// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "../HasSignature.sol";

interface IMintableERC1155 is IERC1155 {
    function mintBatch(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) external;

    function burn(
        address owner,
        uint256 tokenId,
        uint256 amount
    ) external;
}


contract BEChipFactory is Ownable, Initializable, HasSignature {
    IMintableERC1155 public chip;

    address public executor;

    mapping(bytes => bool) public usedSignatures;

    event Chip1155Minted(
        address contractAddress,
        address indexed to,
        uint256[] ids
    );


    constructor() HasSignature("BEChipFactory", "1") {}

    function init(address _erc1155)
        external
        initializer
        onlyOwner
    {
        chip = IMintableERC1155(_erc1155);
    }

    /**
     * @dev update executor
     */
    function updateExecutor(address account) external onlyOwner {
        require(account != address(0), "address can not be zero");
        executor = account;
    }

    function mintChipTo(
        address to,
        uint256[] memory ids
    ) external onlyOwner {
        require(to != address(0), "to address can not be zero");
        uint256[] memory amounts = new uint256[](ids.length);
        uint256 len = ids.length;
        for (uint256 i = 0; i < len; ++i) {
            amounts[i] = 1;
        }
        chip.mintBatch(to, ids, amounts, "");
        emit Chip1155Minted(address(chip), to, ids);
    }

    function mintChipSelf(
        uint256[] memory ids,
        uint256 saltNonce,
        bytes calldata signature
    ) external{
        address to = _msgSender();
        bytes32 criteriaMessageHash = getMessageHash(
            to,
            saltNonce,
            ids
        );
        checkSigner(executor, criteriaMessageHash, signature);
        uint256[] memory amounts = new uint256[](ids.length);
        uint256 len = ids.length;
        for (uint256 i = 0; i < len; ++i) {
            amounts[i] = 1;
        }
        chip.mintBatch(to, ids, amounts, "");
        usedSignatures[signature] = true;
        emit Chip1155Minted(address(chip), to, ids);
    }


    function getMessageHash(
        address _to,
        uint256 _saltNonce,
        uint256[] memory _ids
    ) public pure returns (bytes32) {
        bytes memory encoded = abi.encodePacked(_to, _saltNonce);
        uint256 len = _ids.length;
        for (uint256 i = 0; i < len; ++i) {
            encoded = bytes.concat(
                encoded,
                abi.encodePacked(_ids[i])
            );
        }
        return keccak256(encoded);
    }
}