import { parseTypeTagOrThrow, u64, sendPayloadTxAndLog, parseMoveStructTag, StructTag } from '@manahippo/move-to-ts';
import { AptosAccount, AptosClient, HexString } from 'aptos';
import { Command } from 'commander';
import * as Swap from '../generated/swap';
import { readConfig } from './utils';
import { OmniPoolProvider } from '../swap';
import { CoinListClient } from '../coinlist';

const program = new Command();

program
  .name('yarn cli')
  .description('Aptos Amm TS CLI')
  .requiredOption('-c, --config <path>', 'path to your aptos config.yml (generated with "aptos init")')
  .option('-p, --profile <PROFILE>', 'aptos config profile to use', 'default');

const interface_add_liquidity = async (
  X: string,
  Y: string,
  coin_x_val: string,
  coin_x_val_min: string,
  coin_y_val: string,
  coin_y_val_min: string,
  max_gas: string
) => {
  const { client, account } = readConfig(program);
  const X_ = parseTypeTagOrThrow(X);
  const Y_ = parseTypeTagOrThrow(Y);
  const coin_x_val_ = u64(coin_x_val);
  const coin_x_val_min_ = u64(coin_x_val_min);
  const coin_y_val_ = u64(coin_y_val);
  const coin_y_val_min_ = u64(coin_y_val_min);
  const max_gas_ = parseInt(max_gas);
  const payload = Swap.Interface.buildPayload_add_liquidity(
    coin_x_val_,
    coin_x_val_min_,
    coin_y_val_,
    coin_y_val_min_,
    [X_, Y_]
  );
  await sendPayloadTxAndLog(client, account, payload, { maxGasAmount: max_gas_ });
};

program
  .command('omniswap:add-liquidity')
  .description('Add liquidity to the pool')
  .argument('<TYPE_X>')
  .argument('<TYPE_Y>')
  .argument('<coin_x_val>')
  .argument('<coin_x_val_min>')
  .argument('<coin_y_val>')
  .argument('<coin_y_val_min>')
  .argument('[max_gas]', '', '10000')
  .action(interface_add_liquidity);

const interface_initialize_swap = async (controller: string, beneficiary: string, max_gas: string) => {
  const { client, account } = readConfig(program);
  const controller_ = new HexString(controller);
  const beneficiary_ = new HexString(beneficiary);
  const max_gas_ = parseInt(max_gas);
  const payload = Swap.Interface.buildPayload_initialize_swap(controller_, beneficiary_);
  await sendPayloadTxAndLog(client, account, payload, { maxGasAmount: max_gas_ });
};

program
  .command('omniswap:initialize-swap')
  .description('Initialize swap (admin-only)')
  .argument('<controller>')
  .argument('<beneficiary>')
  .argument('[max_gas]', '', '10000')
  .action(interface_initialize_swap);

const interface_register_pool = async (X: string, Y: string, max_gas: string) => {
  const { client, account } = readConfig(program);
  const X_ = parseTypeTagOrThrow(X);
  const Y_ = parseTypeTagOrThrow(Y);
  const max_gas_ = parseInt(max_gas);
  const payload = Swap.Interface.buildPayload_register_pool([X_, Y_]);
  await sendPayloadTxAndLog(client, account, payload, { maxGasAmount: max_gas_ });
};

program
  .command('omniswap:register-pool')
  .description("Register a new liquidity pool for 'X'/'Y' pair")
  .argument('<TYPE_X>')
  .argument('<TYPE_Y>')
  .argument('[max_gas]', '', '10000')
  .action(interface_register_pool);

const interface_remove_liquidity = async (
  X: string,
  Y: string,
  lp_val: string,
  min_x_out_val: string,
  min_y_out_val: string,
  max_gas: string
) => {
  const { client, account } = readConfig(program);
  const X_ = parseTypeTagOrThrow(X);
  const Y_ = parseTypeTagOrThrow(Y);
  const lp_val_ = u64(lp_val);
  const min_x_out_val_ = u64(min_x_out_val);
  const min_y_out_val_ = u64(min_y_out_val);
  const max_gas_ = parseInt(max_gas);
  const payload = Swap.Interface.buildPayload_remove_liquidity(lp_val_, min_x_out_val_, min_y_out_val_, [X_, Y_]);
  await sendPayloadTxAndLog(client, account, payload, { maxGasAmount: max_gas_ });
};

program
  .command('omniswap:remove-liquidity')
  .description('Remove liquidity to the pool')
  .argument('<TYPE_X>')
  .argument('<TYPE_Y>')
  .argument('<lp_val>')
  .argument('<min_x_out_val>')
  .argument('<min_y_out_val>')
  .argument('[max_gas]', '', '10000')
  .action(interface_remove_liquidity);

const interface_swap = async (X: string, Y: string, coin_val: string, coin_out_min_val: string, max_gas: string) => {
  const { client, account } = readConfig(program);
  const X_ = parseTypeTagOrThrow(X);
  const Y_ = parseTypeTagOrThrow(Y);
  const coin_val_ = u64(coin_val);
  const coin_out_min_val_ = u64(coin_out_min_val);
  const max_gas_ = parseInt(max_gas);
  const payload = Swap.Interface.buildPayload_swap(coin_val_, coin_out_min_val_, [X_, Y_]);
  await sendPayloadTxAndLog(client, account, payload, { maxGasAmount: max_gas_ });
};

program
  .command('omniswap:swap')
  .description("Swap 'X' for 'Y'")
  .argument('<TYPE_X>')
  .argument('<TYPE_Y>')
  .argument('<coin_val>')
  .argument('<coin_out_min_val>')
  .argument('[max_gas]', '', '10000')
  .action(interface_swap);

const omniQueryQutos = async () => {
  const { netConf, app } = readConfig(program);
  const coinListClient = await CoinListClient.load(app);
  const omniProvider = new OmniPoolProvider(app, netConf, coinListClient);
  const poollist = await omniProvider.loadPoolList();
  poollist.forEach(async (pool) => {
    await pool.reloadState(app);
    const quote = await pool.getQuote(1, true);
    console.log(`quote: ${JSON.stringify(quote)}`);
  });
};

program.command('omniswap:query-qutos').description('query all registered liquidity pools').action(omniQueryQutos);

const omniListPools = async () => {
  const { client, netConf } = readConfig(program);
  const resources = await client.getAccountResources(netConf.omniCoinListAddress);
  for (const resource of resources) {
    if (resource.type.indexOf('implements::LiquidityPool') >= 0) {
      console.log('##########');
      const tag = parseMoveStructTag(resource.type);
      console.log(`LHS: ${(tag.typeParams[0] as StructTag).getFullname()}`);
      console.log(`RHS: ${(tag.typeParams[1] as StructTag).getFullname()}`);
    }
  }
};

program.command('omniswap:list-pools').description('List all registered liquidity pools').action(omniListPools);

program.parse();