import * as Env from 'dotenv';
Env.config();
import {
  findLargestTokenAccountForOwner,
  getMultipleAccounts,
  IDS,
  MangoClient,
  MangoGroup,
  MarginAccount,
  nativeToUi,
  NUM_MARKETS,
  NUM_TOKENS, parseTokenAccount,
  parseTokenAccountData, tokenToDecimals, uiToNative,
} from '@blockworks-foundation/mango-client';
import { Account, Connection, PublicKey, Transaction, TransactionSignature } from '@solana/web3.js';
import fs from 'fs';
import { Market } from '@project-serum/serum';
import { notify, sleep } from './utils';
import { homedir } from 'os';
import {
  makeForceCancelOrdersInstruction,
  makePartialLiquidateInstruction,
} from '@blockworks-foundation/mango-client/lib/instruction';


async function drainAccount(
  client: MangoClient,
  connection: Connection,
  programId: PublicKey,
  mangoGroup: MangoGroup,
  ma: MarginAccount,
  markets: Market[],
  payer: Account,
  prices: number[],
  usdWallet: PublicKey
) {
  // Cancel all open orders
  const bidsPromises = markets.map((market) => market.loadBids(connection))
  const asksPromises = markets.map((market) => market.loadAsks(connection))
  const books = await Promise.all(bidsPromises.concat(asksPromises))
  const bids = books.slice(0, books.length / 2)
  const asks = books.slice(books.length / 2, books.length)

  const cancelProms: Promise<TransactionSignature[]>[] = []
  for (let i = 0; i < NUM_MARKETS; i++) {
    cancelProms.push(ma.cancelAllOrdersByMarket(connection, client, programId, mangoGroup, markets[i], bids[i], asks[i], payer))
  }

  await Promise.all(cancelProms)
  console.log('all orders cancelled')

  ma = await client.getMarginAccount(connection, ma.publicKey, mangoGroup.dexProgramId)
  await client.settleAll(connection, programId, mangoGroup, ma, markets, payer)
  console.log('settleAll complete')
  await sleep(2000)
  ma = await client.getMarginAccount(connection, ma.publicKey, mangoGroup.dexProgramId)

  // sort non-quote currency assets by value
  const assets = ma.getAssets(mangoGroup)
  const liabs = ma.getLiabs(mangoGroup)

  const netValues: [number, number][] = []

  for (let i = 0; i < NUM_TOKENS - 1; i++) {
    netValues.push([i, (assets[i] - liabs[i]) * prices[i]])
  }

  // Sort by those with largest net deposits and sell those first before trying to buy back the borrowed
  netValues.sort((a, b) => (b[1] - a[1]))

  for (let i = 0; i < NUM_TOKENS - 1; i++) {
    const marketIndex = netValues[i][0]
    const market = markets[marketIndex]
    const tokenDecimals = mangoGroup.getTokenDecimals(marketIndex)
    const tokenDecimalAdj = Math.pow(10, tokenDecimals)

    if (netValues[i][1] > 0) { // sell to close
      const price = prices[marketIndex] * 0.95
      const size = Math.floor(assets[marketIndex] * tokenDecimalAdj) / tokenDecimalAdj  // round down the size
      if (size === 0) {
        continue
      }
      console.log(`Sell to close ${marketIndex} ${size}`)
      await client.placeOrder(connection, programId, mangoGroup, ma, market, payer, 'sell', price, size, 'limit')

    } else if (netValues[i][1] < 0) { // buy to close
      const price = prices[marketIndex] * 1.05  // buy at up to 5% higher than oracle price
      const size = Math.ceil(liabs[marketIndex] * tokenDecimalAdj) / tokenDecimalAdj

      console.log(`Buy to close ${marketIndex} ${size}`)
      await client.placeOrder(connection, programId, mangoGroup, ma, market, payer, 'buy', price, size, 'limit')
    }
  }

  await sleep(3000)
  ma = await client.getMarginAccount(connection, ma.publicKey, mangoGroup.dexProgramId)
  await client.settleAll(connection, programId, mangoGroup, ma, markets, payer)
  console.log('settleAll complete')
  ma = await client.getMarginAccount(connection, ma.publicKey, mangoGroup.dexProgramId)
  console.log('Liquidation process complete\n', ma.toPrettyString(mangoGroup, prices))

  console.log('Withdrawing USD')

  await client.withdraw(connection, programId, mangoGroup, ma, payer, mangoGroup.tokens[NUM_TOKENS-1], usdWallet, ma.getUiDeposit(mangoGroup, NUM_TOKENS-1) * 0.999)
  console.log('Successfully drained account', ma.publicKey.toString())
}

async function runLiquidator() {
  const client = new MangoClient()
  const cluster = process.env.CLUSTER || 'mainnet-beta'
  const group_name = process.env.GROUP_NAME || 'BTC_ETH_SOL_SRM_USDT'
  const clusterUrl = process.env.CLUSTER_URL || IDS.cluster_urls[cluster]
  const connection = new Connection(clusterUrl, 'singleGossip')

  // The address of the Mango Program on the blockchain
  const programId = new PublicKey(IDS[cluster].mango_program_id)

  // The address of the serum dex program on the blockchain: https://github.com/project-serum/serum-dex
  const dexProgramId = new PublicKey(IDS[cluster].dex_program_id)

  // Address of the MangoGroup
  const mangoGroupPk = new PublicKey(IDS[cluster].mango_groups[group_name].mango_group_pk)

  // liquidator's keypair
  const keyPairPath = process.env.KEYPAIR || homedir() + '/.config/solana/id.json'
  const payer = new Account(JSON.parse(fs.readFileSync(keyPairPath, 'utf-8')))

  notify(`liquidator launched cluster=${cluster} group=${group_name}`);

  let mangoGroup = await client.getMangoGroup(connection, mangoGroupPk)

  const tokenWallets = (await Promise.all(
    mangoGroup.tokens.map(
      (mint) => findLargestTokenAccountForOwner(connection, payer.publicKey, mint).then(
        (response) => response.publicKey
      )
    )
  ))

  // load all markets
  const markets = await Promise.all(mangoGroup.spotMarkets.map(
    (pk) => Market.load(connection, pk, {skipPreflight: true, commitment: 'singleGossip'}, dexProgramId)
  ))
  const sleepTime = 5000
  // TODO handle failures in any of the steps
  // Find a way to get all margin accounts without querying fresh--get incremental updates to margin accounts

  while (true) {
    try {
      mangoGroup = await client.getMangoGroup(connection, mangoGroupPk)
      let marginAccounts = process.env.FILTER_ACCOUNTS ? 
        await client.getAllMarginAccountsWithBorrows(connection, programId, mangoGroup) :
        await client.getAllMarginAccounts(connection, programId, mangoGroup)

      let [prices, vaultAccs, liqorAccs] = await Promise.all([
        mangoGroup.getPrices(connection),
        getMultipleAccounts(connection, mangoGroup.vaults),
        getMultipleAccounts(connection, tokenWallets),
      ])

      const vaultValues = vaultAccs.map(
        (a, i) => nativeToUi(parseTokenAccountData(a.accountInfo.data).amount, mangoGroup.mintDecimals[i])
      )
      const liqorTokenUi = liqorAccs.map(
        (a, i) => nativeToUi(parseTokenAccountData(a.accountInfo.data).amount, mangoGroup.mintDecimals[i])
      )

      console.log(prices)
      console.log(vaultValues)

      let maxBorrAcc = ""
      let maxBorrVal = 0;
      for (let ma of marginAccounts) {  // parallelize this if possible

        let liquidated = false
        let description = ''
        try {
          const assetsVal = ma.getAssetsVal(mangoGroup, prices)
          const liabsVal = ma.getLiabsVal(mangoGroup, prices)
          if (liabsVal > maxBorrVal) {
            maxBorrVal = liabsVal
            maxBorrAcc = ma.publicKey.toBase58()
          }

          if (liabsVal < 0.1) {  // too small of an account; number precision may cause errors
            continue
          }
          let collRatio = (assetsVal / liabsVal)

          // FIXME: added bias to collRatio to allow other liquidators to step in for testing
          if (process.env.COLL_BIAS) {
            collRatio += parseFloat(process.env.COLL_BIAS);
          }
          if (collRatio >= mangoGroup.maintCollRatio) {
            continue
          }

          const deficit = liabsVal * mangoGroup.initCollRatio - assetsVal
          description = ma.toPrettyString(mangoGroup, prices)

          if (deficit < 0.1) {  // too small of an account; number precision may cause errors
            continue
          }
          const depositAmount = deficit * 1.01 + 5
          if (liqorTokenUi[NUM_TOKENS-1] < depositAmount) {
            console.log(`Liquidator does not have enough funds. ${liqorTokenUi[NUM_TOKENS-1]} < ${depositAmount}`)
            continue
          }
          console.log('liquidatable', deficit)
          console.log(description)
          await client.liquidate(connection, programId, mangoGroup, ma, payer,
            tokenWallets, [0, 0, depositAmount])
          liquidated = true
        } catch (e) {
          if (!e.timeout) {
            throw e
          } else {
            await sleep(1000)
            prices = await mangoGroup.getPrices(connection)
            ma = await client.getMarginAccount(connection, ma.publicKey, dexProgramId)
          }
        }

        if (liquidated) {
          console.log('liquidation success')
          console.log(ma.toPrettyString(mangoGroup, prices))

          let tries = 3
          while (tries > 0) {
            try {
              ma = await client.getMarginAccount(connection, ma.publicKey, dexProgramId)
              await drainAccount(client, connection, programId, mangoGroup, ma, markets, payer, prices, tokenWallets[NUM_TOKENS-1])
              console.log('Account drain success')
              notify(`liquidated ${description}`)
              break
            } catch (e) {
              tries -= 1
              notify(`error: ${e}\ncould not drain account ${description}\ntries left: ${tries}`)
              await sleep(1000)
            }
          }
        }

      }

      console.log(`Max Borrow Account: ${maxBorrAcc}   |   Max Borrow Val: ${maxBorrVal}`)

    } catch (e) {
      notify(`unknown error: ${e}`);
      console.error(e);
    } finally {
      await sleep(sleepTime)
    }
  }
}


runLiquidator()
// runPartialLiquidator()