import {ethers} from "ethers";
import {getProvider, getSigner} from "./blockchain.js";
import {chainInfo} from "./chain.js";
import {mockERC20Contract, newContract} from "./contract.js";
import {metadata} from "./metadata.js";


export async function gib( chainId, owner, vault, tokenAmounts ) {
    try {
        return await doGib( chainId, owner, vault, tokenAmounts )
    }
    catch (e) {
        console.error('gib failed', e)
    }
}


export async function doGib( chainId, owner, vault, tokenAmounts ) {
    if (!owner || !vault) return
    if (chainId === 421614) {
        // Arbitrum-Sepolia
        // Find the USDC mock coin and print 10k
        for (const t of metadata[421614].t) {
            if (t.s === 'USDC' && t.x.mock) {
                // print 10,000 USDC
                const signer = getSigner(421614);
                const usdc = await newContract(t.a, 'MockERC20', signer)
                await usdc.mint(vault, 10_000_000000)
                console.log(`minted 10,000 USDC to ${vault}`)
            }
        }
        return
    }
    if( (chainId === 31337 || chainId === 1337) ) {
        const provider = getProvider(chainId);
        let faucet = new ethers.Wallet(
            // Dev Account #8
            '0xdbda1821b80551c9d65939329250298aa3472ba22feea921c0cf5d620ea67b97',
            provider
        )
        const address = faucet.address;
        faucet = new ethers.NonceManager(faucet)
        let nonce = await provider.getTransactionCount(address, 'pending')
        const signer = await provider.getSigner()  // regular server signer not the #8 faucet
        for (const [token, amount] of Object.entries(tokenAmounts)) {
            // if (!(token in mock_token_decimals)) {
            //     const contract = erc20(chainId, token)
            //     mock_token_decimals[token] = Number(await contract.decimals())
            // }
            // const bAmount = BigInt(Math.trunc(amount * 10**mock_token_decimals[token]))
            if (token==='native') {
                console.log(`faucet sending native coin to ${owner} +${amount}`)
                await faucet.sendTransaction({to:owner, value:amount, nonce: nonce++})
            }
            else {
                console.log(`sending ${token} coin to ${vault} +${amount}`)
                await (await mockERC20Contract(token,signer)).mint(vault, amount)
            }
        }

        if (chainId === 31337) {
            const info = chainInfo[chainId]
            if (info.mockCoins) {
                const [coinAddr, usdAddr] = info.mockCoins
                const signer = await provider.getSigner()
                if (tokenAmounts['MEH'] > 0) {
                    const amount = BigInt(tokenAmounts['MEH']);
                    console.log(`faucet minting ${amount} MEH to`, vault)
                    const token = await mockERC20Contract(coinAddr, signer);
                    await token.mint(vault, amount * 10n ** 18n)
                }
                if (tokenAmounts['USXD'] > 0) {
                    const amount = BigInt(tokenAmounts['USXD']);
                    console.log(`faucet minting ${amount} USXD to`, vault)
                    const token = await mockERC20Contract(usdAddr, signer);
                    await token.mint(vault, amount * 10n ** 6n)
                }
            }
        }
    }
}