contract Wednesday is ERC721, ERC721Enumerable, ERC721Burnable, Ownable, PaymentSplitter {
    
    using Strings for uint256;
    
    uint256 private _price = 0.006529 ether;

    string public _baseTokenURI = 'https://ipfs.io/ipfs/QmWC4ynsF4Lt6TyAeij4C2WQGbZpF32uK6hm7Y281VcPZi/';
    
    string public PROVENANCE = '';

    uint256 public MAX_TOKENS_PER_TRANSACTION = 20;

    uint256 public MAX_SUPPLY = 6529;

    mapping(uint => string) private _owners;

    // Withdrawal addresses
    address t1 = 0x7305ce3A245168dDc87c3009F0B4b719BC4519F5;
    address t2 = 0xD02bf9b3DA78BEc791014EB3cEecA65990cb046F;

    address[] addressList = [t1, t2];
    uint256[] shareList = [50, 50];

    constructor()
    ERC721("Wednesday", "WED")
    PaymentSplitter(addressList, shareList)
    {}

    // Just in case Eth does some crazy stuff
    function setPrice(uint256 _newPrice) public onlyOwner {
        _price = _newPrice;
    }

    function _baseURI() internal view virtual override returns (string memory) {
        return _baseTokenURI;
    }

    function setBaseURI(string memory _newBaseURI) public onlyOwner {
        _baseTokenURI = _newBaseURI;
    }

    function getPrice() public view returns (uint256){
        return _price;
    }

    function setProvenanceHash(string memory _provenanceHash) public onlyOwner {
        PROVENANCE = _provenanceHash;
    }
    

    function airdrop(address _to, uint256 _tokenId) external onlyOwner {
        uint256 supply = totalSupply();
        require( supply + 1 <= MAX_SUPPLY, "Number of tokens exceeds supply" );
        _safeMint(_to, _tokenId);
    }

    function mint(uint256 _count) public payable {
        uint256 supply = totalSupply();
        require( _count <= MAX_TOKENS_PER_TRANSACTION, "You can mint a maximum of 20 tokens per transaction" );
        require( supply + _count <= MAX_SUPPLY,        "Number of tokens exceeds supply" );
        require( msg.value >= _price * _count,         "Ether sent is not correct" );

        for(uint256 i = 1; i <= _count; i++){
            _safeMint( msg.sender, supply + i );
        }
    }
    
    // The following functions are overrides required by Solidity.
    function _beforeTokenTransfer(address from, address to, uint256 tokenId)
        internal
        override(ERC721, ERC721Enumerable)
    {
        super._beforeTokenTransfer(from, to, tokenId);
    }

    function _burn(uint256 tokenId) internal override(ERC721) {
        super._burn(tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, ERC721Enumerable)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}
function setPrice(uint256 _newPrice) public onlyOwner {
    _price = _newPrice;
}

// Just in case Eth does some crazy stuff