// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;
import "hardhat/console.sol";

import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
import '@openzeppelin/contracts/access/Ownable.sol';

contract ArtDistilled is ERC721Enumerable, Ownable {
    using Strings for uint256;

    string _baseTokenURI;

    bool public paused = true;
    bool public onlyWhitelisted = true;
    mapping(address => bool) public whitelistedAddresses;
    mapping(address => uint) public mintedAddress;

    uint256 private _phaseLimit = 2500;
    uint256 private _reserved = 100;
    uint256 private _price = 0.05 ether;
    address private _vault = 0x8c606755f7c9F56b7660615C17e8c3f87d2E7c20;

    constructor(string memory baseURI) ERC721("ArtHouse Spirits", "AHSD")  {
        setBaseURI(baseURI);
    }
    function _baseURI() internal view virtual override returns (string memory) {
        return _baseTokenURI;
    }
    function getPrice() external view returns (uint256){
        return _price;
    }
    function getURI() external view returns (string memory){
        return _baseTokenURI;
    }
    function checkWhitelist(address wallet) external view returns (bool){
        return whitelistedAddresses[wallet];
    }

    function mint(uint256 num) public payable {
        uint256 supply = totalSupply() + 1;
        require(!paused,                                 "Sale paused" );
        require(num <= 3,                                "You can mint a maximum of 3 NFTs" );
        require(mintedAddress[msg.sender] + num <= 3,    "Wallet cant mint only 3 NFTs" );
        require(supply + num < 20000 - _reserved,        "Exceeds maximum NFT supply" );
        require(supply + num < _phaseLimit,              "Can't mint more NFTs in this phase" );
        require(msg.value >= _price * num,               "Ether sent is not correct" );

        if(onlyWhitelisted == true) {
            require(whitelistedAddresses[msg.sender],    "Wallet is not whitelisted");
        }

        for(uint256 i; i < num; i++){
            _safeMint(msg.sender, supply + i );
            mintedAddress[msg.sender] += 1;
        }
        (bool success, bytes memory data) = payable(_vault).call{value: msg.value}("");
        require(success,                                 "Can't transfer money" );

    }
    function walletOfOwner(address _owner) public view returns(uint256[] memory) {
        uint256 tokenCount = balanceOf(_owner);
        uint256[] memory tokensId = new uint256[](tokenCount);
        for(uint256 i; i < tokenCount; i++){
            tokensId[i] = tokenOfOwnerByIndex(_owner, i);
        }
        return tokensId;
    }


    //@dev Owner setting set up
    function giveAway(address _to, uint256 _amount) external onlyOwner() {
        require( _amount <= _reserved, "Exceeds reserved NFT supply" );

        uint256 supply = totalSupply()+1;
        for(uint256 i; i < _amount; i++){
            _safeMint( _to, supply + i );
        }

        _reserved -= _amount;
    }
    function setVaultAddress(address newAddress) external onlyOwner() {
        _vault = newAddress;
    }
    function withdrawAll() external onlyOwner() {
        (bool success, bytes memory data) = payable(_vault).call{value: address(this).balance}("");
        require(success, "Can't transfer" );
    }
    function setPhaseLimit(uint limit) external onlyOwner() {
        _phaseLimit = limit;
    }
    function setBaseURI(string memory baseURI) public onlyOwner() {
        _baseTokenURI = baseURI;
    }
    function setPrice(uint256 newPrice) external onlyOwner() {
        _price = newPrice;
    }
    function setPause(bool newState) external onlyOwner() {
        paused = newState;
    }
    function setOnlyWhitelisted(bool state) external onlyOwner() {
        onlyWhitelisted = state;
    }
    function whitelistUsers(address[] calldata wallets, bool state) external onlyOwner() {
        for(uint256 i; i < wallets.length; i++){
            whitelistedAddresses[wallets[i]] = state;
        }
    }

}