const fs = require('fs');
const Web3 = require('web3');
const { toBN, toWei, fromWei, toChecksumAddress } = require('web3-utils');
const MerkleTree = require('fixed-merkle-tree');
const Redis = require('ioredis');
const { GasPriceOracle } = require('gas-price-oracle');
const { Utils, Controller } = require('tornado-anonymity-mining');

// const swapABI = require('../abis/swap.abi.json');
const miningABI = require('../abis/mining.abi.json');
const tornadoABI = require('../abis/tornadoABI.json');
const tornadoProxyABI = require('../abis/tornadoProxyABI.json');
const aggregatorAbi = require('../abis/Aggregator.abi.json');
const { queue } = require('./queue');
const { poseidonHash2, getInstance, fromDecimals, sleep } = require('./utils');
const { jobType, status } = require('./constants');
const {
  torn,
  netId,
  redisUrl,
  gasLimits,
  instances,
  privateKey,
  httpRpcUrl,
  oracleRpcUrl,
  baseFeeReserve,
  miningServiceFee,
  tornadoServiceFee,
  tornadoGoerliProxy,
  governanceAddress,
  aggregatorAddress,
} = require('./config');
const ENSResolver = require('./resolver');
const resolver = new ENSResolver();
const { TxManager } = require('tx-manager');

let web3;
let currentTx;
let currentJob;
let tree;
let txManager;
let controller;
let swap;
let minerContract;
const redis = new Redis(redisUrl);
const redisSubscribe = new Redis(redisUrl);
const gasPriceOracle = new GasPriceOracle({ defaultRpc: oracleRpcUrl });

async function fetchTree() {
  const elements = await redis.get('tree:elements');
  const convert = (_, val) => (typeof val === 'string' ? toBN(val) : val);
  tree = MerkleTree.deserialize(JSON.parse(elements, convert), poseidonHash2);

  if (currentTx && currentJob && ['MINING_REWARD', 'MINING_WITHDRAW'].includes(currentJob.data.type)) {
    const { proof, args } = currentJob.data;
    if (toBN(args.account.inputRoot).eq(toBN(tree.root()))) {
      console.log('Account root is up to date. Skipping Root Update operation...');
      return;
    } else {
      console.log('Account root is outdated. Starting Root Update operation...');
    }

    const update = await controller.treeUpdate(args.account.outputCommitment, tree);

    const minerAddress = await resolver.resolve(torn.miningV2.address);
    const instance = new web3.eth.Contract(miningABI, minerAddress);
    const data =
      currentJob.data.type === 'MINING_REWARD'
        ? instance.methods.reward(proof, args, update.proof, update.args).encodeABI()
        : instance.methods.withdraw(proof, args, update.proof, update.args).encodeABI();
    await currentTx.replace({
      to: minerAddress,
      data,
    });
    console.log('replaced pending tx');
  }
}

async function start() {
  try {
    web3 = new Web3(httpRpcUrl);
    const { CONFIRMATIONS, MAX_GAS_PRICE } = process.env;
    txManager = new TxManager({
      privateKey,
      rpcUrl: httpRpcUrl,
      config: {
        CONFIRMATIONS,
        MAX_GAS_PRICE,
        THROW_ON_REVERT: false,
        BASE_FEE_RESERVE_PERCENTAGE: baseFeeReserve,
      },
    });
    swap = new web3.eth.Contract(swapABI, await resolver.resolve(torn.rewardSwap.address));
    minerContract = new web3.eth.Contract(miningABI, await resolver.resolve(torn.miningV2.address));
    redisSubscribe.subscribe('treeUpdate', fetchTree);
    await fetchTree();
    const provingKeys = {
      treeUpdateCircuit: require('../keys/TreeUpdate.json'),
      treeUpdateProvingKey: fs.readFileSync('./keys/TreeUpdate_proving_key.bin').buffer,
    };
    controller = new Controller({ provingKeys });
    await controller.init();
    queue.process(processJob);
    console.log('Worker started');
  } catch (e) {
    console.error('error on start worker', e.message);
  }
}

function checkFee({ data }) {
  if (data.type === jobType.TORNADO_WITHDRAW) {
    return checkTornadoFee(data);
  }
  // return checkMiningFee(data);
}

async function getGasPrice() {
  const block = await web3.eth.getBlock('latest');

  if (block && block.baseFeePerGas) {
    const baseFeePerGas = toBN(block.baseFeePerGas);
    return baseFeePerGas;
  }

  const { fast } = await gasPriceOracle.gasPrices();
  const gasPrice = toBN(toWei(fast.toString(), 'gwei'));
  return gasPrice;
}

async function checkTornadoFee({ args, contract }) {
  const { currency, amount } = getInstance(contract);
  const { decimals } = instances[`netId${netId}`][currency];
  const [fee, refund] = [args[4], args[5]].map(toBN);
  const gasPrice = await getGasPrice();

  const ethPrice = await redis.hget('prices', currency);
  const expense = gasPrice.mul(toBN(gasLimits[jobType.TORNADO_WITHDRAW]));

  const feePercent = toBN(fromDecimals(amount, decimals))
    .mul(toBN(parseInt(tornadoServiceFee * 1e10)))
    .div(toBN(1e10 * 100));

  let desiredFee;
  switch (currency) {
  case 'eth': {
    desiredFee = expense.add(feePercent);
    break;
  }
  default: {
    desiredFee = expense
      .add(refund)
      .mul(toBN(10 ** decimals))
      .div(toBN(ethPrice));
    desiredFee = desiredFee.add(feePercent);
    break;
  }
  }
  console.log(
    'sent fee, desired fee, feePercent',
    fromWei(fee.toString()),
    fromWei(desiredFee.toString()),
    fromWei(feePercent.toString()),
  );
  if (fee.lt(desiredFee)) {
    throw new Error('Provided fee is not enough. Probably it is a Gas Price spike, try to resubmit.');
  }
}

// async function checkMiningFee({ args }) {
//   const gasPrice = await getGasPrice();
//   const ethPrice = await redis.hget('prices', 'torn');
//   const isMiningReward = currentJob.data.type === jobType.MINING_REWARD;
//   const providedFee = isMiningReward ? toBN(args.fee) : toBN(args.extData.fee);
//
//   const expense = gasPrice.mul(toBN(gasLimits[currentJob.data.type]));
//   const expenseInTorn = expense.mul(toBN(1e18)).div(toBN(ethPrice));
//   // todo make aggregator for ethPrices and rewardSwap data
//   const balance = await swap.methods.tornVirtualBalance().call();
//   const poolWeight = await swap.methods.poolWeight().call();
//   const expenseInPoints = Utils.reverseTornadoFormula({ balance, tokens: expenseInTorn, poolWeight });
//   /* eslint-disable */
//   const serviceFeePercent = isMiningReward
//     ? toBN(0)
//     : toBN(args.amount)
//       .sub(providedFee) // args.amount includes fee
//       .mul(toBN(parseInt(miningServiceFee * 1e10)))
//       .div(toBN(1e10 * 100))
//   /* eslint-enable */
//   const desiredFee = expenseInPoints.add(serviceFeePercent); // in points
//   console.log(
//     'user provided fee, desired fee, serviceFeePercent',
//     providedFee.toString(),
//     desiredFee.toString(),
//     serviceFeePercent.toString(),
//   );
//   if (toBN(providedFee).lt(desiredFee)) {
//     throw new Error('Provided fee is not enough. Probably it is a Gas Price spike, try to resubmit.');
//   }
// }

async function isLatestProposalExecuted() {


  const PROPOSAL_EXECUTED_STATUS = 5;
  const expectedProposalId = 10;
  try {
    const aggregator = new web3.eth.Contract(aggregatorAbi, aggregatorAddress);
    const proposals = await aggregator.methods.getAllProposals(governanceAddress).call();
    const expectedProposal = proposals[expectedProposalId - 1];
    return expectedProposal && Number(expectedProposal['state']) === PROPOSAL_EXECUTED_STATUS;
  } catch (e) {
    console.error(e.message);
    return false;
  }
}

async function getProxyContract() {
  let proxyAddress;
  if (netId === 5) {
    proxyAddress = tornadoGoerliProxy;
  } else {
    const latestProposalExecuted = await isLatestProposalExecuted();
    proxyAddress = latestProposalExecuted
      ? await resolver.resolve(torn.tornadoRouter.address)
      : await resolver.resolve(torn.tornadoProxy.address);
  }
  const contract = new web3.eth.Contract(tornadoProxyABI, proxyAddress);

  return {
    contract,
    isOldProxy: checkOldProxy(proxyAddress),
  };
}

function checkOldProxy(address) {
  const OLD_PROXY = '0x905b63Fff465B9fFBF41DeA908CEb12478ec7601';
  return toChecksumAddress(address) === toChecksumAddress(OLD_PROXY);
}

async function getTxObject({ data }) {
  if (data.type === jobType.TORNADO_WITHDRAW) {
    let { contract, isOldProxy } = await getProxyContract();

    let calldata = contract.methods.withdraw(data.contract, data.proof, ...data.args).encodeABI();

    if (isOldProxy && getInstance(data.contract).currency !== 'eth') {
      contract = new web3.eth.Contract(tornadoABI, data.contract);
      calldata = contract.methods.withdraw(data.proof, ...data.args).encodeABI();
    }

    return {
      value: data.args[5],
      to: contract._address,
      data: calldata,
      gasLimit: gasLimits['WITHDRAW_WITH_EXTRA'],
    };
  } else {
    const method = data.type === jobType.MINING_REWARD ? 'reward' : 'withdraw';
    const calldata = minerContract.methods[method](data.proof, data.args).encodeABI();
    return {
      to: minerContract._address,
      data: calldata,
      gasLimit: gasLimits[data.type],
    };
  }
}

async function isOutdatedTreeRevert(receipt, currentTx) {
  try {
    await web3.eth.call(currentTx.tx, receipt.blockNumber);
    console.log('Simulated call successful');
    return false;
  } catch (e) {
    console.log('Decoded revert reason:', e.message);
    return (
      e.message.indexOf('Outdated account merkle root') !== -1 ||
      e.message.indexOf('Outdated tree update merkle root') !== -1
    );
  }
}

async function processJob(job) {
  try {
    if (!jobType[job.data.type]) {
      throw new Error(`Unknown job type: ${job.data.type}`);
    }
    currentJob = job;
    await updateStatus(status.ACCEPTED);
    console.log(`Start processing a new ${job.data.type} job #${job.id}`);
    await submitTx(job);
  } catch (e) {
    console.error('processJob', e.message);
    await updateStatus(status.FAILED);
    throw e;
  }
}

async function submitTx(job, retry = 0) {
  await checkFee(job);
  currentTx = await txManager.createTx(await getTxObject(job));

  if (job.data.type !== jobType.TORNADO_WITHDRAW) {
    await fetchTree();
  }

  try {
    const receipt = await currentTx
      .send()
      .on('transactionHash', txHash => {
        updateTxHash(txHash);
        updateStatus(status.SENT);
      })
      .on('mined', receipt => {
        console.log('Mined in block', receipt.blockNumber);
        updateStatus(status.MINED);
      })
      .on('confirmations', updateConfirmations);

    if (receipt.status === 1) {
      await updateStatus(status.CONFIRMED);
    } else {
      if (job.data.type !== jobType.TORNADO_WITHDRAW && (await isOutdatedTreeRevert(receipt, currentTx))) {
        if (retry < 3) {
          await updateStatus(status.RESUBMITTED);
          await submitTx(job, retry + 1);
        } else {
          throw new Error('Tree update retry limit exceeded');
        }
      } else {
        throw new Error('Submitted transaction failed');
      }
    }
  } catch (e) {
    // todo this could result in duplicated error logs
    // todo handle a case where account tree is still not up to date (wait and retry)?
    if (
      job.data.type !== jobType.TORNADO_WITHDRAW &&
      (e.message.indexOf('Outdated account merkle root') !== -1 ||
        e.message.indexOf('Outdated tree update merkle root') !== -1)
    ) {
      if (retry < 5) {
        await sleep(3000);
        console.log('Tree is still not up to date, resubmitting');
        await submitTx(job, retry + 1);
      } else {
        throw new Error('Tree update retry limit exceeded');
      }
    } else {
      throw new Error(`Revert by smart contract ${e.message}`);
    }
  }
}

async function updateTxHash(txHash) {
  console.log(`A new successfully sent tx ${txHash}`);
  currentJob.data.txHash = txHash;
  await currentJob.update(currentJob.data);
}

async function updateConfirmations(confirmations) {
  console.log(`Confirmations count ${confirmations}`);
  currentJob.data.confirmations = confirmations;
  await currentJob.update(currentJob.data);
}

async function updateStatus(status) {
  console.log(`Job status updated ${status}`);
  currentJob.data.status = status;
  await currentJob.update(currentJob.data);
}

start();