import {ethers} from "ethers";
import {getAbi} from "./abi.js";
import {getProvider, getSigner} from "./blockchain.js";
import {vaultBalances, vaults} from './cache.js';
import {chainInfo, VAULT_INIT_CODE_HASH} from "./chain.js";
import {sendVaultOrders} from "./order.js";

// Vault
//   address owner
//   balances { tokenAddress: amount }
//   recentOrders []

const vaultAbi = await getAbi('Vault')
const factoryAbi = await getAbi('Factory')


export function vaultAddress(chainId, owner, num=0) {
    try {
        const salt = ethers.solidityPackedKeccak256(['address','uint8'],[owner,num])
        const result = ethers.getCreate2Address(chainInfo[chainId].factory, salt, VAULT_INIT_CODE_HASH)
        // console.log('vaultAddress', chainId, owner, num, chainInfo[chainId].factory, salt, VAULT_INIT_CODE_HASH, result)
        return result
    }
    catch (e) {
        console.error('Could not generate vault address',chainId,owner,num)
        return null
    }
}


async function emitBalances(socket, chainId, vault) {
    const balances = await vaultBalances.get(chainId, vault);
    socket.emit('vb', chainId, vault, balances !== null ? balances : '{}')
    return balances;
}


export async function loginAddress(socket, chainId, address) {
    if( socket.user_room !== undefined)
        socket.leave(socket.user_room)
    if( address === undefined ) {
        socket.emit('vaults', chainId, address, [])
    }
    else {
        socket.user_room = `${chainId}|${address}`
        socket.join(socket.user_room)
        console.log('joined room', socket.user_room)
        const found = []
        for( let num = 0; ; num++ ) {
            const vault = vaultAddress(chainId, address, num)
            if(vault !== null && await vaults.contains(chainId, vault)) {
                found.push(vault)
                const balances = await emitBalances(socket, chainId, vault);
                console.log('found vault', vault, balances)
            }
            else
                break
        }
        socket.emit('vaults', chainId, address, found)
        for( const vault of found )
            sendVaultOrders(socket, chainId, vault)
    }
}


export async function ensureVault(socket, chainId, owner, num) {
    if( !(chainId in chainInfo) )
        return
    console.log('ensureVault', chainId, owner, num)
    const address = vaultAddress(chainId, owner, num)
    if (!await vaults.contains(chainId,address)) {
        try {
            const vault = await createVault(chainId, owner, num)
            console.log(vault)
            if (vault !== null) {
                socket.emit('vaults', chainId, owner, [vault])
                await emitBalances(socket, chainId, vault)
            }
            else
                console.error('got null vault for chainId', chainId)
        } catch {
        }
    }
    else
        console.log('ensureVault', owner, 'exists:', address)
}


async function createVault(chainId, owner, num) {
    console.log('createVault', chainId, owner, num )
    const signer = getSigner(chainId);
    const deployer = new ethers.Contract(chainInfo[chainId].factory, factoryAbi, signer)
    const addr = vaultAddress(chainId, owner, num)
    try {
        const tx = await deployer.deployVault(owner, num)
        // console.log(`deploying vault for ${owner} #${num} with tx ${tx.hash}`)
        await tx.wait()
    }
    catch (e) {
        const vault = new ethers.Contract(addr, vaultAbi, getProvider(chainId))
        try {
            const ver = await vault.version()
            console.log(`vault already deployed at ${addr} with version ${ver}`)
        }
        catch (e2) {
            console.error('could not deploy vault:',e)
            return null
        }
    }
    return addr
}