// SPDX-License-Identifier: MIT

pragma solidity ^0.8.19;

import { IENSResolver } from "@interfaces/IENSResolver.sol";
import { IENSRegistry } from "@interfaces/IENSRegistry.sol";
import { ENSNamehash } from "./ENSNamehash.sol";
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { TornadoAddresses } from "@proprietary/TornadoAddresses.sol";

contract GoerliTestProposal is Ownable, TornadoAddresses {
    address internal ensResolverAddress = 0xd7a4F6473f32aC2Af804B3686AE8F1932bC35750; // goerli ENS resolver
    address internal ensRegistryAddress = 0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e;
    string testDomain = "tornadotest.eth";
    bytes32 testNode = calculateDomainNode(testDomain);

    IENSResolver ensResolver = IENSResolver(ensResolverAddress);
    IENSRegistry ensRegistry = IENSRegistry(ensRegistryAddress);

    function transferDomainOwnership(address to) public onlyOwner {
        _transferDomainOwnership(testNode, to);
    }

    function transferSubdomainOwnership(string memory domain, string memory subdomainLabel, address to) public onlyOwner {
        _transferSubdomainOwnership(domain, subdomainLabel, to);
    }

    function registerSubname(string memory domain, string memory subdomainLabel) public onlyOwner {
        bytes32 rootNode = calculateDomainNode(domain);
        address rootResolver = ensRegistry.resolver(rootNode);
        bytes32 subdomainLabelhash = calculateSubdomainLabelhash(subdomainLabel);

        ensRegistry.setSubnodeRecord(rootNode, subdomainLabelhash, address(this), rootResolver, 0);
    }

    function _transferDomainOwnership(bytes32 domainNode, address to) private {
        require(ensRegistry.owner(domainNode) == address(this), "This test contract must be an owner of domain");
        ensRegistry.setOwner(domainNode, to);
    }

    function _transferSubdomainOwnership(string memory domain, string memory subdomainLabel, address to) private {
        bytes32 rootNode = calculateDomainNode(domain);
        bytes32 subdomainLabelhash = calculateSubdomainLabelhash(subdomainLabel);
        bytes32 subdomainNode = keccak256(abi.encodePacked(rootNode, subdomainLabelhash));
        require(ensRegistry.recordExists(subdomainNode), "Subdomain not registered");
        require(ensRegistry.owner(rootNode) == address(this), "This test contract must be an owner of domain");

        ensRegistry.setSubnodeOwner(rootNode, subdomainLabelhash, to);
    }

    function setNewDomain(string memory newDomain) public onlyOwner {
        bytes32 newNode = ENSNamehash.namehash(bytes(newDomain));
        require(ensRegistry.recordExists(newNode), "Node doesn't exist");
        require(ensRegistry.owner(newNode) == address(this), "Contract is not an owner of new ENS name");
        transferDomainOwnership(owner());

        testDomain = newDomain;
        testNode = newNode;
    }

    function calculateDomainNode(string memory domain) internal pure returns (bytes32) {
        return ENSNamehash.namehash(bytes(domain));
    }

    function calculateSubdomainLabelhash(string memory subdomainLabel) internal pure returns (bytes32) {
        return keccak256(bytes(subdomainLabel));
    }

    function ownSubdomain(string memory domain, string memory subdomainLabel) public {
        _transferSubdomainOwnership(domain, subdomainLabel, address(this));
    }

    function setClassicUiIpfs() public {
        bytes memory classicUiIPFSContenthash = hex"e301017012203c89ba6bfdeb8d7209463006e620ee6dcb34675cf3202f20919e3a5f9919070d";

        ensResolver.setContenthash(testNode, classicUiIPFSContenthash);
    }

    function setNovaIpfs() public {
        bytes memory novaUiIPFSContenthash = hex"e3010170122069648b09fb7ed9a89ca153a000bc8c1bf82a779195a640609e1510dc36c28bb7";

        ensResolver.setContenthash(testNode, novaUiIPFSContenthash);
    }

    function setRelayersNetworkIpfs() public {
        bytes memory relayersUiIPFSContenthash = hex"e301017012203d61bed0641d7c53d5f036b6448f9d455ae6e0ceda44563009536a12e51d52cf";

        ensResolver.setContenthash(testNode, relayersUiIPFSContenthash);
    }

    function setDocsIpfs() public {
        bytes memory docsIPFSContenthash = hex"e301017012201e6facc47ac27a4072b3ba19e716c0db37cbd29b40b23f3af8a85412ef45be08";

        ensResolver.setContenthash(testNode, docsIPFSContenthash);
    }

    function setStakingAddress(string memory domain) public {
        ensResolver.setAddr(calculateDomainNode(domain), stakingAddress);
    }
}