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 name() external view returns (string memory) {
  return _name;
}

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

function tokenURI(uint256 _tokenId) external view returns (string memory) {
  if (bytes(baseURI).length == 0) {
    return "";
  }

  require(
    _exists(_tokenId),
    "ERC721Metadata: received a URI query for a nonexistent token"
  );
  return
    string(
      abi.encodePacked(baseURI, _toLowerCase(subdomains[bytes32(_tokenId)]))
    );
}

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

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 migrateNames(
  bytes32[] calldata _names,
  address[] calldata _beneficiaries,
  uint256[] calldata _createdDates
) external onlyOwner isNotMigrated {
  for (uint256 i = 0; i < _names.length; i++) {
    string memory name = _bytes32ToString(_names[i]);
    _register(
      name,
      keccak256(abi.encodePacked(_toLowerCase(name))),
      _beneficiaries[i],
      _createdDates[i]
    );
  }
}

function register(string calldata _subdomain, address _beneficiary)
  external
  onlyController
  isMigrated
{
  // Make sure this contract owns the domain
  _checkOwnerOfDomain();
  // Create labelhash for the subdomain
  bytes32 subdomainLabelHash = keccak256(
    abi.encodePacked(_toLowerCase(_subdomain))
  );
  // Make sure it is free
  require(_available(subdomainLabelHash), "Subdomain already owned");
  // solium-disable-next-line security/no-block-members
  _register(_subdomain, subdomainLabelHash, _beneficiary, now);
}

function reclaim(uint256 _tokenId) public onlyController {
  address owner = ownerOf(_tokenId);

  registry.setSubnodeOwner(
    domainNameHash,
    bytes32(_tokenId),
    ownerOf(_tokenId)
  );

  emit Reclaimed(msg.sender, owner, _tokenId);
}

function reclaim(uint256 _tokenId, address _owner) public {
  // Check if the sender is authorized to manage the subdomain
  require(
    _isApprovedOrOwner(msg.sender, _tokenId),
    "Only an authorized account can change the subdomain settings"
  );

  registry.setSubnodeOwner(domainNameHash, bytes32(_tokenId), _owner);

  emit Reclaimed(msg.sender, _owner, _tokenId);
}

function onERC721Received(
  address, /* _operator */
  address, /* _from */
  uint256 _tokenId,
  bytes memory /* _data */
) public returns (bytes4) {
  require(
    msg.sender == address(base),
    "Only base can send NFTs to this contract"
  );

  // Re-claim to update the owner at the ENS Registry
  base.reclaim(_tokenId, address(this));
  return ERC721_RECEIVED;
}

function available(string memory _subdomain) public view returns (bool) {
  // Create labelhash for the subdomain
  bytes32 subdomainLabelHash = keccak256(
    abi.encodePacked(_toLowerCase(_subdomain))
  );
  return _available(subdomainLabelHash);
}

function getTokenId(string memory _subdomain) public view returns (uint256) {
  string memory subdomain = _toLowerCase(_subdomain);
  bytes32 subdomainLabelHash = keccak256(abi.encodePacked(subdomain));
  uint256 tokenId = uint256(subdomainLabelHash);

  require(_exists(tokenId), "The subdomain is not registered");

  return tokenId;
}

function getOwnerOf(string memory _subdomain) public view returns (address) {
  return ownerOf(getTokenId(_subdomain));
}

function reclaimDomain(uint256 _tokenId) public onlyOwner {
  base.reclaim(_tokenId, address(this));

  emit DomainReclaimed(_tokenId);
}

function transferDomainOwnership(address _owner, uint256 _tokenId)
  public
  onlyOwner
{
  base.transferFrom(address(this), _owner, _tokenId);
  emit DomainTransferred(_owner, _tokenId);
}

function setResolver(address _resolver) public onlyOwner {
  address resolver = registry.resolver(domainNameHash);

  require(_resolver.isContract(), "New resolver should be a contract");
  require(_resolver != resolver, "New resolver should be different from old");

  _checkNotAllowedAddresses(_resolver);

  registry.setResolver(domainNameHash, _resolver);

  emit ResolverUpdated(resolver, _resolver);
}

function forwardToResolver(bytes memory _data) public onlyOwner {
  address resolver = registry.resolver(domainNameHash);

  _checkNotAllowedAddresses(resolver);

  (bool success, bytes memory res) = resolver.call(_data);

  require(success, "Call failed");

  // Make sure this contract is still the owner of the domain
  _checkOwnerOfDomain();

  emit CallForwarwedToResolver(resolver, _data, res);
}

function addController(address controller) external onlyOwner {
  require(!controllers[controller], "The controller was already added");
  controllers[controller] = true;
  emit ControllerAdded(controller);
}

function removeController(address controller) external onlyOwner {
  require(controllers[controller], "The controller is already disabled");
  controllers[controller] = false;
  emit ControllerRemoved(controller);
}

function updateRegistry(IENSRegistry _registry) public onlyOwner {
  require(registry != _registry, "New registry should be different from old");
  require(address(_registry).isContract(), "New registry should be a contract");

  emit RegistryUpdated(registry, _registry);

  registry = _registry;
}

function updateBase(IBaseRegistrar _base) public onlyOwner {
  require(base != _base, "New base should be different from old");
  require(address(_base).isContract(), "New base should be a contract");

  emit BaseUpdated(base, _base);

  base = _base;
}

function updateBaseURI(string memory _baseURI) public onlyOwner {
  require(
    keccak256(abi.encodePacked((baseURI))) !=
      keccak256(abi.encodePacked((_baseURI))),
    "Base URI should be different from old"
  );
  emit BaseURI(baseURI, _baseURI);
  baseURI = _baseURI;
}

function migrationFinished() external onlyOwner isNotMigrated {
  migrated = true;
  emit MigrationFinished();
}