// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721 {
    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

    event Transfer(address indexed from, address indexed to, uint256 indexed id);

    event Approval(address indexed owner, address indexed spender, uint256 indexed id);

    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /*//////////////////////////////////////////////////////////////
                         METADATA STORAGE/LOGIC
    //////////////////////////////////////////////////////////////*/

    string public name;

    string public symbol;

    function tokenURI(uint256 id) public view virtual returns (string memory);

    /*//////////////////////////////////////////////////////////////
                      ERC721 BALANCE/OWNER STORAGE
    //////////////////////////////////////////////////////////////*/

    mapping(uint256 => address) internal _ownerOf;

    mapping(address => uint256) internal _balanceOf;

    function ownerOf(uint256 id) public view virtual returns (address owner) {
        require((owner = _ownerOf[id]) != address(0), "NOT_MINTED");
    }

    function balanceOf(address owner) public view virtual returns (uint256) {
        require(owner != address(0), "ZERO_ADDRESS");

        return _balanceOf[owner];
    }

    /*//////////////////////////////////////////////////////////////
                         ERC721 APPROVAL STORAGE
    //////////////////////////////////////////////////////////////*/

    mapping(uint256 => address) public getApproved;

    mapping(address => mapping(address => bool)) public isApprovedForAll;

    /*//////////////////////////////////////////////////////////////
                               CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    constructor(string memory _name, string memory _symbol) {
        name = _name;
        symbol = _symbol;
    }

    /*//////////////////////////////////////////////////////////////
                              ERC721 LOGIC
    //////////////////////////////////////////////////////////////*/

    function approve(address spender, uint256 id) public virtual {
        address owner = _ownerOf[id];

        require(msg.sender == owner || isApprovedForAll[owner][msg.sender], "NOT_AUTHORIZED");

        getApproved[id] = spender;

        emit Approval(owner, spender, id);
    }

    function setApprovalForAll(address operator, bool approved) public virtual {
        isApprovedForAll[msg.sender][operator] = approved;

        emit ApprovalForAll(msg.sender, operator, approved);
    }

    function transferFrom(
        address from,
        address to,
        uint256 id
    ) public virtual {
        require(from == _ownerOf[id], "WRONG_FROM");

        require(to != address(0), "INVALID_RECIPIENT");

        require(
            msg.sender == from || isApprovedForAll[from][msg.sender] || msg.sender == getApproved[id],
            "NOT_AUTHORIZED"
        );

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        unchecked {
            _balanceOf[from]--;

            _balanceOf[to]++;
        }

        _ownerOf[id] = to;

        delete getApproved[id];

        emit Transfer(from, to, id);
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 id
    ) public virtual {
        transferFrom(from, to, id);

        require(
            to.code.length == 0 ||
                ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, "") ==
                ERC721TokenReceiver.onERC721Received.selector,
            "UNSAFE_RECIPIENT"
        );
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        bytes calldata data
    ) public virtual {
        transferFrom(from, to, id);

        require(
            to.code.length == 0 ||
                ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, data) ==
                ERC721TokenReceiver.onERC721Received.selector,
            "UNSAFE_RECIPIENT"
        );
    }

    /*//////////////////////////////////////////////////////////////
                              ERC165 LOGIC
    //////////////////////////////////////////////////////////////*/

    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return
            interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
            interfaceId == 0x80ac58cd || // ERC165 Interface ID for ERC721
            interfaceId == 0x5b5e139f; // ERC165 Interface ID for ERC721Metadata
    }

    /*//////////////////////////////////////////////////////////////
                        INTERNAL MINT/BURN LOGIC
    //////////////////////////////////////////////////////////////*/

    function _mint(address to, uint256 id) internal virtual {
        require(to != address(0), "INVALID_RECIPIENT");

        require(_ownerOf[id] == address(0), "ALREADY_MINTED");

        // Counter overflow is incredibly unrealistic.
        unchecked {
            _balanceOf[to]++;
        }

        _ownerOf[id] = to;

        emit Transfer(address(0), to, id);
    }

    function _burn(uint256 id) internal virtual {
        address owner = _ownerOf[id];

        require(owner != address(0), "NOT_MINTED");

        // Ownership check above ensures no underflow.
        unchecked {
            _balanceOf[owner]--;
        }

        delete _ownerOf[id];

        delete getApproved[id];

        emit Transfer(owner, address(0), id);
    }

    /*//////////////////////////////////////////////////////////////
                        INTERNAL SAFE MINT LOGIC
    //////////////////////////////////////////////////////////////*/

    function _safeMint(address to, uint256 id) internal virtual {
        _mint(to, id);

        require(
            to.code.length == 0 ||
                ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, "") ==
                ERC721TokenReceiver.onERC721Received.selector,
            "UNSAFE_RECIPIENT"
        );
    }

    function _safeMint(
        address to,
        uint256 id,
        bytes memory data
    ) internal virtual {
        _mint(to, id);

        require(
            to.code.length == 0 ||
                ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, data) ==
                ERC721TokenReceiver.onERC721Received.selector,
            "UNSAFE_RECIPIENT"
        );
    }
}

/// @notice A generic interface for a contract which properly accepts ERC721 tokens.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721TokenReceiver {
    function onERC721Received(
        address,
        address,
        uint256,
        bytes calldata
    ) external virtual returns (bytes4) {
        return ERC721TokenReceiver.onERC721Received.selector;
    }
}

// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.23;

// https://iamnotgoodatcomputer.com/

import "@solmate/tokens/ERC721.sol";
import "@solmate/auth/Owned.sol";
import "@solmate/utils/ReentrancyGuard.sol";
import "@solmate/utils/LibString.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";

interface IHypercards {
    function getUserTokens(
        address user
    ) external view returns (uint256[] memory);

    function balanceOf(
        address account,
        uint256 id
    ) external view returns (uint256);
}

contract IANGAC is ERC721, Owned, ReentrancyGuard {
    IHypercards public hyperCardsContract;
    address public payoutAddress;

    uint256 public constant FULL_PRICE = 0.015 ether;
    uint256 public constant DISCOUNTED_PRICE = 0.01 ether;
    uint256 public constant CARDS_FOR_DISCOUNT = 4;
    uint256 public constant MAX_SUPPLY = 10000;
    uint256 public constant ROYALTY_PERCENTAGE = 500; // 5% royalty
    string private _baseURI;
    uint256 public totalSupply;

    mapping(address => mapping(uint256 => bool))
        public usedHyperCardForDiscount;

    event IANGACMinted(address indexed to, uint256 tokenId, bool discounted);
    event HyperCardsUsedForDiscount(address indexed user, uint256[] cardIds);

    error InsufficientPayment();
    error UserDoesNotOwnHyperCard();
    error NotEnoughHyperCardsForDiscount(uint256 required, uint256 available);
    error NotEligibleForDiscountedIANGAC();
    error HyperCardAlreadyUsedForDiscount();
    error MaxSupplyReached();
    error InvalidTokenId();

    modifier withinMaxSupply() {
        if (totalSupply >= MAX_SUPPLY) revert MaxSupplyReached();
        _;
    }

    constructor(
        address _hyperCardsAddress,
        string memory baseURI,
        address _payoutAddress
    ) ERC721("IANGAC", "IANGAC") Owned(msg.sender) {
        hyperCardsContract = IHypercards(_hyperCardsAddress);
        _baseURI = baseURI;
        payoutAddress = _payoutAddress;
    }

    function setHyperCardsAddress(
        address _hyperCardsAddress
    ) external onlyOwner {
        hyperCardsContract = IHypercards(_hyperCardsAddress);
    }

    function setPayoutAddress(address _newPayoutAddress) external onlyOwner {
        payoutAddress = _newPayoutAddress;
    }

    function getPotentialDiscountEligibility(
        address user,
        uint256[] memory ownedHyperCardIds
    ) public view returns (bool) {
        uint256 eligibleCards = 0;

        for (uint256 i = 0; i < ownedHyperCardIds.length; i++) {
            uint256 cardId = ownedHyperCardIds[i];
            if (hyperCardsContract.balanceOf(user, cardId) == 0) {
                return false;
            }

            if (!usedHyperCardForDiscount[user][cardId]) {
                eligibleCards++;
            }
        }

        return eligibleCards >= CARDS_FOR_DISCOUNT;
    }

    // Mint a full price IANGAC for a given tokenId.
    // Nice if you know the tokenId but don't want to mess around with the discounts,
    //  or just want to mint directly.
    function mintIANGAC(
        uint256 tokenId
    ) external payable withinMaxSupply nonReentrant {
        if (tokenId < 1 || tokenId > MAX_SUPPLY) revert InvalidTokenId();
        if (msg.value < FULL_PRICE) revert InsufficientPayment();

        _mint(msg.sender, tokenId);
        totalSupply++;
        emit IANGACMinted(msg.sender, tokenId, false);

        if (msg.value > FULL_PRICE) {
            payable(msg.sender).transfer(msg.value - FULL_PRICE);
        }
    }

    function mintDiscountedIANGAC(
        uint256 tokenId
    ) external payable withinMaxSupply nonReentrant {
        if (tokenId < 1 || tokenId > MAX_SUPPLY) revert InvalidTokenId();
        uint256[] memory hyperCardIds = getEligibleTokenIds(msg.sender);

        if (hyperCardIds.length < CARDS_FOR_DISCOUNT)
            revert NotEnoughHyperCardsForDiscount(
                CARDS_FOR_DISCOUNT,
                hyperCardIds.length
            );
        if (msg.value < DISCOUNTED_PRICE) revert InsufficientPayment();

        for (uint256 i = 0; i < CARDS_FOR_DISCOUNT; i++) {
            uint256 cardId = hyperCardIds[i];
            if (usedHyperCardForDiscount[msg.sender][cardId])
                revert HyperCardAlreadyUsedForDiscount();
        }

        bool isEligible = getPotentialDiscountEligibility(
            msg.sender,
            hyperCardIds
        );
        if (!isEligible) revert NotEligibleForDiscountedIANGAC();

        for (uint256 i = 0; i < CARDS_FOR_DISCOUNT; i++) {
            uint256 cardId = hyperCardIds[i];
            usedHyperCardForDiscount[msg.sender][cardId] = true;
        }

        _mint(msg.sender, tokenId);
        totalSupply++;
        emit IANGACMinted(msg.sender, tokenId, true);
        emit HyperCardsUsedForDiscount(msg.sender, hyperCardIds);

        if (msg.value > DISCOUNTED_PRICE) {
            payable(msg.sender).transfer(msg.value - DISCOUNTED_PRICE);
        }
    }

    function withdraw() external onlyOwner {
        uint256 balance = address(this).balance;
        payable(payoutAddress).transfer(balance);
    }

    function tokenURI(uint256 id) public view override returns (string memory) {
        return string(abi.encodePacked(_baseURI, LibString.toString(id)));
    }

    function royaltyInfo(
        uint256 tokenId,
        uint256 salePrice
    ) external view returns (address receiver, uint256 royaltyAmount) {
        uint256 royalty = (salePrice * ROYALTY_PERCENTAGE) / 10000;
        return (payoutAddress, royalty);
    }

    function supportsInterface(
        bytes4 interfaceId
    ) public view virtual override returns (bool) {
        return
            interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
            interfaceId == 0x80ac58cd || // ERC165 Interface ID for ERC721
            interfaceId == 0x5b5e139f || // ERC165 Interface ID for ERC721Metadata
            interfaceId == type(IERC2981).interfaceId;
    }

    function getEligibleTokenIds(
        address user
    ) public view returns (uint256[] memory) {
        uint256[] memory userTokens = hyperCardsContract.getUserTokens(user);
        uint256[] memory tempEligibleTokens = new uint256[](userTokens.length);
        uint256 eligibleCount = 0;

        for (uint256 i = 0; i < userTokens.length; i++) {
            uint256 cardId = userTokens[i];
            if (
                hyperCardsContract.balanceOf(user, cardId) > 0 &&
                !usedHyperCardForDiscount[user][cardId]
            ) {
                tempEligibleTokens[eligibleCount] = cardId;
                eligibleCount++;
            }
        }

        // Create a new array with the exact size of eligible tokens
        uint256[] memory eligibleTokens = new uint256[](eligibleCount);
        for (uint256 i = 0; i < eligibleCount; i++) {
            eligibleTokens[i] = tempEligibleTokens[i];
        }

        return eligibleTokens;
    }

    function getAvailableDiscountedMints(
        address user
    ) public view returns (uint256) {
        uint256[] memory eligibleTokens = getEligibleTokenIds(user);
        return eligibleTokens.length / CARDS_FOR_DISCOUNT;
    }

    // A non-error throwing way to check if a token is minted.
    function isTokenMinted(uint256 tokenId) public view returns (bool) {
        return _ownerOf[tokenId] != address(0);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC2981.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../utils/introspection/IERC165.sol";

/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 */
interface IERC2981 is IERC165 {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
     */
    function royaltyInfo(
        uint256 tokenId,
        uint256 salePrice
    ) external view returns (address receiver, uint256 royaltyAmount);
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

/// @notice Efficient library for creating string representations of integers.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol)
/// @author Modified from Solady (https://github.com/Vectorized/solady/blob/main/src/utils/LibString.sol)
library LibString {
    function toString(int256 value) internal pure returns (string memory str) {
        if (value >= 0) return toString(uint256(value));

        unchecked {
            str = toString(uint256(-value));

            /// @solidity memory-safe-assembly
            assembly {
                // Note: This is only safe because we over-allocate memory
                // and write the string from right to left in toString(uint256),
                // and thus can be sure that sub(str, 1) is an unused memory location.

                let length := mload(str) // Load the string length.
                // Put the - character at the start of the string contents.
                mstore(str, 45) // 45 is the ASCII code for the - character.
                str := sub(str, 1) // Move back the string pointer by a byte.
                mstore(str, add(length, 1)) // Update the string length.
            }
        }
    }

    function toString(uint256 value) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            // The maximum value of a uint256 contains 78 digits (1 byte per digit), but we allocate 160 bytes
            // to keep the free memory pointer word aligned. We'll need 1 word for the length, 1 word for the
            // trailing zeros padding, and 3 other words for a max of 78 digits. In total: 5 * 32 = 160 bytes.
            let newFreeMemoryPointer := add(mload(0x40), 160)

            // Update the free memory pointer to avoid overriding our string.
            mstore(0x40, newFreeMemoryPointer)

            // Assign str to the end of the zone of newly allocated memory.
            str := sub(newFreeMemoryPointer, 32)

            // Clean the last word of memory it may not be overwritten.
            mstore(str, 0)

            // Cache the end of the memory to calculate the length later.
            let end := str

            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            // prettier-ignore
            for { let temp := value } 1 {} {
                // Move the pointer 1 byte to the left.
                str := sub(str, 1)

                // Write the character to the pointer.
                // The ASCII index of the '0' character is 48.
                mstore8(str, add(48, mod(temp, 10)))

                // Keep dividing temp until zero.
                temp := div(temp, 10)

                 // prettier-ignore
                if iszero(temp) { break }
            }

            // Compute and cache the final total length of the string.
            let length := sub(end, str)

            // Move the pointer 32 bytes leftwards to make room for the length.
            str := sub(str, 32)

            // Store the string's length at the start of memory allocated for our string.
            mstore(str, length)
        }
    }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Simple single owner authorization mixin.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Owned.sol)
abstract contract Owned {
    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

    event OwnershipTransferred(address indexed user, address indexed newOwner);

    /*//////////////////////////////////////////////////////////////
                            OWNERSHIP STORAGE
    //////////////////////////////////////////////////////////////*/

    address public owner;

    modifier onlyOwner() virtual {
        require(msg.sender == owner, "UNAUTHORIZED");

        _;
    }

    /*//////////////////////////////////////////////////////////////
                               CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    constructor(address _owner) {
        owner = _owner;

        emit OwnershipTransferred(address(0), _owner);
    }

    /*//////////////////////////////////////////////////////////////
                             OWNERSHIP LOGIC
    //////////////////////////////////////////////////////////////*/

    function transferOwnership(address newOwner) public virtual onlyOwner {
        owner = newOwner;

        emit OwnershipTransferred(msg.sender, newOwner);
    }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Gas optimized reentrancy protection for smart contracts.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/ReentrancyGuard.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol)
abstract contract ReentrancyGuard {
    uint256 private locked = 1;

    modifier nonReentrant() virtual {
        require(locked == 1, "REENTRANCY");

        locked = 2;

        _;

        locked = 1;
    }
}

{
  "compilationTarget": {
    "src/IANGAC.sol": "IANGAC"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [
    ":@openzeppelin/=lib/openzeppelin-contracts/",
    ":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    ":@solmate/=lib/solmate/src/",
    ":ds-test/=lib/solmate/lib/ds-test/src/",
    ":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    ":forge-std/=lib/forge-std/src/",
    ":openzeppelin-contracts/=lib/openzeppelin-contracts/",
    ":solmate/=lib/solmate/src/"
  ]
}