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

interface KateCoin {
    function mint(uint256 amount, address mintFor) external;
}

interface NftInterface {
    function getApproved(uint256 tokenId) external view returns (address);
    function ownerOf(uint256 tokenId) external view returns (address);
    function transferFrom(address from, address to, uint256 tokenId) external;
}

contract NFTBurner {
    address constant DEAD_ADDRESS = 0x000000000000000000000000000000000000dEaD;
    address public nftAddress;
    KateCoin public kateCoin;
    uint256 public interactedTimes = 0;
    uint256 public mintedAmount = 0;
    uint256 public rewardAmount = 10000000000000000000;
    address public owner;

    struct InteractionDetails {
        uint256 interactedTimes;
        uint256 mintedAmount;
    }

    mapping(address => InteractionDetails) public interactions;

    modifier onlyOwner() {
        require(msg.sender == owner, "Caller is not the owner");
        _;
    }

    constructor(KateCoin _kateCoin, address _nftAddress) {
        kateCoin = _kateCoin;
        nftAddress = _nftAddress;
        owner = msg.sender;
    }

    function setRewardAmount(uint256 _rewardAmount) external onlyOwner {
        rewardAmount = _rewardAmount;
    }

    function burnNFT(uint256 tokenId) external {
        NftInterface nft = NftInterface(nftAddress);

        nft.transferFrom(nft.ownerOf(tokenId), DEAD_ADDRESS, tokenId);

        interactedTimes += 1;
        mintedAmount += rewardAmount;
        if (!interactionExists(msg.sender)) {
            interactions[msg.sender] = InteractionDetails({
                interactedTimes: 0,
                mintedAmount: 0
            });
        }
        interactions[msg.sender].interactedTimes += 1;
        interactions[msg.sender].mintedAmount += rewardAmount;

        // Mint the reward tokens
        kateCoin.mint(rewardAmount, msg.sender);
    }

    function interactionExists(address user) internal view returns (bool) {
        return interactions[user].interactedTimes > 0;
    }

    function getValuesAndAddressValues(
        address inputAddress
    ) public view returns (uint256[] memory) {
        uint256[] memory result = new uint256[](4);
        result[0] = interactedTimes;
        result[1] = mintedAmount;
        result[2] = interactions[inputAddress].interactedTimes;
        result[3] = interactions[inputAddress].mintedAmount;
        return result;
    }
}

{
  "compilationTarget": {
    "NFTBurner.sol": "NFTBurner"
  },
  "evmVersion": "london",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}