import { expect } from 'chai';
import {
  asyncPoseidonHash,
  dpPoseidonHash,
  encodeTxAuctionBorrowMessage,
  encodeTxAuctionLendMessage,
  encodeTxCancelOrderMessage,
  encodeTxDepositMessage,
  encodeTxRedeemMessage,
  encodeTxRegisterMessage,
  encodeTxSecondLimitOrderMessage,
  encodeTxSecondMarketOrderMessage,
  encodeTxTransferMessage,
  encodeTxWithdrawMessage,
  TsSecondOrderType,
  TsTxPureRequest,
  TsTxSecondLimitOrderNonSignatureRequest,
  TsTxSecondMarketOrderNonSignatureRequest,
} from '../src/';
import * as txHelperCaseList from './data/ts-tx-helper.testcase.json';

describe(`test ts-tx-helper`, function () {
  this.timeout(100000);
  before(async function () {
    await asyncPoseidonHash;
  });

  it('encodeTxRegisterMessage', function () {
    const list = txHelperCaseList['encodeTxRegisterMessage'];
    for (const item of list) {
      const { input, expectEncodeData: expectResult } = item;
      const output = encodeTxRegisterMessage(input);
      const hash = dpPoseidonHash(output).toString();
      expect(bigintArrayToStringArray(output)).to.deep.equal(expectResult);
      expect(hash).to.equal(item.expectHash);
    }
  });

  it('encodeTxDepositMessage', function () {
    const list = txHelperCaseList['encodeTxDepositMessage'];
    for (const item of list) {
      const { input, expectEncodeData: expectResult } = item;
      const output = encodeTxDepositMessage(input);
      const hash = dpPoseidonHash(output).toString();
      expect(bigintArrayToStringArray(output)).to.deep.equal(expectResult);
      expect(hash).to.equal(item.expectHash);
    }
  });

  it('encodeTxTransferMessage', function () {
    const list = txHelperCaseList['encodeTxTransferMessage'];
    for (const item of list) {
      const { input, expectEncodeData: expectResult } = item;
      const output = encodeTxTransferMessage(input);
      const hash = dpPoseidonHash(output).toString();
      expect(bigintArrayToStringArray(output)).to.deep.equal(expectResult);
      expect(hash).to.equal(item.expectHash);
    }
  });

  it('encodeTxWithdrawMessage', function () {
    const list = txHelperCaseList['encodeTxWithdrawMessage'];
    for (const item of list) {
      const { input, expectEncodeData: expectResult } = item;
      const output = encodeTxWithdrawMessage(input);
      const hash = dpPoseidonHash(output).toString();
      expect(bigintArrayToStringArray(output)).to.deep.equal(expectResult);
      expect(hash).to.equal(item.expectHash);
    }
  });

  it('encodeTxAuctionLendMessage', function () {
    const list = txHelperCaseList['encodeTxAuctionLendMessage'];
    for (const item of list) {
      const { input, expectEncodeData: expectResult } = item;
      const output = encodeTxAuctionLendMessage(input);
      const hash = dpPoseidonHash(output).toString();
      expect(bigintArrayToStringArray(output)).to.deep.equal(expectResult);
      expect(hash).to.equal(item.expectHash);
    }
  });

  it('encodeTxAuctionBorrowMessage', function () {
    const list = txHelperCaseList['encodeTxAuctionBorrowMessage'];
    for (const item of list) {
      const { input, expectEncodeData: expectResult } = item;
      const output = encodeTxAuctionBorrowMessage(input);
      const hash = dpPoseidonHash(output).toString();
      expect(bigintArrayToStringArray(output)).to.deep.equal(expectResult);
      expect(hash).to.equal(item.expectHash);
    }
  });

  it('encodeTxCancelOrderMessage', function () {
    const list = txHelperCaseList['encodeTxCancelOrderMessage'];
    for (const item of list) {
      const { input, expectEncodeData: expectResult } = item;
      const output = encodeTxCancelOrderMessage(input);
      const hash = dpPoseidonHash(output).toString();
      expect(bigintArrayToStringArray(output)).to.deep.equal(expectResult);
      expect(hash).to.equal(item.expectHash);
    }
  });

  it('encodeTxSecondLimitOrderMessage', function () {
    const list = txHelperCaseList['encodeTxSecondLimitOrderMessage'];
    for (const item of list) {
      const { input: _input, expectEncodeData: expectResult } = item;
      const input: TsTxPureRequest<TsTxSecondLimitOrderNonSignatureRequest> = {
        ..._input,
        side: _input.side as TsSecondOrderType,
      };
      const output = encodeTxSecondLimitOrderMessage(input);
      const hash = dpPoseidonHash(output).toString();
      expect(bigintArrayToStringArray(output)).to.deep.equal(expectResult);
      expect(hash).to.equal(item.expectHash);
    }
  });

  it('encodeTxSecondMarketOrderMessage', function () {
    const list = txHelperCaseList['encodeTxSecondMarketOrderMessage'];
    for (const item of list) {
      const { input: _input, expectEncodeData: expectResult } = item;
      const input: TsTxPureRequest<TsTxSecondMarketOrderNonSignatureRequest> = {
        ..._input,
        side: _input.side as TsSecondOrderType,
      };
      const output = encodeTxSecondMarketOrderMessage(input);
      const hash = dpPoseidonHash(output).toString();
      expect(bigintArrayToStringArray(output)).to.deep.equal(expectResult);
      expect(hash).to.equal(item.expectHash);
    }
  });

  it('encodeTxRedeemMessage', function () {
    const list = txHelperCaseList['encodeTxRedeemMessage'];
    for (const item of list) {
      const { input, expectEncodeData: expectResult } = item;
      const output = encodeTxRedeemMessage(input);
      const hash = dpPoseidonHash(output).toString();
      expect(bigintArrayToStringArray(output)).to.deep.equal(expectResult);
      expect(hash).to.equal(item.expectHash);
    }
  });
});

function bigintArrayToStringArray(arr: bigint[]): string[] {
  return arr.map((item) => item.toString());
}