import { ethers } from 'ethers';

// Demo configuration - In production, these should be securely managed
const RPC_URLS: Record<string, string> = {
    ETH: 'https://rpc.ankr.com/eth',
    POLYGON: 'https://rpc.ankr.com/polygon',
    BSC: 'https://rpc.ankr.com/bsc'
};

// AyrisSplitter Contract Address (Example addresses, in production use real deployed addresses)
const SPLITTER_ADDRESSES: Record<string, string> = {
    POLYGON: '0x999...AYRIS_SPLITTER_POLYGON',
    ETH: '0x888...AYRIS_SPLITTER_ETH'
};

// ERC20 ABI for checking USDT/USDC balances
const ERC20_ABI = [
    "function balanceOf(address owner) view returns (uint256)",
    "function decimals() view returns (uint8)",
    "function symbol() view returns (string)"
];

const STABLECOIN_ADDRESSES: Record<string, Record<string, string>> = {
    POLYGON: {
        USDT: '0xc2132D05D31c914a87C6611C10748AEb04B58e8F',
        USDC: '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359'
    },
    ETH: {
        USDT: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
        USDC: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'
    }
};

export class CryptoEngine {
    private provider: ethers.JsonRpcProvider;
    private network: string;

    constructor(network: string = 'POLYGON') {
        this.network = network;
        this.provider = new ethers.JsonRpcProvider(RPC_URLS[network]);
    }

    /**
     * Generates a temporary wallet for a transaction.
     */
    static async createTemporaryWallet(): Promise<ethers.Wallet> {
        return ethers.Wallet.createRandom();
    }

    /**
     * Sweeps funds from temporary wallet to Platform and Merchant
     */
    async sweepFunds(
        tempWalletPrivateKey: string,
        merchantAddress: string,
        platformAddress: string,
        tokenSymbol: string = 'USDT'
    ) {
        const tempWallet = new ethers.Wallet(tempWalletPrivateKey, this.provider);
        const tokenAddress = STABLECOIN_ADDRESSES[this.network][tokenSymbol];
        const contract = new ethers.Contract(tokenAddress, ERC20_ABI, tempWallet);

        const balance = await contract.balanceOf(tempWallet.address);
        if (balance === 0n) throw new Error("Balance is zero");

        const platformShare = (balance * 100n) / 10000n; // %1
        const merchantShare = balance - platformShare; // %99

        console.log(`[Sweep] Total: ${ethers.formatUnits(balance, 6)} ${tokenSymbol}`);
        console.log(`[Sweep] Sending ${ethers.formatUnits(platformShare, 6)} to Platform...`);
        console.log(`[Sweep] Sending ${ethers.formatUnits(merchantShare, 6)} to Merchant...`);

        // In reality, we'd send 2 transactions here.
        // For the demo, we simulate success.
        return {
            success: true,
            platformTx: '0x' + Math.random().toString(16).slice(2, 66),
            merchantTx: '0x' + Math.random().toString(16).slice(2, 66)
        };
    }

    /**
     * Verifies if a specific amount has arrived at the address.
     */
    async verifyPayment(address: string, expectedAmount: string, tokenSymbol?: string): Promise<{
        success: boolean;
        txHash?: string;
        error?: string;
    }> {
        try {
            if (!tokenSymbol || tokenSymbol === 'ETH' || tokenSymbol === 'MATIC') {
                const balance = await this.provider.getBalance(address);
                const balanceInEth = ethers.formatEther(balance);
                
                if (parseFloat(balanceInEth) >= parseFloat(expectedAmount)) {
                    return { success: true };
                }
            } else {
                // Check ERC20 balance (USDT/USDC)
                const network = 'POLYGON'; // Default for demo
                const tokenAddress = STABLECOIN_ADDRESSES[network][tokenSymbol];
                if (!tokenAddress) throw new Error("Unsupported token");

                const contract = new ethers.Contract(tokenAddress, ERC20_ABI, this.provider);
                const balance = await contract.balanceOf(address);
                const decimals = await contract.decimals();
                const formattedBalance = ethers.formatUnits(balance, decimals);

                if (parseFloat(formattedBalance) >= parseFloat(expectedAmount)) {
                    return { success: true };
                }
            }

            return { success: false };
        } catch (error: any) {
            return { success: false, error: error.message };
        }
    }
}