import * as BigNumber from 'bignumber.js';

export const bigNumberConfigs = {
    configure() {
        // By default BigNumber's `toString` method converts to exponential notation if the value has
        // more then 20 digits. We want to avoid this behavior, so we set EXPONENTIAL_AT to a high number
        BigNumber.config({
            EXPONENTIAL_AT: 1000,
        });
    },
};

 it('should fill the valid orders with fees', async () => {
     const makerFee = new BigNumber(1);
     const takerFee = new BigNumber(2);
     const signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
         makerTokenAddress, takerTokenAddress, makerFee, takerFee,
         makerAddress, takerAddress, fillableAmount, feeRecipient,
     );
     const txHash = await zeroEx.exchange.fillOrderAsync(
         signedOrder, fillTakerAmount, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress);
     await zeroEx.awaitTransactionMinedAsync(txHash);
     expect(await zeroEx.token.getBalanceAsync(zrxTokenAddress, feeRecipient))
         .to.be.bignumber.equal(makerFee.plus(takerFee));
 });

        it('should throw if remaining fillAmount is less then the desired fillAmount', async () => {
            const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
                makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
            );
            const tooLargeFillAmount = new BigNumber(7);
            const fillAmountDifference = tooLargeFillAmount.minus(fillableAmount);
            await zeroEx.token.transferAsync(takerTokenAddress, coinbase, takerAddress, fillAmountDifference);
            await zeroEx.token.setProxyAllowanceAsync(takerTokenAddress, takerAddress, tooLargeFillAmount);
            await zeroEx.token.transferAsync(makerTokenAddress, coinbase, makerAddress, fillAmountDifference);
            await zeroEx.token.setProxyAllowanceAsync(makerTokenAddress, makerAddress, tooLargeFillAmount);

            return expect(zeroEx.exchange.validateFillOrKillOrderThrowIfInvalidAsync(
                signedOrder, tooLargeFillAmount, takerAddress,
            )).to.be.rejectedWith(ExchangeContractErrs.InsufficientRemainingFillAmount);
        });

 describe('#fillOrdersUpTo', () => {
     let signedOrder: SignedOrder;
     let signedOrderHashHex: string;
     let anotherSignedOrder: SignedOrder;
     let anotherOrderHashHex: string;
     let signedOrders: SignedOrder[];
     const fillUpToAmount = fillableAmount.plus(fillableAmount).minus(1);
     beforeEach(async () => {
         signedOrder = await fillScenarios.createFillableSignedOrderAsync(
             makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
         );
         signedOrderHashHex = ZeroEx.getOrderHashHex(signedOrder);
         anotherSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
             makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
         );
         anotherOrderHashHex = ZeroEx.getOrderHashHex(anotherSignedOrder);
         signedOrders = [signedOrder, anotherSignedOrder];
     });
     describe('successful batch fills', () => {
         it('should throw if a batch is empty', async () => {
             return expect(zeroEx.exchange.fillOrdersUpToAsync(
                 [], fillUpToAmount, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress),
             ).to.be.rejectedWith(ExchangeContractErrs.BatchOrdersMustHaveAtLeastOneItem);
         });
         it('should successfully fill up to specified amount', async () => {
             const txHash = await zeroEx.exchange.fillOrdersUpToAsync(
                 signedOrders, fillUpToAmount, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress,
             );
             await zeroEx.awaitTransactionMinedAsync(txHash);
             const filledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(signedOrderHashHex);
             const anotherFilledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(anotherOrderHashHex);
             expect(filledAmount).to.be.bignumber.equal(fillableAmount);
             const remainingFillAmount = fillableAmount.minus(1);
             expect(anotherFilledAmount).to.be.bignumber.equal(remainingFillAmount);
         });
     });
 });