import {
    artifacts as assetProxyArtifacts,
    DydxBridgeActionType,
    DydxBridgeContract,
    DydxBridgeData,
    dydxBridgeDataEncoder,
    encodeERC20AssetData,
    encodeERC20BridgeAssetData,
    IDydxContract,
} from '@0x/contracts-asset-proxy';
import { artifacts as devUtilsArtifacts, DevUtilsContract } from '@0x/contracts-dev-utils';
import { ERC20TokenContract } from '@0x/contracts-erc20';
import { blockchainTests, constants, expect, Numberish } from '@0x/contracts-test-utils';
import { Order } from '@0x/types';
import { BigNumber, fromTokenUnitAmount, hexUtils, toTokenUnitAmount } from '@0x/utils';

import { contractAddresses } from '../mainnet_fork_utils';

enum DydxActionType {
    Deposit = 0,
    Withdraw = 1,
}

enum DydxAssetDenomination {
    Wei = 0,
    Par = 1,
}

enum DydxAssetReference {
    Delta = 0,
    Target = 1,
}

const CHONKY_DAI_WALLET = '0x3a9F7C8cA36C42d7035E87C3304eE5cBd353a532';
const CHONKY_USDC_WALLET = '0x1EDA7056fF11C9817038E0020C3a6F1d6A8Ec32e';

blockchainTests.configure({
    fork: {
        unlockedAccounts: [CHONKY_DAI_WALLET, CHONKY_USDC_WALLET],
    },
});

blockchainTests.fork('DevUtils dydx order validation tests', env => {
    const { ZERO_AMOUNT: ZERO } = constants;
    const SIGNATURE = '0x01'; // Invalid signature. Doesn't matter.
    const DAI_ADDRESS = '0x6B175474E89094C44Da98b954EedeAC495271d0F';
    const USDC_ADDRESS = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
    const DYDX_ADDRESS = '0x1E0447b19BB6EcFdAe1e4AE1694b0C3659614e4e';
    const TOKEN_INFO: { [addr: string]: { decimals: number; marketId: number } } = {
        [DAI_ADDRESS]: {
            decimals: 18,
            marketId: 3,
        },
        [USDC_ADDRESS]: {
            decimals: 6,
            marketId: 2,
        },
    };
    const DAI_DECIMALS = TOKEN_INFO[DAI_ADDRESS].decimals;
    const USDC_DECIMALS = TOKEN_INFO[USDC_ADDRESS].decimals;
    let bridge: DydxBridgeContract;
    let dydx: IDydxContract;
    let dai: ERC20TokenContract;
    let usdc: ERC20TokenContract;
    let devUtils: DevUtilsContract;
    let accountOwner: string;
    let minMarginRatio: number;

    before(async () => {
        [accountOwner] = await env.getAccountAddressesAsync();
        dydx = new IDydxContract(DYDX_ADDRESS, env.provider, env.txDefaults);
        dai = new ERC20TokenContract(DAI_ADDRESS, env.provider, env.txDefaults);
        usdc = new ERC20TokenContract(USDC_ADDRESS, env.provider, env.txDefaults);
        bridge = await DydxBridgeContract.deployFrom0xArtifactAsync(
            assetProxyArtifacts.DydxBridge,
            env.provider,
            env.txDefaults,
            {},
        );
        devUtils = await DevUtilsContract.deployWithLibrariesFrom0xArtifactAsync(
            devUtilsArtifacts.DevUtils,
            devUtilsArtifacts,
            env.provider,
            env.txDefaults,
            devUtilsArtifacts,
            contractAddresses.exchange,
            contractAddresses.chaiBridge,
            bridge.address,
        );
        minMarginRatio = toTokenUnitAmount((await dydx.getRiskParams().callAsync()).marginRatio.value)
            .plus(1)
            .toNumber();
        // Set approvals and operators.
        await dai
            .approve(DYDX_ADDRESS, constants.MAX_UINT256)
            .awaitTransactionSuccessAsync({ from: CHONKY_DAI_WALLET });
        await usdc
            .approve(DYDX_ADDRESS, constants.MAX_UINT256)
            .awaitTransactionSuccessAsync({ from: CHONKY_USDC_WALLET });
        await dydx
            .setOperators([{ operator: bridge.address, trusted: true }])
            .awaitTransactionSuccessAsync({ from: CHONKY_DAI_WALLET });
        await dydx
            .setOperators([{ operator: bridge.address, trusted: true }])
            .awaitTransactionSuccessAsync({ from: CHONKY_USDC_WALLET });
    });

    async function depositAndWithdrawAsync(
        makerAddress: string,
        accountId: BigNumber,
        depositSize: Numberish = 0,
        withdrawSize: Numberish = 0,
    ): Promise<void> {
        const fromToken = makerAddress === CHONKY_DAI_WALLET ? DAI_ADDRESS : USDC_ADDRESS;
        const toToken = fromToken === DAI_ADDRESS ? USDC_ADDRESS : DAI_ADDRESS;
        const fromDecimals = TOKEN_INFO[fromToken].decimals;
        const fromMarketId = TOKEN_INFO[fromToken].marketId;
        const toDecimals = TOKEN_INFO[toToken].decimals;
        const toMarketId = TOKEN_INFO[toToken].marketId;
        await dydx
            .operate(
                [{ owner: makerAddress, number: accountId }],
                [
                    ...(depositSize > 0
                        ? [
                              {
                                  actionType: DydxActionType.Deposit,
                                  accountIdx: ZERO,
                                  amount: {
                                      sign: true,
                                      denomination: DydxAssetDenomination.Wei,
                                      ref: DydxAssetReference.Delta,
                                      value: fromTokenUnitAmount(depositSize, fromDecimals),
                                  },
                                  primaryMarketId: new BigNumber(fromMarketId),
                                  secondaryMarketId: new BigNumber(constants.NULL_ADDRESS),
                                  otherAddress: makerAddress,
                                  otherAccountIdx: ZERO,
                                  data: constants.NULL_BYTES,
                              },
                          ]
                        : []),
                    ...(withdrawSize > 0
                        ? [
                              {
                                  actionType: DydxActionType.Withdraw,
                                  accountIdx: ZERO,
                                  amount: {
                                      sign: false,
                                      denomination: DydxAssetDenomination.Wei,
                                      ref: DydxAssetReference.Delta,
                                      value: fromTokenUnitAmount(withdrawSize, toDecimals),
                                  },
                                  primaryMarketId: new BigNumber(toMarketId),
                                  secondaryMarketId: new BigNumber(constants.NULL_ADDRESS),
                                  otherAddress: makerAddress,
                                  otherAccountIdx: ZERO,
                                  data: constants.NULL_BYTES,
                              },
                          ]
                        : []),
                ],
            )
            .awaitTransactionSuccessAsync({ from: makerAddress });
    }

    const SECONDS_IN_ONE_YEAR = 365 * 24 * 60 * 60;

    function createOrder(fields: Partial<Order> = {}): Order {
        return {
            chainId: 1,
            exchangeAddress: contractAddresses.exchange,
            expirationTimeSeconds: new BigNumber(Math.floor(Date.now() / 1000 + SECONDS_IN_ONE_YEAR)),
            makerAddress: CHONKY_DAI_WALLET,
            takerAddress: constants.NULL_ADDRESS,
            senderAddress: constants.NULL_ADDRESS,
            feeRecipientAddress: constants.NULL_ADDRESS,
            salt: new BigNumber(hexUtils.random()),
            makerAssetAmount: fromTokenUnitAmount(100, USDC_DECIMALS),
            takerAssetAmount: fromTokenUnitAmount(200, DAI_DECIMALS),
            makerFee: ZERO,
            takerFee: ZERO,
            makerAssetData: encodeDydxBridgeAssetData(),
            takerAssetData: encodeERC20AssetData(DAI_ADDRESS),
            makerFeeAssetData: constants.NULL_BYTES,
            takerFeeAssetData: constants.NULL_BYTES,
            ...fields,
        };
    }

    function encodeDydxBridgeAssetData(
        fields: Partial<{
            fromToken: string;
            toToken: string;
            depositRate: number;
            withdrawRate: number;
            accountId: BigNumber;
        }> = {},
    ): string {
        const { fromToken, toToken, depositRate, withdrawRate, accountId } = {
            fromToken: DAI_ADDRESS,
            toToken: USDC_ADDRESS,
            depositRate: 1,
            withdrawRate: 1,
            accountId: ZERO,
            ...fields,
        };
        const fromTokenMarketId = new BigNumber(TOKEN_INFO[fromToken].marketId);
        const toTokenMarketId = new BigNumber(TOKEN_INFO[toToken].marketId);
        const bridgeData: DydxBridgeData = {
            accountNumbers: [accountId],
            actions: [
                ...(depositRate > 0
                    ? [
                          {
                              actionType: DydxBridgeActionType.Deposit,
                              accountIdx: ZERO,
                              marketId: fromTokenMarketId,
                              ...createConversionFraction(toToken, fromToken, depositRate),
                          },
                      ]
                    : []),
                ...(withdrawRate > 0
                    ? [
                          {
                              actionType: DydxBridgeActionType.Withdraw,
                              accountIdx: ZERO,
                              marketId: toTokenMarketId,
                              ...createConversionFraction(toToken, toToken, withdrawRate),
                          },
                      ]
                    : []),
            ],
        };
        return encodeERC20BridgeAssetData(toToken, bridge.address, dydxBridgeDataEncoder.encode({ bridgeData }));
    }

    // Create fraction with default 18 decimal precision.
    function createConversionFraction(
        fromToken: string,
        toToken: string,
        rate: number,
    ): {
        conversionRateNumerator: BigNumber;
        conversionRateDenominator: BigNumber;
    } {
        const fromDecimals = TOKEN_INFO[fromToken].decimals;
        const toDecimals = TOKEN_INFO[toToken].decimals;
        return {
            conversionRateNumerator: fromTokenUnitAmount(rate, toDecimals),
            conversionRateDenominator: fromTokenUnitAmount(1, fromDecimals),
        };
    }

    function randomAccountId(): BigNumber {
        return new BigNumber(hexUtils.random());
    }

    describe('DAI -> USDC', () => {
        const makerAddress = CHONKY_DAI_WALLET;
        function _createOrder(fields: Partial<Order> = {}): Order {
            return createOrder(fields);
        }

        it('validates a fully solvent order', async () => {
            // This account is collateralized enough to fill the order with just
            // withdraws.
            const accountId = randomAccountId();
            await depositAndWithdrawAsync(makerAddress, accountId, 200, 0);
            const order = _createOrder({
                makerAssetData: encodeDydxBridgeAssetData({
                    accountId,
                    depositRate: 0,
                }),
            });
            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState(order, SIGNATURE).callAsync();
            expect(fillableTakerAssetAmount).to.bignumber.eq(order.takerAssetAmount);
        });

        it('validates a perpetually solvent order', async () => {
            // This account is not very well collateralized, but the deposit rate
            // will keep the collateralization ratio the same or better.
            const accountId = randomAccountId();
            await depositAndWithdrawAsync(makerAddress, accountId, 1, 0);
            const order = _createOrder({
                makerAssetData: encodeDydxBridgeAssetData({
                    accountId,
                    depositRate: minMarginRatio,
                }),
            });
            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState(order, SIGNATURE).callAsync();
            expect(fillableTakerAssetAmount).to.bignumber.eq(order.takerAssetAmount);
        });

        it('validates a partially solvent order with an inadequate deposit', async () => {
            // This account is not very well collateralized and the deposit rate is
            // also too low to sustain the collateralization ratio for the full order.
            const accountId = randomAccountId();
            await depositAndWithdrawAsync(makerAddress, accountId, 1, 0);
            const order = _createOrder({
                makerAssetData: encodeDydxBridgeAssetData({
                    accountId,
                    depositRate: minMarginRatio * 0.95,
                }),
            });
            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState(order, SIGNATURE).callAsync();
            expect(fillableTakerAssetAmount).to.bignumber.gt(0);
            expect(fillableTakerAssetAmount).to.bignumber.lt(order.takerAssetAmount);
        });

        it('validates a partially solvent order with no deposit', async () => {
            // This account is not very well collateralized and there is no deposit
            // to keep the collateralization ratio up.
            const accountId = randomAccountId();
            await depositAndWithdrawAsync(makerAddress, accountId, 1, 0);
            const order = _createOrder({
                makerAssetData: encodeDydxBridgeAssetData({
                    accountId,
                    depositRate: 0,
                }),
            });
            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState(order, SIGNATURE).callAsync();
            expect(fillableTakerAssetAmount).to.bignumber.gt(0);
            expect(fillableTakerAssetAmount).to.bignumber.lt(order.takerAssetAmount);
        });

        // TODO(dorothy-zbornak): We can't actually create an account that's below
        // the margin ratio without replacing the price oracles.
        it('invalidates a virtually insolvent order', async () => {
            // This account has a collateralization ratio JUST above the
            // minimum margin ratio, so it can only withdraw nearly zero maker tokens.
            const accountId = randomAccountId();
            await depositAndWithdrawAsync(makerAddress, accountId, 1, 1 / (minMarginRatio + 3e-4));
            const order = _createOrder({
                makerAssetData: encodeDydxBridgeAssetData({
                    accountId,
                    depositRate: 0,
                }),
            });
            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState(order, SIGNATURE).callAsync();
            // Price fluctuations will cause this to be a little above zero, so we
            // don't compare to zero.
            expect(fillableTakerAssetAmount).to.bignumber.lt(fromTokenUnitAmount(1e-3, DAI_DECIMALS));
        });
    });

    describe('USDC -> DAI', () => {
        const makerAddress = CHONKY_USDC_WALLET;
        function _createOrder(fields: Partial<Order> = {}): Order {
            return createOrder({
                makerAddress,
                takerAssetData: encodeERC20AssetData(USDC_ADDRESS),
                makerAssetData: encodeDydxBridgeAssetData({
                    fromToken: USDC_ADDRESS,
                    toToken: DAI_ADDRESS,
                }),
                makerAssetAmount: fromTokenUnitAmount(100, DAI_DECIMALS),
                takerAssetAmount: fromTokenUnitAmount(100, USDC_DECIMALS),
                ...fields,
            });
        }

        it('validates a fully solvent order', async () => {
            // This account is collateralized enough to fill the order with just
            // withdraws.
            const accountId = randomAccountId();
            await depositAndWithdrawAsync(makerAddress, accountId, 200, 0);
            const order = _createOrder({
                makerAssetData: encodeDydxBridgeAssetData({
                    accountId,
                    depositRate: 0,
                    fromToken: USDC_ADDRESS,
                    toToken: DAI_ADDRESS,
                }),
            });
            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState(order, SIGNATURE).callAsync();
            expect(fillableTakerAssetAmount).to.bignumber.eq(order.takerAssetAmount);
        });

        it('validates a perpetually solvent order', async () => {
            // This account is not very well collateralized, but the deposit rate
            // will keep the collateralization ratio the same or better.
            const accountId = randomAccountId();
            await depositAndWithdrawAsync(makerAddress, accountId, 1, 0);
            const order = _createOrder({
                makerAssetData: encodeDydxBridgeAssetData({
                    accountId,
                    depositRate: minMarginRatio,
                    fromToken: USDC_ADDRESS,
                    toToken: DAI_ADDRESS,
                }),
            });
            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState(order, SIGNATURE).callAsync();
            expect(fillableTakerAssetAmount).to.bignumber.eq(order.takerAssetAmount);
        });

        it('validates a partially solvent order with an inadequate deposit', async () => {
            // This account is not very well collateralized and the deposit rate is
            // also too low to sustain the collateralization ratio for the full order.
            const accountId = randomAccountId();
            await depositAndWithdrawAsync(makerAddress, accountId, 1, 0);
            const order = _createOrder({
                makerAssetData: encodeDydxBridgeAssetData({
                    accountId,
                    depositRate: minMarginRatio * 0.95,
                    fromToken: USDC_ADDRESS,
                    toToken: DAI_ADDRESS,
                }),
            });
            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState(order, SIGNATURE).callAsync();
            expect(fillableTakerAssetAmount).to.bignumber.gt(0);
            expect(fillableTakerAssetAmount).to.bignumber.lt(order.takerAssetAmount);
        });

        it('validates a partially solvent order with no deposit', async () => {
            // This account is not very well collateralized and there is no deposit
            // to keep the collateralization ratio up.
            const accountId = randomAccountId();
            await depositAndWithdrawAsync(makerAddress, accountId, 1, 0);
            const order = _createOrder({
                makerAssetData: encodeDydxBridgeAssetData({
                    accountId,
                    depositRate: 0,
                    fromToken: USDC_ADDRESS,
                    toToken: DAI_ADDRESS,
                }),
            });
            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState(order, SIGNATURE).callAsync();
            expect(fillableTakerAssetAmount).to.bignumber.gt(0);
            expect(fillableTakerAssetAmount).to.bignumber.lt(order.takerAssetAmount);
        });

        // TODO(dorothy-zbornak): We can't actually create an account that's below
        // the margin ratio without replacing the price oracles.
        it('invalidates a virtually insolvent order', async () => {
            // This account has a collateralization ratio JUST above the
            // minimum margin ratio, so it can only withdraw nearly zero maker tokens.
            const accountId = randomAccountId();
            await depositAndWithdrawAsync(makerAddress, accountId, 1, 1 / (minMarginRatio + 3e-4));
            const order = _createOrder({
                makerAssetData: encodeDydxBridgeAssetData({
                    accountId,
                    depositRate: 0,
                    fromToken: USDC_ADDRESS,
                    toToken: DAI_ADDRESS,
                }),
            });
            const [, fillableTakerAssetAmount] = await devUtils.getOrderRelevantState(order, SIGNATURE).callAsync();
            // Price fluctuations will cause this to be a little above zero, so we
            // don't compare to zero.
            expect(fillableTakerAssetAmount).to.bignumber.lt(fromTokenUnitAmount(1e-3, USDC_DECIMALS));
        });
    });
});