import './env/environment';
import {web3ProviderFactory} from './lib/web3-provider-wrapper';
import {
  ZeroEx,
  SubscriptionOpts,
  BlockParam,
  IndexedFilterValues,
  ExchangeEvents,
  ContractEvent,
  SignedOrder,
  Token,
  ExchangeContractErrs,
  ZeroExError
} from '0x.js';
import * as mocha from 'mocha';
import * as chai from 'chai';
import * as Web3 from 'web3';
import BigNumber from 'bignumber.js';
import {FillScenarios} from './lib/fill_scenarios';
import {BlockchainLifecycle} from './lib/blockchain_lifecycle';
import {TokenUtils} from './lib/token_utils';
import {OrderValidation} from '../src/order-validation';

const expect = chai.expect;

const blockchainLifecycle = new BlockchainLifecycle();

/* tslint:disable:no-unused-expression */

describe('OrderValidation Only', () => {
  let zeroEx: ZeroEx;
  let userAddresses: string[];
  let tokens: Token[];
  let tokenUtils: TokenUtils;
  let exchangeContractAddress: string;
  let zrxTokenAddress: string;
  let fillScenarios: FillScenarios;
  let makerTokenAddress: string;
  let takerTokenAddress: string;
  let coinbase: string;
  let makerAddress: string;
  let takerAddress: string;
  let feeRecipient: string;
  const fillableAmount = new BigNumber(5);
  const fillTakerAmount = new BigNumber(5);
  const shouldThrowOnInsufficientBalanceOrAllowance = false;
  before(async () => {
    const web3provider = web3ProviderFactory.getRpcProvider(
      process.env.RPC_HTTP_SCHEME, process.env.RPC_HOST, process.env.RPC_PORT);
    zeroEx = new ZeroEx(web3provider);
    exchangeContractAddress = await zeroEx.exchange.getContractAddressAsync();
    userAddresses = await zeroEx.getAvailableAddressesAsync();
    [coinbase, makerAddress, takerAddress, feeRecipient] = userAddresses;
    tokens = await zeroEx.tokenRegistry.getTokensAsync();
    tokenUtils = new TokenUtils(tokens);
    zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
    fillScenarios = new FillScenarios(zeroEx, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
    const [makerToken, takerToken] = tokenUtils.getNonProtocolTokens();
    makerTokenAddress = makerToken.address;
    takerTokenAddress = takerToken.address;
  });
  beforeEach(async () => {
      await blockchainLifecycle.startAsync();
  });
  afterEach(async () => {
      await blockchainLifecycle.revertAsync();
  });

    it('should return false when order is expired', async () => {
        const expirationInPast = new BigNumber(1496826058); // 7th Jun 2017
        const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
            makerTokenAddress, takerTokenAddress, makerAddress, takerAddress,
            fillableAmount, expirationInPast,
        );
        const result: boolean = await OrderValidation.isOrderValidSimple(signedOrder);
        expect(result).is.false;
    });

    it('should return true when order is valid', async () => {
        const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
            makerTokenAddress, takerTokenAddress, makerAddress, takerAddress,
            fillableAmount
        );
        const result: boolean = await OrderValidation.isOrderValidSimple(signedOrder);
        expect(result).is.true;
    });

    it('should throw when order is expired', async () => {
        const expirationInPast = new BigNumber(1496826058); // 7th Jun 2017
        const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
            makerTokenAddress, takerTokenAddress, makerAddress, takerAddress,
            fillableAmount, expirationInPast,
        );
        try {
            await OrderValidation.isOrderValid(signedOrder);
        } catch (err) {
            expect(err === ExchangeContractErrs.OrderCancelExpired);
        }
    });

    it('should not throw when order is valid', async () => {
        const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
            makerTokenAddress, takerTokenAddress, makerAddress, takerAddress,
            fillableAmount
        );
        try {
            await OrderValidation.isOrderValid(signedOrder);
            expect(true);
        } catch (e) {
            expect(false, 'Should not have thrown.');
        }
    });
});