// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

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

interface IMetabolts {

    function mintMTBT(
        address _account, 
        uint256 _numberOfTokens, 
        uint256 _privateCount
    ) external;

    function setPrivateCount(
        uint256 _count
    ) external;

    function reserveCount() external view returns (uint256);
    function mintIndex() external view returns (uint256);
    function privateCount() external view returns (uint256);
    function startingIndex() external view returns (uint256);
}

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

/*
888b     d888          888             888               888 888             888b     d888 d8b          888    888     888  .d8888b.  
8888b   d8888          888             888               888 888             8888b   d8888 Y8P          888    888     888 d88P  Y88b 
88888b.d88888          888             888               888 888             88888b.d88888              888    888     888        888 
888Y88888P888  .d88b.  888888  8888b.  88888b.   .d88b.  888 888888 .d8888b  888Y88888P888 888 88888b.  888888 Y88b   d88P      .d88P 
888 Y888P 888 d8P  Y8b 888        "88b 888 "88b d88""88b 888 888    88K      888 Y888P 888 888 888 "88b 888     Y88b d88P   .od888P"  
888  Y8P  888 88888888 888    .d888888 888  888 888  888 888 888    "Y8888b. 888  Y8P  888 888 888  888 888      Y88o88P   d88P"      
888   "   888 Y8b.     Y88b.  888  888 888 d88P Y88..88P 888 Y88b.       X88 888   "   888 888 888  888 Y88b.     Y888P    888"       
888       888  "Y8888   "Y888 "Y888888 88888P"   "Y88P"  888  "Y888  88888P' 888       888 888 888  888  "Y888     Y8P     888888888
*/                                                                                                             


import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

import "./IMetabolts.sol";

contract MetaboltsMintV2 is Ownable, ReentrancyGuard{

    IMetabolts immutable public nftContract;

    bool public isPublicMint = true;   
    uint256 public publicPrice = 0.08 ether;
    uint256 public publicMaxMintLimit = 30;

    event MintPublic(address indexed _account, uint256 _count);
    
    constructor(address _nftAddress){
        nftContract = IMetabolts(_nftAddress);
    }

    receive() payable external {
    }

    // @dev Withdraws ethers
    // @param _walletAddress The wallet address
    function withdraw(address _walletAddress) external onlyOwner {
        uint256 balance = address(this).balance;
        payable(_walletAddress).transfer(balance);
    }

    
    // @dev Public Mints NFTs
    // @param _amount The amount of NFTs
    function mintPublic(uint256 _amount) payable external nonReentrant{
        require(isPublicMint, "MetaboltsMintV2: public mint is not open");
        require(_amount > 0 && _amount <= publicMaxMintLimit, "MetaboltsMintV2: invalid amount");

        require(msg.value >= (publicPrice*_amount), "MetaboltsMintV2: invalid value");

        nftContract.mintMTBT(msg.sender, _amount, 0);

        emit MintPublic(msg.sender, _amount);
    }


    function _getTotalMinted() internal view returns(uint256){
        return nftContract.reserveCount()+nftContract.privateCount()+nftContract.mintIndex();
    }

    // @dev Returns the status of the metabolts
    // @return The status of the metabolts
    function getMetaboltsMintStatus() external view returns(bool, uint256){
        uint256 totalMinted = _getTotalMinted();
        return (isPublicMint, totalMinted);
    }

    // @dev Sets the mint price
    // @param _publicPrice The public price
    function setMintPrice(uint256 _publicPrice) external onlyOwner {
        publicPrice = _publicPrice;
    }

    // @dev Sets the stage
    // @param _isPublicMint The activation of the public mint
    function setStage(bool _isPublicMint) external onlyOwner {
        isPublicMint = _isPublicMint;
    }

    // @dev Sets the max mint limit
    // @param _maxMintLimit The max mint limit per tx of the public mint
    function setMaxMintLimit(uint256 _maxMintLimit) external onlyOwner {
        publicMaxMintLimit = _maxMintLimit;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

{
  "compilationTarget": {
    "contracts/MetaboltsMintV2.sol": "MetaboltsMintV2"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}