// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";

contract BEBadge is AccessControl, ERC721Enumerable {
  mapping(uint256 => bool) public lockedTokens;
  string private _baseTokenURI = "https://market.cebg.games/api/nft/info/";
  bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
  bytes32 public constant BURN_ROLE = keccak256("BURN_ROLE");
  bytes32 public constant LOCK_ROLE = keccak256("LOCK_ROLE");
  uint256 public immutable supplyLimit;

  event Lock(uint256 indexed tokenId);
  event UnLock(uint256 indexed tokenId);
  event BatchMint(address indexed to, uint256[] tokenIds);

  constructor(
    string memory name_,
    string memory symbol_,
    uint256 supplyLimt_
  ) ERC721(name_, symbol_) {
    _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
    _setupRole(MINTER_ROLE, msg.sender);
    _setupRole(BURN_ROLE, msg.sender);
    _setupRole(LOCK_ROLE, msg.sender);
    supplyLimit = supplyLimt_;
  }

  function _baseURI() internal view virtual override returns (string memory) {
    return _baseTokenURI;
  }

  /**
   * @dev Creates a new token for `to`. Its token ID will be automatically
   * assigned (and available on the emitted {IERC721-Transfer} event), and the token
   * URI autogenerated based on the base URI passed at construction.
   *
   * See {ERC721-_mint}.
   *
   * Requirements:
   *
   * - the caller must have the `MINTER_ROLE`.
   */
  function mint(
    address to,
    uint256 tokenId
  ) external virtual onlyRole(MINTER_ROLE) {
    if (supplyLimit > 0) {
      require(totalSupply() < supplyLimit, "Exceed the total supply");
    }
    _mint(to, tokenId);
  }

  /**
   * @dev Batch mint tokens and transfer to specified address.
   *
   * Requirements:
   * - Caller must have `MINTER_ROLE`.
   * - The total supply limit should not be exceeded.
   * - The number of tokenIds offered for minting should not exceed 100.
   */

  function batchMint(
    address to,
    uint256[] calldata tokenIds
  ) external onlyRole(MINTER_ROLE) {
    if (supplyLimit > 0) {
      require(
        (totalSupply() + tokenIds.length) <= supplyLimit,
        "Exceed the total supply"
      );
    }
    require(tokenIds.length <= 100, "tokenIds too many");
    for (uint256 i = 0; i < tokenIds.length; i++) {
      _mint(to, tokenIds[i]);
    }
    emit BatchMint(to, tokenIds);
  }

  /**
   * @dev Grant mint role to address
   */
  function setMintRole(address to) external {
    grantRole(MINTER_ROLE, to);
  }

  /**
   * @dev Remove mint role to address
   */
  function removeMintRole(address to) external {
    revokeRole(MINTER_ROLE, to);
  }

  /**
   * @dev grant burn role to address
   */
  function setBurnRole(address to) external {
    grantRole(BURN_ROLE, to);
  }

  /**
   * @dev Remove burn role to address
   */
  function removeBurnRole(address proxy) external {
    revokeRole(BURN_ROLE, proxy);
  }

  /**
   * @dev Add address for lock item
   */
  function grantLockRole(address to) external {
    grantRole(LOCK_ROLE, to);
  }

  /**
   * @dev Remove address for lock item
   */
  function removeLockRole(address account) external {
    revokeRole(LOCK_ROLE, account);
  }

  /**
   * @dev Lock token to use in game or for rental
   */
  function lock(uint256 tokenId) external onlyRole(LOCK_ROLE) {
    require(_exists(tokenId), "Must be valid tokenId");
    require(!lockedTokens[tokenId], "Token has already locked");
    lockedTokens[tokenId] = true;
    emit Lock(tokenId);
  }

  /**
   * @dev Unlock token to use blockchain or sale on marketplace
   */
  function unlock(uint256 tokenId) external onlyRole(LOCK_ROLE) {
    require(_exists(tokenId), "Must be valid tokenId");
    require(lockedTokens[tokenId], "Token has already unlocked");
    lockedTokens[tokenId] = false;
    emit UnLock(tokenId);
  }

  /**
   * @dev Get lock status
   */
  function isLocked(uint256 tokenId) external view returns (bool) {
    return lockedTokens[tokenId];
  }

  /**
   * @dev Set token URI
   */
  function updateBaseURI(
    string calldata baseTokenURI
  ) external onlyRole(DEFAULT_ADMIN_ROLE) {
    _baseTokenURI = baseTokenURI;
  }

  /**
   * @dev See {IERC165-_beforeTokenTransfer}.
   */
  function _beforeTokenTransfer(
    address from,
    address to,
    uint256 tokenId
  ) internal virtual override(ERC721Enumerable) {
    require(!lockedTokens[tokenId], "Can not transfer locked token");
    super._beforeTokenTransfer(from, to, tokenId);
  }

  /**
   * @dev See {IERC165-supportsInterface}.
   */
  function supportsInterface(
    bytes4 interfaceId
  )
    public
    view
    virtual
    override(AccessControl, ERC721Enumerable)
    returns (bool)
  {
    return super.supportsInterface(interfaceId);
  }

  /**
   * @dev Burns `tokenId`.
   *
   * Requirements:
   *
   * - The caller must own `tokenId` or be an approved operator.
   */
  function burn(
    address owner,
    uint256 tokenId
  ) external virtual onlyRole(BURN_ROLE) {
    require(_exists(tokenId), "TokenId not exists");
    require(!lockedTokens[tokenId], "Can not burn locked token");
    require(
      ownerOf(tokenId) == owner,
      "current address is not owner of this item now"
    );
    _burn(tokenId);
  }
}