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

import {ERC721Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import {AccessControlUpgradeable} from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import {CountersUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import {ECDSAUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol";
import {IERC5192} from "./IERC5192.sol";
import {IInvictusOrderApplication} from "./IInvictusOrderApplication.sol";

/// @title Invictus Order Soulbound Tokens
/// @author Kfish n Chips
/// @custom:security-contact security@kfishnchips.com
contract InvictusOrderApplication is
    Initializable,
    UUPSUpgradeable,
    ERC721Upgradeable,
    AccessControlUpgradeable,
    IERC5192,
    IInvictusOrderApplication
{
    using CountersUpgradeable for CountersUpgradeable.Counter;

    /// @notice Minter Role
    /// @dev Will be granted to the Orchestrator
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    /// @notice  Upgrader Role
    bytes32 public constant UPGRADER_ROLE = keccak256("UPGRADER_ROLE");
    /// @notice Token ID counter
    CountersUpgradeable.Counter private _tokenIdCounter;
    /// @notice base URI used to retrieve metadata
    /// @dev tokenURI will use .json at the end for each token
    string public baseURI;
    /// @notice Enable/disable tokens transfer
    bool private _tokenLocked;
    /// @notice Backend signer address
    address internal signer;
    /// @notice Contract owner
    address public owner;
    /// @notice Keep track of minters
    mapping(bytes32 => bool) private hashes;

    /// @notice Emitted when the token transfer status change.
    event ToggleTokenLocked(address sender, bool state);
    /// @notice Emitted when the baseURI change.
    event BaseURIChanged(
        address indexed sender,
        string previousURI,
        string newURI
    );
     /// @notice Emitted when signer change.
    event SignerChanged(
        address indexed sender,
        address previousSigner,
        address newSigner
    );

    /// @notice enable/disable Token Transfer
    /// Emits an {ToggleTokenLocked} event.
    function toggleTokenLocked() external onlyRole(DEFAULT_ADMIN_ROLE) {
        _tokenLocked = !_tokenLocked;
        emit ToggleTokenLocked(msg.sender, _tokenLocked);
    }

    /// @notice Used to set the signer
    /// @param _signer the new signer
    /// Emits an {SignerChanged} event.
    function setSigner(address _signer)
        external
        onlyRole(DEFAULT_ADMIN_ROLE)
    {
        if (_signer == address(0)) revert AddressZero();
        emit SignerChanged(msg.sender, signer, _signer);
        signer = _signer;
    }

    /// @notice Used to set the baseURI for metadata
    /// @param newBaseURI the base URI
    /// Emits an {BaseURIChanged} event.
    function setBaseURI(string memory newBaseURI)
        external
        onlyRole(DEFAULT_ADMIN_ROLE)
    {
        if (bytes(newBaseURI).length == 0) revert InvalidBaseURI();
        emit BaseURIChanged(msg.sender, baseURI, newBaseURI);
        baseURI = newBaseURI;
    }

    /// @notice Safely mints and transfers it to `msg.sender`.
    /// @param messageHash Hashed application
    /// @param _v Recovery value + 27
    /// @param _r First 32 bytes of the signature
    /// @param _s Next 32 bytes of the signature
    /// Emits a {Transfer} event.
    function mint(bytes32 messageHash, uint8 _v, bytes32 _r, bytes32 _s) external {
        if(hashes[messageHash]) revert AlreadyMinted();
        address _signer = ECDSAUpgradeable.recover(messageHash, _v, _r, _s);

        if(signer != _signer) revert InvalidSender();
        hashes[messageHash] = true;
        uint256 tokenId = _tokenIdCounter.current();
        _tokenIdCounter.increment();
        _safeMint(msg.sender, tokenId);

        if (_tokenLocked) emit Locked(tokenId);
        else emit Unlocked(tokenId);
    }

    /// @notice Mint to a specific address
    /// @dev Requires MINTER_ROLE
    /// @param to the receiver address
    function mintTo(address to) external onlyRole(MINTER_ROLE) {
        uint256 tokenId = _tokenIdCounter.current();
        _tokenIdCounter.increment();
        _safeMint(to, tokenId);
        if (_tokenLocked) emit Locked(tokenId);
        else emit Unlocked(tokenId);
    }

    /// @inheritdoc	IERC5192
    function locked(uint256 tokenId) external view returns (bool) {
        if (!_exists(tokenId)) revert InvalidTokenID();
        return _tokenLocked;
    }

    /// @notice Total supply minted
    function totalSupply() external view returns (uint256) {
        return _tokenIdCounter.current() - 1;
    }

    function initialize(address _signer, string memory _newBaseURI) public initializer {
        __AccessControl_init_unchained();
        __ERC721_init_unchained("Invictus Order Application", "IOAPP");
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(MINTER_ROLE, msg.sender);
        _grantRole(UPGRADER_ROLE, msg.sender);
        baseURI = _newBaseURI;
        signer = _signer;
        _tokenLocked = true;
        _tokenIdCounter.increment();
        transferOwnership(msg.sender);
    }

    /// @notice Approve operator for a token
    /// @dev overriden to avoid approvals for SBT
    function approve(address to, uint256 tokenId) public virtual override {
        if (_tokenLocked) revert ApprovalNotAllowed();
        super.approve(to, tokenId);
    }

    /// @notice Ownership Transfer
    /// @dev owner is only used because some marketplaces require it
    /// Emits an {OwnershipTransferred} event.
    function transferOwnership(address _owner) public onlyRole(DEFAULT_ADMIN_ROLE) {
        if (_owner == address(0) || _owner == address(this)) revert InvalidAddress();
        address previousOwner = owner;
        owner = _owner;

        emit OwnershipTransferred(previousOwner, _owner);
    }

    /// @notice Approve operator for an address
    /// @dev overriden to avoid approvals for SBT
    function setApprovalForAll(address operator, bool approved)
        public
        virtual
        override
    {
        if (_tokenLocked) revert ApprovalNotAllowed();
        super.setApprovalForAll(operator, approved);
    }

    /// @notice Override of ERC721, AccessControl supportsInterface function
    /// @param _interfaceId the interfaceId
    /// @return bool if interfaceId is supported or not
    function supportsInterface(bytes4 _interfaceId)
        public
        view
        override(ERC721Upgradeable, AccessControlUpgradeable)
        returns (bool)
    {
        bytes4 interfaceIDIERC5192 = 0xb45a3c0e;
        return
            _interfaceId == interfaceIDIERC5192 ||
            super.supportsInterface(_interfaceId);
    }

    /// @notice Hook to check whether a key is transferrable
    /// @dev admins can always transfer regardless of whether keys are flagged
    /// @param _from address that holds the tokenId
    /// @param _to address that will receive the tokenId
    /// @param _startTokenId index of first tokenId that will be transferred
    /// @param _quantity amount that will be transferred
    function _beforeTokenTransfer(
        address _from,
        address _to,
        uint256 _startTokenId,
        uint256 _quantity
    ) internal override {
        if (_tokenLocked && _from != address(0))
            revert TransferNotAllowed();
        super._beforeTokenTransfer(_from, _to, _startTokenId, _quantity);
    }

    /// @inheritdoc	ERC721Upgradeable
    function _baseURI() internal view override returns (string memory) {
        return baseURI;
    }

    /// @inheritdoc UUPSUpgradeable
    function _authorizeUpgrade(address newImplementation) // solhint-disable-line
        internal
        virtual
        override
        onlyRole(UPGRADER_ROLE)
    {} // solhint-disable-line
}