import * as mocha from 'mocha';
import * as chai from 'chai';
import {RelayUtil} from '../src/index';
import {RelaySignedOrder, IndexedRelayTokens, RelayToken} from '0x-relay-types';
import {factories} from './lib/factories';
import BigNumber from 'bignumber.js';

/* tslint:disable:no-unused-expression */
const expect = chai.expect;

let util: RelayUtil;
let indexedRelayTokens: IndexedRelayTokens;
const tokenAddresses: string[] = [];
let tokenKeys: string[];
let tokenA: RelayToken;
let tokenB: RelayToken;
const smallTokenDecimal = 6;
let tokenSmallA: RelayToken;
const tokenSmallAIndex: number = 8;
let tokenSmallB: RelayToken;
const tokenSmallBIndex: number = 9;
let makerAddress: string;
let takerAddress: string;
let smallMakerAddress: string;
let smallTakerAddress: string;
const token0DecimalsIndex: number = 2;
let token0DecimalsAddress: string;

describe('calculateRates', () => {
    it('calculates rates between tokens with different decimal places', () => {
        const maker: BigNumber = new BigNumber('10');
        const taker: BigNumber = new BigNumber('10');
        expect(RelayUtil.calculateRate(
            maker,
            taker
        ).equals(new BigNumber('1')));
        expect(RelayUtil.calculateRate(
            maker,
            taker,
            18,
            10
        ).equals(new BigNumber('100000000')));
        expect(RelayUtil.calculateRate(
            maker,
            taker,
            10,
            18
        ).equals(new BigNumber('.00000001')));
    });

});

describe('calculateRatesUnit', () => {

  it('calculates rates between amounts already in unitAmount form', () => {
    const maker: BigNumber = new BigNumber('10');
    const taker: BigNumber = new BigNumber('10');

    expect(RelayUtil.calculateRateUnit(
        maker,
        taker
    ).equals(new BigNumber('1')));
  });

  it('calculates rates between non-BigNumber amounts', () => {
    const maker: string = '10';
    const taker: string = '10';

    expect(RelayUtil.calculateRateUnit(
        maker,
        taker
    ).equals(new BigNumber('1')));
  });

  it('calculates rates between mix of number type amounts', () => {
    let maker: any = 10;
    let taker: any = '10';

    expect(RelayUtil.calculateRateUnit(
        maker,
        taker
    ).equals(new BigNumber('1')));

    maker = new BigNumber(10);
    taker = 10;
    expect(RelayUtil.calculateRateUnit(
        maker,
        taker
    ).equals(new BigNumber('1')));
  });

  it('calculates rate as zero with invalid type amount ', () => {

    const maker = undefined;
    const taker: any = '10';

    expect(RelayUtil.calculateRateUnit(
        maker,
        taker
    ).equals(new BigNumber('0')));

  });

});

describe('OrderRates', () => {

    beforeEach(async () => {
      indexedRelayTokens = factories.indexedRelayTokensFactory(10, tokenAddresses);
      util = new RelayUtil(indexedRelayTokens);

      // setup 2 relay tokens
      tokenKeys = Object.keys(indexedRelayTokens);
      tokenA = indexedRelayTokens[tokenKeys[0]];
      tokenB = indexedRelayTokens[tokenKeys[1]];
      indexedRelayTokens[tokenKeys[token0DecimalsIndex]].decimals = 0;
      indexedRelayTokens[tokenKeys[tokenSmallAIndex]].decimals = smallTokenDecimal;
      tokenSmallA = indexedRelayTokens[tokenKeys[tokenSmallAIndex]];
      smallMakerAddress = tokenSmallA.address;
      indexedRelayTokens[tokenKeys[tokenSmallBIndex]].decimals = smallTokenDecimal;
      tokenSmallB = indexedRelayTokens[tokenKeys[tokenSmallBIndex]];
      smallTakerAddress = tokenSmallB.address;
      makerAddress = tokenA.address;
      takerAddress = tokenB.address;
      token0DecimalsAddress = indexedRelayTokens[tokenKeys[token0DecimalsIndex]].address;

    });

    it('calculates the proper rates from raw fields', async () => {

        let makerAmount: BigNumber = new BigNumber('20000000');
        let takerAmount: BigNumber = new BigNumber('20000000');

        let result: BigNumber = util.orderRate(
            makerAmount,
            makerAddress,
            takerAmount,
            takerAddress
        );
        expect(result.equals(new BigNumber('1')));

        makerAmount = new BigNumber('200000000');
        result = util.orderRate(
            makerAmount,
            makerAddress,
            takerAmount,
            takerAddress
        );
        expect(result.equals(new BigNumber('0.1')));

        makerAmount = new BigNumber('20000000');
        takerAmount = new BigNumber('200000000');
        result = util.orderRate(
            makerAmount,
            makerAddress,
            takerAmount,
            takerAddress
        );
        expect(result.equals(new BigNumber('10')));
    });

    it('calculates the proper rates with small decimal tokens', async () => {
        const result: BigNumber = util.orderRate(
            new BigNumber('100'),
            smallMakerAddress,
            new BigNumber('100'),
            smallTakerAddress
        );
        expect(result.equals(new BigNumber('1')));
    });

    it('calculates the proper rates with different decimal tokens', async () => {
        const result: BigNumber = util.orderRate(
            new BigNumber('100'),
            makerAddress,
            new BigNumber('100'),
            smallTakerAddress
        );
        expect(result.equals(new BigNumber('1000000000000')));
    });

    it('calculates the proper rates with 0 decimal tokens', async () => {

        const result: BigNumber = util.orderRate(
            new BigNumber('100'),
            token0DecimalsAddress,
            new BigNumber('100'),
            smallTakerAddress
        );
        expect(result.equals(new BigNumber('1000000000000')));
    });

    it('calculates the proper rates from relaySignedOrders', async () => {
        const order = factories.relaySignedOrderFactory();
        order.signedOrder.makerTokenAmount = new BigNumber('999999');
        order.signedOrder.takerTokenAmount = new BigNumber('99999999');
        order.signedOrder.makerTokenAddress = tokenA.address;
        order.signedOrder.takerTokenAddress = tokenB.address;

        expect(util.relaySignedOrderRate(order).equals(new BigNumber('0.01')));
    });

    it('calculates the proper rates from signedOrders', async () => {
        const order = factories.signedOrderFactory();
        order.makerTokenAmount = new BigNumber('999999');
        order.takerTokenAmount = new BigNumber('9999');
        order.makerTokenAddress = tokenA.address;
        order.takerTokenAddress = tokenB.address;
        expect(util.signedOrderRate(order).equals(new BigNumber('100')));
    });

    it('calculates the proper rates from signedOrder between different sized tokens', async () => {
        const order = factories.signedOrderFactory();
        order.makerTokenAmount = new BigNumber('100');
        order.takerTokenAmount = new BigNumber('100');
        order.makerTokenAddress = tokenA.address;
        order.takerTokenAddress = smallTakerAddress;
        expect(util.signedOrderRate(order).equals(new BigNumber('.0000000001')));
    });
});

describe('OrderRatesUnit', () => {

    it('calculates the proper rates from relaySignedOrders', async () => {
        const order = factories.relaySignedOrderFactory();
        order.signedOrder.makerTokenAmount = new BigNumber('999999');
        order.signedOrder.takerTokenAmount = new BigNumber('99999999');

        expect(RelayUtil.relaySignedOrderRateUnit(order).equals(new BigNumber('0.01')));
    });

    it('calculates the proper rates from signedOrders', async () => {
        const order = factories.signedOrderFactory();
        order.makerTokenAmount = new BigNumber('999999');
        order.takerTokenAmount = new BigNumber('9999');
        expect(RelayUtil.signedOrderRateUnit(order).equals(new BigNumber('100')));
    });
});