// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import { ContractMetadata } from "../metadata/ContractMetadata.sol";
import { ERC1155Base } from "../token/ERC1155/ERC1155Base.sol";
import { ERC1155Cementable } from "../token/ERC1155/ERC1155Cementable.sol";
import { ERC1155Burnable } from "../token/ERC1155/extensions/ERC1155Burnable.sol";
import { ERC1155Freezable } from "../token/ERC1155/extensions/ERC1155Freezable.sol";
import { Ownable, Ownable2Step } from "@openzeppelin/contracts/access/Ownable2Step.sol";
import { ERC1155 as ERC1155OpenZeppelin } from "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import { ERC2981 } from "@openzeppelin/contracts/token/common/ERC2981.sol";

contract SimpleERC1155 is Ownable2Step, ContractMetadata, ERC2981, ERC1155Cementable, ERC1155Burnable, ERC1155Freezable {
    uint256 internal _nextTokenId;
    mapping(uint256 => mapping(address => bool)) internal _minters;

    modifier onlyMinter(uint256 _tokenId) {
        require(_minters[_tokenId][_msgSender()], "Invalid minter");
        _;
    }

    constructor(
        address _defaultRoyaltyReceiver,
        uint96 _defaultRoyaltyFeeNumerator
    ) ERC1155OpenZeppelin("") Ownable(_msgSender()) {
        _nextTokenId = 1;
        _setDefaultRoyalty(_defaultRoyaltyReceiver, _defaultRoyaltyFeeNumerator);
    }

    function create(string calldata _metadata, bool _cemented, address _minter) external onlyOwner returns (uint256) {
        uint256 _tokenId = _nextTokenId;
        _setTokenMetadata(_tokenId, _metadata);
        if (_cemented) {
            _tokenMetadataCemented[_tokenId] = true;
        }
        if (_minter != address(0)) {
            _minters[_tokenId][_minter] = true;
        }
        _nextTokenId++;
        return _tokenId;
    }

    function mint(address _to, uint256 _tokenId, uint256 _amount) public virtual onlyMinter(_tokenId) {
        require(_exists(_tokenId), "Invalid tokenId");
        _mint(_to, _tokenId, _amount, "");
    }

    function grantMinter(uint256 _tokenId, address _minter) external onlyOwner {
        _minters[_tokenId][_minter] = true;
    }

    function revokeMinter(uint256 _tokenId, address _minter) external onlyOwner {
        delete _minters[_tokenId][_minter];
    }

    function renounceMinter(uint256 _tokenId) external onlyOwner {
        delete _minters[_tokenId][_msgSender()];
    }

    function uri(
        uint256 _tokenId
    ) public view override(ERC1155OpenZeppelin, ERC1155Cementable) returns (string memory) {
        return _uri(_tokenId);
    }

    function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) external onlyOwner {
        _setDefaultRoyalty(_receiver, _feeNumerator);
    }

    function setTokenRoyalty(uint256 _tokenId, address _receiver, uint96 _feeNumerator) external onlyOwner {
        _setTokenRoyalty(_tokenId, _receiver, _feeNumerator);
    }

    function _canSetContractMetadata() internal view override returns (bool) {
        return owner() == _msgSender();
    }

    /// @dev Returns whether token metadata can be set in the given execution context.
    function _canSetTokenMetadata(uint256) internal view override returns (bool) {
        return owner() == _msgSender();
    }

    function supportsInterface(
        bytes4 interfaceId
    ) public view virtual override(ERC1155Burnable, ERC1155Freezable, ERC1155OpenZeppelin, ERC2981) returns (bool) {
        return super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {ERC1155-_update}.
     */
    function _update(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values
    ) internal virtual override(ERC1155Base, ERC1155Freezable) {
        super._update(from, to, ids, values);
    }
}