#!/usr/bin/env python3
"""
Test ENS Resolver

This script tests the ENS resolver with known ENS names and addresses.

Usage:
    python test_ens_resolver.py
"""

import os
import sys
from dotenv import load_dotenv

# Add parent directory to path to import utils
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from utils.ens_resolver import ENSResolver
from utils.logger import setup_logger
from web3 import Web3

# Load environment variables
load_dotenv()

# Setup logging
logger = setup_logger("test_ens_resolver")

def test_ens_resolver():
    """
    Test the ENS resolver with known ENS names and addresses.
    """
    logger.info("Testing ENS resolver")
    
    # Initialize Web3 and ENS resolver
    alchemy_api_key = os.getenv("ALCHEMY_API_KEY")
    if not alchemy_api_key:
        logger.error("ALCHEMY_API_KEY not found in environment variables")
        sys.exit(1)
        
    web3 = Web3(Web3.HTTPProvider(f"https://eth-mainnet.g.alchemy.com/v2/{alchemy_api_key}"))
    ens_resolver = ENSResolver(web3)
    
    # Test cases - known ENS names and addresses
    test_cases = [
        # Vitalik's ENS
        {"address": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045", "expected_ens": "vitalik.eth"},
        # ENS DAO
        {"address": "0x4f3a120E72C76c22ae802D129F599BFDbc31cb81", "expected_ens": "ens.eth"},
        # Brantly.eth
        {"address": "0x983110309620D911731Ac0932219af06091b6744", "expected_ens": "brantly.eth"},
        # Nick.eth
        {"address": "0xb8c2C29ee19D8307cb7255e1Cd9CbDE883A267d5", "expected_ens": "nick.eth"}
    ]
    
    # Test address to ENS resolution
    logger.info("Testing address to ENS resolution")
    for test_case in test_cases:
        address = test_case["address"]
        expected_ens = test_case["expected_ens"]
        
        try:
            resolved_ens = ens_resolver.get_ens_name(address)
            if resolved_ens:
                logger.info(f"✅ Address {address} resolved to {resolved_ens}")
                if resolved_ens.lower() == expected_ens.lower():
                    logger.info(f"✅ Matches expected ENS {expected_ens}")
                else:
                    logger.warning(f"❌ Does not match expected ENS {expected_ens}")
            else:
                logger.warning(f"❌ Could not resolve ENS for address {address}")
        except Exception as e:
            logger.error(f"Error resolving ENS for {address}: {str(e)}")
    
    # Test ENS to address resolution
    logger.info("\nTesting ENS to address resolution")
    for test_case in test_cases:
        address = test_case["address"]
        ens_name = test_case["expected_ens"]
        
        try:
            resolved_address = ens_resolver.get_ens_address(ens_name)
            if resolved_address:
                logger.info(f"✅ ENS {ens_name} resolved to {resolved_address}")
                if resolved_address.lower() == address.lower():
                    logger.info(f"✅ Matches expected address {address}")
                else:
                    logger.warning(f"❌ Does not match expected address {address}")
            else:
                logger.warning(f"❌ Could not resolve address for ENS {ens_name}")
        except Exception as e:
            logger.error(f"Error resolving address for {ens_name}: {str(e)}")
    
    # Test ENS profile retrieval
    logger.info("\nTesting ENS profile retrieval")
    for test_case in test_cases:
        ens_name = test_case["expected_ens"]
        
        try:
            profile = ens_resolver.get_ens_profile(ens_name)
            if profile:
                logger.info(f"✅ Retrieved profile for {ens_name}:")
                for key, value in profile.items():
                    if value:
                        logger.info(f"  - {key}: {value}")
            else:
                logger.warning(f"❌ Could not retrieve profile for {ens_name}")
        except Exception as e:
            logger.error(f"Error retrieving profile for {ens_name}: {str(e)}")
    
    logger.info("ENS resolver testing completed")

if __name__ == "__main__":
    test_ens_resolver()