function owner() public view returns (address) {
  return _owner;
}

function isOwner() public view returns (bool) {
  return _msgSender() == _owner;
}

function renounceOwnership() public onlyOwner {
  emit OwnershipTransferred(_owner, address(0));
  _owner = address(0);
}

function transferOwnership(address newOwner) public onlyOwner {
  _transferOwnership(newOwner);
}

function balanceOf(address owner) public view returns (uint256) {
  require(owner != address(0), "ERC721: balance query for the zero address");

  return _ownedTokensCount[owner].current();
}

function ownerOf(uint256 tokenId) public view returns (address) {
  address owner = _tokenOwner[tokenId];
  require(owner != address(0), "ERC721: owner query for nonexistent token");

  return owner;
}

function safeTransferFrom(
  address from,
  address to,
  uint256 tokenId
) public {
  safeTransferFrom(from, to, tokenId, "");
}

function transferFrom(
  address from,
  address to,
  uint256 tokenId
) public {
  //solhint-disable-next-line max-line-length
  require(
    _isApprovedOrOwner(_msgSender(), tokenId),
    "ERC721: transfer caller is not owner nor approved"
  );

  _transferFrom(from, to, tokenId);
}

function approve(address to, uint256 tokenId) public {
  address owner = ownerOf(tokenId);
  require(to != owner, "ERC721: approval to current owner");

  require(
    _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
    "ERC721: approve caller is not owner nor approved for all"
  );

  _tokenApprovals[tokenId] = to;
  emit Approval(owner, to, tokenId);
}

function getApproved(uint256 tokenId) public view returns (address) {
  require(_exists(tokenId), "ERC721: approved query for nonexistent token");

  return _tokenApprovals[tokenId];
}

function setApprovalForAll(address to, bool approved) public {
  require(to != _msgSender(), "ERC721: approve to caller");

  _operatorApprovals[_msgSender()][to] = approved;
  emit ApprovalForAll(_msgSender(), to, approved);
}

function isApprovedForAll(address owner, address operator)
  public
  view
  returns (bool)
{
  return _operatorApprovals[owner][operator];
}

function safeTransferFrom(
  address from,
  address to,
  uint256 tokenId,
  bytes memory _data
) public {
  require(
    _isApprovedOrOwner(_msgSender(), tokenId),
    "ERC721: transfer caller is not owner nor approved"
  );
  _safeTransferFrom(from, to, tokenId, _data);
}

function supportsInterface(bytes4 interfaceId) external view returns (bool) {
  return _supportedInterfaces[interfaceId];
}

function burn(uint256 tokenId) public {
  //solhint-disable-next-line max-line-length
  require(
    _isApprovedOrOwner(_msgSender(), tokenId),
    "ERC721Burnable: caller is not owner nor approved"
  );
  _burn(tokenId);
}

function isMinter(address account) public view returns (bool) {
  return _minters.has(account);
}

function addMinter(address account) public onlyMinter {
  _addMinter(account);
}

function renounceMinter() public {
  _removeMinter(_msgSender());
}

function name() external view returns (string memory) {
  return _name;
}

function symbol() external view returns (string memory) {
  return _symbol;
}

function tokenURI(uint256 _tokenId) public view returns (string memory) {
  return Strings.strConcat(baseUri, items[_tokenId].metaId);
}

function mintWithTokenURI(
  address to,
  uint256 tokenId,
  string memory tokenURI
) public onlyMinter returns (bool) {
  _mint(to, tokenId);
  _setTokenURI(tokenId, tokenURI);
  return true;
}

function totalSupply() public view returns (uint256) {
  return _allTokens.length;
}

function tokenOfOwnerByIndex(address owner, uint256 index)
  public
  view
  returns (uint256)
{
  require(
    index < balanceOf(owner),
    "ERC721Enumerable: owner index out of bounds"
  );
  return _ownedTokens[owner][index];
}

function tokenByIndex(uint256 index) public view returns (uint256) {
  require(
    index < totalSupply(),
    "ERC721Enumerable: global index out of bounds"
  );
  return _allTokens[index];
}

function setTokenState(uint256[] memory ids, bool isEnabled) public onlyMinter {
  for (uint256 i = 0; i < ids.length; i++) {
    if (isEnabled == true) {
      items[ids[i]].state = TokenState.ForSale;
    } else {
      items[ids[i]].state = TokenState.Pending;
    }
  }
  emit BatchForSale(ids, items[ids[0]].metaId);
}

function setTokenPrice(uint256[] memory ids, uint256 setPrice)
  public
  onlyMinter
{
  for (uint256 i = 0; i < ids.length; i++) {
    items[ids[i]].price = setPrice;
  }
}

function buyThing(uint256 _tokenId) public payable returns (bool) {
  require(msg.value >= items[_tokenId].price, "Price issue");
  require(TokenState.ForSale == items[_tokenId].state, "No Sale");

  if (items[_tokenId].price >= 0) {
    uint256 fee = mintbaseFee(msg.value);
    uint256 withFee = SafeMath.sub(msg.value, fee);

    maker.transfer(withFee);
    feeAddress.transfer(fee);
  }

  _transferFrom(maker, msg.sender, _tokenId);
  items[_tokenId].state = TokenState.Sold;

  emit Bought(_tokenId, items[_tokenId].metaId, msg.value);
}

function destroyAndSend() public onlyOwner {
  emit Destroy();
  selfdestruct(maker);
}

function batchTransfer(
  address giver,
  address[] memory recipients,
  uint256[] memory values
) public {
  for (uint256 i = 0; i < values.length; i++) {
    transferFrom(giver, recipients[i], values[i]);
    items[values[i]].state = TokenState.Transferred;
  }
  emit BatchTransfered(items[values[0]].metaId, recipients, values);
}

function batchMint(
  address to,
  uint256 amountToMint,
  string memory metaId,
  uint256 setPrice,
  bool isForSale
) public onlyMinter {
  require(amountToMint <= 40, "Over 40");

  for (uint256 i = 0; i < amountToMint; i++) {
    id = id.add(1);
    items[id].price = setPrice;
    items[id].metaId = metaId;
    if (isForSale == true) {
      items[id].state = TokenState.ForSale;
    } else {
      items[id].state = TokenState.Pending;
    }
    _mint(to, id);
    emit Minted(id, metaId);
  }
}

function batchBurn(uint256[] memory tokenIds) public onlyMinter {
  for (uint256 i = 0; i < tokenIds.length; i++) {
    _burn(tokenIds[i]);
  }
  emit BatchBurned(items[tokenIds[0]].metaId, tokenIds);
}

function tokensOfOwner(address owner) public view returns (uint256[] memory) {
  return _tokensOfOwner(owner);
}