import { BN } from '@coral-xyz/anchor';
import { OpenOrders } from '@project-serum/serum';
import { expect } from 'chai';
import cloneDeep from 'lodash/cloneDeep';
import range from 'lodash/range';

import { I80F48, ONE_I80F48, ZERO_I80F48 } from '../numbers/I80F48';
import { BankForHealth, StablePriceModel, TokenIndex } from './bank';
import { HealthCache, PerpInfo, Serum3Info, TokenInfo } from './healthCache';
import { HealthType, PerpPosition } from './mangoAccount';
import { PerpMarket, PerpOrderSide } from './perp';
import { MarketIndex } from './serum3';

function mockBankAndOracle(
  tokenIndex: TokenIndex,
  maintWeight: number,
  initWeight: number,
  price: number,
  stablePrice: number,
): BankForHealth {
  return {
    tokenIndex,
    maintAssetWeight: I80F48.fromNumber(1 - maintWeight),
    initAssetWeight: I80F48.fromNumber(1 - initWeight),
    maintLiabWeight: I80F48.fromNumber(1 + maintWeight),
    initLiabWeight: I80F48.fromNumber(1 + initWeight),
    price: I80F48.fromNumber(price),
    stablePriceModel: { stablePrice: stablePrice } as StablePriceModel,
    scaledInitAssetWeight: () => I80F48.fromNumber(1 - initWeight),
    scaledInitLiabWeight: () => I80F48.fromNumber(1 + initWeight),
  };
}

function mockPerpMarket(
  perpMarketIndex: number,
  maintBaseWeight: number,
  initBaseWeight: number,
  baseLotSize: number,
  price: number,
): PerpMarket {
  return {
    perpMarketIndex,
    maintBaseAssetWeight: I80F48.fromNumber(1 - maintBaseWeight),
    initBaseAssetWeight: I80F48.fromNumber(1 - initBaseWeight),
    maintBaseLiabWeight: I80F48.fromNumber(1 + maintBaseWeight),
    initBaseLiabWeight: I80F48.fromNumber(1 + initBaseWeight),
    maintOverallAssetWeight: I80F48.fromNumber(1 - 0.02),
    initOverallAssetWeight: I80F48.fromNumber(1 - 0.05),
    price: I80F48.fromNumber(price),
    stablePriceModel: { stablePrice: price } as StablePriceModel,
    quoteLotSize: new BN(100),
    baseLotSize: new BN(baseLotSize),
    longFunding: ZERO_I80F48(),
    shortFunding: ZERO_I80F48(),
  } as unknown as PerpMarket;
}

describe('Health Cache', () => {
  it('test_health0', () => {
    const sourceBank: BankForHealth = mockBankAndOracle(
      1 as TokenIndex,
      0.1,
      0.2,
      1,
      1,
    );
    const targetBank: BankForHealth = mockBankAndOracle(
      4 as TokenIndex,
      0.3,
      0.5,
      5,
      5,
    );

    const ti1 = TokenInfo.fromBank(sourceBank, I80F48.fromNumber(100));
    const ti2 = TokenInfo.fromBank(targetBank, I80F48.fromNumber(-10));

    const si1 = Serum3Info.fromOoModifyingTokenInfos(
      1,
      ti2,
      0,
      ti1,
      2 as MarketIndex,
      {
        quoteTokenTotal: new BN(21),
        baseTokenTotal: new BN(18),
        quoteTokenFree: new BN(1),
        baseTokenFree: new BN(3),
        referrerRebatesAccrued: new BN(2),
      } as any as OpenOrders,
    );

    const pM = mockPerpMarket(9, 0.1, 0.2, 10, targetBank.price.toNumber());
    const pp = new PerpPosition(
      pM.perpMarketIndex,
      0,
      new BN(0),
      new BN(3),
      I80F48.fromNumber(-310),
      new BN(0),
      ZERO_I80F48(),
      ZERO_I80F48(),
      new BN(7),
      new BN(11),
      new BN(1),
      new BN(2),
      0,
      0,
      new BN(0),
      new BN(0),
      new BN(0),
      0,
      ZERO_I80F48(),
      ZERO_I80F48(),
      new BN(0),
      ZERO_I80F48(),
    );
    const pi1 = PerpInfo.fromPerpPosition(pM, pp);

    const hc = new HealthCache([ti1, ti2], [si1], [pi1]);

    // for bank1/oracle1, including open orders (scenario: bids execute)
    const health1 = (100.0 + 1.0 + 2.0 + (20.0 + 15.0 * 5.0)) * 0.8;
    // for bank2/oracle2
    const health2 = (-10.0 + 3.0) * 5.0 * 1.5;
    // for perp (scenario: bids execute)
    const health3 =
      (3.0 + 7.0 + 1.0) * 10.0 * 5.0 * 0.8 +
      (-310.0 + 2.0 * 100.0 - 7.0 * 10.0 * 5.0);

    const health = hc.health(HealthType.init).toNumber();
    console.log(
      ` - health ${health
        .toFixed(3)
        .padStart(
          10,
        )}, case "test that includes all the side values (like referrer_rebates_accrued)"`,
    );

    expect(health - (health1 + health2 + health3)).lessThan(0.0000001);
  });

  it('test_health1', (done) => {
    function testFixture(fixture: {
      name: string;
      token1: number;
      token2: number;
      token3: number;
      oo12: [number, number];
      oo13: [number, number];
      perp1: [number, number, number, number];
      expectedHealth: number;
    }): void {
      const bank1: BankForHealth = mockBankAndOracle(
        1 as TokenIndex,
        0.1,
        0.2,
        1,
        1,
      );
      const bank2: BankForHealth = mockBankAndOracle(
        4 as TokenIndex,
        0.3,
        0.5,
        5,
        5,
      );
      const bank3: BankForHealth = mockBankAndOracle(
        5 as TokenIndex,
        0.3,
        0.5,
        10,
        10,
      );

      const ti1 = TokenInfo.fromBank(bank1, I80F48.fromNumber(fixture.token1));
      const ti2 = TokenInfo.fromBank(bank2, I80F48.fromNumber(fixture.token2));
      const ti3 = TokenInfo.fromBank(bank3, I80F48.fromNumber(fixture.token3));

      const si1 = Serum3Info.fromOoModifyingTokenInfos(
        1,
        ti2,
        0,
        ti1,
        2 as MarketIndex,
        {
          quoteTokenTotal: new BN(fixture.oo12[0]),
          baseTokenTotal: new BN(fixture.oo12[1]),
          quoteTokenFree: new BN(0),
          baseTokenFree: new BN(0),
          referrerRebatesAccrued: new BN(0),
        } as any as OpenOrders,
      );

      const si2 = Serum3Info.fromOoModifyingTokenInfos(
        2,
        ti3,
        0,
        ti1,
        2 as MarketIndex,
        {
          quoteTokenTotal: new BN(fixture.oo13[0]),
          baseTokenTotal: new BN(fixture.oo13[1]),
          quoteTokenFree: new BN(0),
          baseTokenFree: new BN(0),
          referrerRebatesAccrued: new BN(0),
        } as any as OpenOrders,
      );

      const pM = mockPerpMarket(9, 0.1, 0.2, 10, bank2.price.toNumber());
      const pp = new PerpPosition(
        pM.perpMarketIndex,
        0,
        new BN(0),
        new BN(fixture.perp1[0]),
        I80F48.fromNumber(fixture.perp1[1]),
        new BN(0),
        ZERO_I80F48(),
        ZERO_I80F48(),
        new BN(fixture.perp1[2]),
        new BN(fixture.perp1[3]),
        new BN(0),
        new BN(0),
        0,
        0,
        new BN(0),
        new BN(0),
        new BN(0),
        0,
        ZERO_I80F48(),
        ZERO_I80F48(),
        new BN(0),
        ZERO_I80F48(),
      );
      const pi1 = PerpInfo.fromPerpPosition(pM, pp);

      const hc = new HealthCache([ti1, ti2, ti3], [si1, si2], [pi1]);
      const health = hc.health(HealthType.init).toNumber();
      console.log(
        ` - case "${fixture.name}" health ${health
          .toFixed(3)
          .padStart(10)}, expected ${fixture.expectedHealth}`,
      );
      expect(health - fixture.expectedHealth).lessThan(0.0000001);
    }

    const basePrice = 5;
    const baseLotsToQuote = 10.0 * basePrice;

    testFixture({
      name: '0',
      token1: 100,
      token2: -10,
      token3: 0,
      oo12: [20, 15],
      oo13: [0, 0],
      perp1: [3, -131, 7, 11],
      expectedHealth:
        // for token1, including open orders (scenario: bids execute)
        (100.0 + (20.0 + 15.0 * basePrice)) * 0.8 -
        // for token2
        10.0 * basePrice * 1.5 +
        // for perp (scenario: bids execute)
        (3.0 + 7.0) * baseLotsToQuote * 0.8 +
        (-131.0 - 7.0 * baseLotsToQuote),
    });

    testFixture({
      name: '1',
      token1: -100,
      token2: 10,
      token3: 0,
      oo12: [20, 15],
      oo13: [0, 0],
      perp1: [-10, -131, 7, 11],
      expectedHealth:
        // for token1
        -100.0 * 1.2 +
        // for token2, including open orders (scenario: asks execute)
        (10.0 * basePrice + (20.0 + 15.0 * basePrice)) * 0.5 +
        // for perp (scenario: asks execute)
        (-10.0 - 11.0) * baseLotsToQuote * 1.2 +
        (-131.0 + 11.0 * baseLotsToQuote),
    });

    testFixture({
      name: '2: weighted positive perp pnl',
      token1: 0,
      token2: 0,
      token3: 0,
      oo12: [0, 0],
      oo13: [0, 0],
      perp1: [-1, 100, 0, 0],
      expectedHealth: 0.95 * (100.0 - 1.2 * 1.0 * baseLotsToQuote),
    });

    testFixture({
      name: '3: negative perp pnl is not weighted',
      token1: 0,
      token2: 0,
      token3: 0,
      oo12: [0, 0],
      oo13: [0, 0],
      perp1: [1, -100, 0, 0],
      expectedHealth: -100.0 + 0.8 * 1.0 * baseLotsToQuote,
    });

    testFixture({
      name: '4: perp health',
      token1: 0,
      token2: 0,
      token3: 0,
      oo12: [0, 0],
      oo13: [0, 0],
      perp1: [10, 100, 0, 0],
      expectedHealth: 0.95 * (100.0 + 0.8 * 10.0 * baseLotsToQuote),
    });

    testFixture({
      name: '5: perp health',
      token1: 0,
      token2: 0,
      token3: 0,
      oo12: [0, 0],
      oo13: [0, 0],
      perp1: [30, -100, 0, 0],
      expectedHealth: 0.95 * (-100.0 + 0.8 * 30.0 * baseLotsToQuote),
    });

    testFixture({
      name: '6, reserved oo funds',
      token1: -100,
      token2: -10,
      token3: -10,
      oo12: [1, 1],
      oo13: [1, 1],
      perp1: [0, 0, 0, 0],
      expectedHealth:
        // tokens
        -100.0 * 1.2 -
        10.0 * 5.0 * 1.5 -
        10.0 * 10.0 * 1.5 +
        // oo_1_2 (-> token1)
        (1.0 + 5.0) * 1.2 +
        // oo_1_3 (-> token1)
        (1.0 + 10.0) * 1.2,
    });

    testFixture({
      name: '7, reserved oo funds cross the zero balance level',
      token1: -14,
      token2: -10,
      token3: -10,
      oo12: [1, 1],
      oo13: [1, 1],
      perp1: [0, 0, 0, 0],
      expectedHealth:
        -14.0 * 1.2 -
        10.0 * 5.0 * 1.5 -
        10.0 * 10.0 * 1.5 +
        // oo_1_2 (-> token1)
        3.0 * 1.2 +
        3.0 * 0.8 +
        // oo_1_3 (-> token1)
        8.0 * 1.2 +
        3.0 * 0.8,
    });

    testFixture({
      name: '8, reserved oo funds in a non-quote currency',
      token1: -100,
      token2: -100,
      token3: -1,
      oo12: [0, 0],
      oo13: [10, 1],
      perp1: [0, 0, 0, 0],
      expectedHealth:
        // tokens
        -100.0 * 1.2 -
        100.0 * 5.0 * 1.5 -
        10.0 * 1.5 +
        // oo_1_3 (-> token3)
        10.0 * 1.5 +
        10.0 * 0.5,
    });

    testFixture({
      name: '9, like 8 but oo_1_2 flips the oo_1_3 target',
      token1: -100,
      token2: -100,
      token3: -1,
      oo12: [100, 0],
      oo13: [10, 1],
      perp1: [0, 0, 0, 0],
      expectedHealth:
        // tokens
        -100.0 * 1.2 -
        100.0 * 5.0 * 1.5 -
        10.0 * 1.5 +
        // oo_1_2 (-> token1)
        80.0 * 1.2 +
        20.0 * 0.8 +
        // oo_1_3 (-> token1)
        20.0 * 0.8,
    });

    done();
  });

  it('test_max_swap', (done) => {
    const b0 = mockBankAndOracle(0 as TokenIndex, 0.1, 0.1, 2, 2);
    const b1 = mockBankAndOracle(1 as TokenIndex, 0.2, 0.2, 3, 3);
    const b2 = mockBankAndOracle(2 as TokenIndex, 0.3, 0.3, 4, 4);
    const banks = [b0, b1, b2];
    const hc = new HealthCache(
      [
        TokenInfo.fromBank(b0, I80F48.fromNumber(0)),
        TokenInfo.fromBank(b1, I80F48.fromNumber(0)),
        TokenInfo.fromBank(b2, I80F48.fromNumber(0)),
      ],
      [],
      [],
    );

    expect(
      hc
        .getMaxSwapSourceForHealthRatio(
          b0,
          b1,
          I80F48.fromNumber(2 / 3),
          I80F48.fromNumber(50),
        )
        .toNumber(),
    ).lessThan(0.0000001);

    function findMaxSwapActual(
      hc: HealthCache,
      source: TokenIndex,
      target: TokenIndex,
      minValue: number,
      priceFactor: number,
      maxSwapFn: (HealthCache) => I80F48,
    ): number[] {
      const clonedHc: HealthCache = cloneDeep(hc);

      const sourcePrice = clonedHc.tokenInfos[source].prices;
      const targetPrice = clonedHc.tokenInfos[target].prices;
      const swapPrice = I80F48.fromNumber(priceFactor)
        .mul(sourcePrice.oracle)
        .div(targetPrice.oracle);
      const sourceAmount = clonedHc.getMaxSwapSourceForHealthFn(
        banks[source],
        banks[target],
        swapPrice,
        I80F48.fromNumber(minValue),
        maxSwapFn,
      );

      function valueForAmount(amount: I80F48): I80F48 {
        // adjust token balance
        const clonedHcClone: HealthCache = cloneDeep(clonedHc);
        clonedHc.tokenInfos[source].balanceNative.isub(amount);
        clonedHc.tokenInfos[target].balanceNative.iadd(amount.mul(swapPrice));
        return maxSwapFn(clonedHcClone);
      }

      return [
        sourceAmount.toNumber(),
        valueForAmount(sourceAmount).toNumber(),
        valueForAmount(sourceAmount.sub(ONE_I80F48())).toNumber(),
        valueForAmount(sourceAmount.add(ONE_I80F48())).toNumber(),
      ];
    }

    function checkMaxSwapResult(
      hc: HealthCache,
      source: TokenIndex,
      target: TokenIndex,
      minValue: number,
      priceFactor: number,
      maxSwapFn: (HealthCache) => I80F48,
    ): void {
      const [sourceAmount, actualValue, minusValue, plusValue] =
        findMaxSwapActual(hc, source, target, minValue, priceFactor, maxSwapFn);
      console.log(
        ` -- checking ${source} to ${target} for priceFactor: ${priceFactor}, target: ${minValue} actual: ${minusValue}/${actualValue}/${plusValue}, amount: ${sourceAmount}`,
      );
      if (actualValue < minValue) {
        // check that swapping more would decrease the ratio!
        expect(plusValue < actualValue);
      } else {
        expect(actualValue >= minValue);
        // either we're within tolerance of the target, or swapping 1 more would
        // bring us below the target
        expect(actualValue < minValue + 1 || plusValue < minValue);
      }
    }

    function maxSwapFnRatio(hc: HealthCache): I80F48 {
      return hc.healthRatio(HealthType.init);
    }

    function maxSwapFn(hc: HealthCache): I80F48 {
      return hc.health(HealthType.init);
    }

    for (const fn of [maxSwapFn, maxSwapFnRatio]) {
      {
        console.log(' - test 0');
        // adjust by usdc
        const clonedHc: HealthCache = cloneDeep(hc);
        clonedHc.tokenInfos[1].balanceNative.iadd(
          I80F48.fromNumber(100).div(clonedHc.tokenInfos[1].prices.oracle),
        );

        for (const priceFactor of [0.1, 0.9, 1.1]) {
          for (const target of range(1, 100, 1)) {
            checkMaxSwapResult(
              clonedHc,
              0 as TokenIndex,
              1 as TokenIndex,
              target,
              priceFactor,
              fn,
            );
            checkMaxSwapResult(
              clonedHc,
              1 as TokenIndex,
              0 as TokenIndex,
              target,
              priceFactor,
              fn,
            );
            checkMaxSwapResult(
              clonedHc,
              0 as TokenIndex,
              2 as TokenIndex,
              target,
              priceFactor,
              fn,
            );
          }
        }

        // At this unlikely price it's healthy to swap infinitely
        expect(function () {
          findMaxSwapActual(
            clonedHc,
            0 as TokenIndex,
            1 as TokenIndex,
            50.0,
            1.5,
            fn,
          );
        }).to.throw('Number out of range');
      }

      {
        console.log(' - test 1');
        const clonedHc: HealthCache = cloneDeep(hc);
        // adjust by usdc
        clonedHc.tokenInfos[0].balanceNative.iadd(
          I80F48.fromNumber(-20).div(clonedHc.tokenInfos[0].prices.oracle),
        );
        clonedHc.tokenInfos[1].balanceNative.iadd(
          I80F48.fromNumber(100).div(clonedHc.tokenInfos[1].prices.oracle),
        );

        for (const priceFactor of [0.1, 0.9, 1.1]) {
          for (const target of range(1, 100, 1)) {
            checkMaxSwapResult(
              clonedHc,
              0 as TokenIndex,
              1 as TokenIndex,
              target,
              priceFactor,
              fn,
            );
            checkMaxSwapResult(
              clonedHc,
              1 as TokenIndex,
              0 as TokenIndex,
              target,
              priceFactor,
              fn,
            );
            checkMaxSwapResult(
              clonedHc,
              0 as TokenIndex,
              2 as TokenIndex,
              target,
              priceFactor,
              fn,
            );
            checkMaxSwapResult(
              clonedHc,
              2 as TokenIndex,
              0 as TokenIndex,
              target,
              priceFactor,
              fn,
            );
          }
        }
      }

      {
        console.log(' - test 2');
        const clonedHc: HealthCache = cloneDeep(hc);
        // adjust by usdc
        clonedHc.tokenInfos[0].balanceNative.iadd(
          I80F48.fromNumber(-50).div(clonedHc.tokenInfos[0].prices.oracle),
        );
        clonedHc.tokenInfos[1].balanceNative.iadd(
          I80F48.fromNumber(100).div(clonedHc.tokenInfos[1].prices.oracle),
        );
        // possible even though the init ratio is <100
        checkMaxSwapResult(
          clonedHc,
          1 as TokenIndex,
          0 as TokenIndex,
          100,
          1,

          maxSwapFn,
        );
      }

      {
        console.log(' - test 3');
        const clonedHc: HealthCache = cloneDeep(hc);
        // adjust by usdc
        clonedHc.tokenInfos[0].balanceNative.iadd(
          I80F48.fromNumber(-30).div(clonedHc.tokenInfos[0].prices.oracle),
        );
        clonedHc.tokenInfos[1].balanceNative.iadd(
          I80F48.fromNumber(100).div(clonedHc.tokenInfos[1].prices.oracle),
        );
        clonedHc.tokenInfos[2].balanceNative.iadd(
          I80F48.fromNumber(-30).div(clonedHc.tokenInfos[2].prices.oracle),
        );

        // swapping with a high ratio advises paying back all liabs
        // and then swapping even more because increasing assets in 0 has better asset weight
        const initRatio = clonedHc.healthRatio(HealthType.init).toNumber();
        const [amount, actualRatio] = findMaxSwapActual(
          clonedHc,
          1 as TokenIndex,
          0 as TokenIndex,
          100,
          1,
          maxSwapFn,
        );
        expect(actualRatio / 2.0 > initRatio);
        expect(amount - 100 / 3).lessThan(1);
      }

      {
        console.log(' - test 4');
        const clonedHc: HealthCache = cloneDeep(hc);
        // adjust by usdc
        clonedHc.tokenInfos[0].balanceNative.iadd(
          I80F48.fromNumber(100).div(clonedHc.tokenInfos[0].prices.oracle),
        );
        clonedHc.tokenInfos[1].balanceNative.iadd(
          I80F48.fromNumber(-2).div(clonedHc.tokenInfos[1].prices.oracle),
        );
        clonedHc.tokenInfos[2].balanceNative.iadd(
          I80F48.fromNumber(-65).div(clonedHc.tokenInfos[2].prices.oracle),
        );

        const initRatio = clonedHc.healthRatio(HealthType.init);
        expect(initRatio.toNumber()).greaterThan(3);
        expect(initRatio.toNumber()).lessThan(4);

        checkMaxSwapResult(
          clonedHc,
          0 as TokenIndex,
          1 as TokenIndex,
          1,
          1,
          maxSwapFn,
        );
        checkMaxSwapResult(
          clonedHc,
          0 as TokenIndex,
          1 as TokenIndex,
          3,
          1,
          maxSwapFn,
        );
        checkMaxSwapResult(
          clonedHc,
          0 as TokenIndex,
          1 as TokenIndex,
          4,
          1,
          maxSwapFn,
        );
      }

      // TODO test 5

      {
        console.log(' - test 6');
        const clonedHc: HealthCache = cloneDeep(hc);
        clonedHc.serum3Infos = [
          new Serum3Info(
            I80F48.fromNumber(30 / 3),
            I80F48.fromNumber(30 / 2),
            1,
            0,
            0 as MarketIndex,
          ),
        ];

        // adjust by usdc
        clonedHc.tokenInfos[0].balanceNative.iadd(
          I80F48.fromNumber(-20).div(clonedHc.tokenInfos[0].prices.oracle),
        );
        clonedHc.tokenInfos[1].balanceNative.iadd(
          I80F48.fromNumber(-40).div(clonedHc.tokenInfos[1].prices.oracle),
        );
        clonedHc.tokenInfos[2].balanceNative.iadd(
          I80F48.fromNumber(120).div(clonedHc.tokenInfos[2].prices.oracle),
        );

        for (const priceFactor of [0.9, 1.1]) {
          for (const target of range(1, 100, 1)) {
            checkMaxSwapResult(
              clonedHc,
              0 as TokenIndex,
              1 as TokenIndex,
              target,
              priceFactor,
              fn,
            );
            checkMaxSwapResult(
              clonedHc,
              1 as TokenIndex,
              0 as TokenIndex,
              target,
              priceFactor,
              fn,
            );
            checkMaxSwapResult(
              clonedHc,
              0 as TokenIndex,
              2 as TokenIndex,
              target,
              priceFactor,
              fn,
            );
            checkMaxSwapResult(
              clonedHc,
              1 as TokenIndex,
              2 as TokenIndex,
              target,
              priceFactor,
              fn,
            );
            checkMaxSwapResult(
              clonedHc,
              2 as TokenIndex,
              0 as TokenIndex,
              target,
              priceFactor,
              fn,
            );
            checkMaxSwapResult(
              clonedHc,
              2 as TokenIndex,
              1 as TokenIndex,
              target,
              priceFactor,
              fn,
            );
          }
        }
      }

      {
        // check starting with negative health but swapping can make it positive
        console.log(' - test 7');
        const clonedHc: HealthCache = cloneDeep(hc);

        // adjust by usdc
        clonedHc.tokenInfos[0].balanceNative.iadd(
          I80F48.fromNumber(-20).div(clonedHc.tokenInfos[0].prices.oracle),
        );
        clonedHc.tokenInfos[1].balanceNative.iadd(
          I80F48.fromNumber(20).div(clonedHc.tokenInfos[1].prices.oracle),
        );
        expect(clonedHc.health(HealthType.init).toNumber() < 0);

        for (const priceFactor of [0.9, 1.1]) {
          for (const target of range(1, 100, 1)) {
            checkMaxSwapResult(
              clonedHc,
              1 as TokenIndex,
              0 as TokenIndex,
              target,
              priceFactor,
              fn,
            );
          }
        }
      }

      {
        // check starting with negative health but swapping can't make it positive
        console.log(' - test 8');
        const clonedHc: HealthCache = cloneDeep(hc);

        // adjust by usdc
        clonedHc.tokenInfos[0].balanceNative.iadd(
          I80F48.fromNumber(-20).div(clonedHc.tokenInfos[0].prices.oracle),
        );
        clonedHc.tokenInfos[1].balanceNative.iadd(
          I80F48.fromNumber(10).div(clonedHc.tokenInfos[1].prices.oracle),
        );
        expect(clonedHc.health(HealthType.init).toNumber() < 0);

        for (const priceFactor of [0.9, 1.1]) {
          for (const target of range(1, 100, 1)) {
            checkMaxSwapResult(
              clonedHc,
              1 as TokenIndex,
              0 as TokenIndex,
              target,
              priceFactor,
              fn,
            );
          }
        }
      }

      {
        // swap some assets into a zero-asset-weight token
        console.log(' - test 9');
        const clonedHc: HealthCache = cloneDeep(hc);

        // adjust by usdc
        clonedHc.tokenInfos[0].balanceNative.iadd(
          I80F48.fromNumber(10).div(clonedHc.tokenInfos[0].prices.oracle),
        );
        clonedHc.tokenInfos[1].initAssetWeight = ZERO_I80F48();
        expect(
          findMaxSwapActual(
            clonedHc,
            0 as TokenIndex,
            1 as TokenIndex,
            1,
            1,
            maxSwapFn,
          )[0] > 0,
        );

        for (const priceFactor of [0.9, 1.1]) {
          for (const target of range(1, 100, 1)) {
            checkMaxSwapResult(
              clonedHc,
              0 as TokenIndex,
              1 as TokenIndex,
              target,
              priceFactor,
              fn,
            );
          }
        }
      }
    }
    done();
  });

  it('test_max_perp', (done) => {
    const baseLotSize = 100;
    const b0 = mockBankAndOracle(0 as TokenIndex, 0.0, 0.0, 1, 1);
    const p0 = mockPerpMarket(0, 0.3, 0.3, baseLotSize, 2);
    const hc = new HealthCache(
      [TokenInfo.fromBank(b0, I80F48.fromNumber(0))],
      [],
      [PerpInfo.emptyFromPerpMarket(p0)],
    );

    expect(hc.health(HealthType.init).toNumber()).equals(0);

    expect(
      hc
        .getMaxPerpForHealthRatio(
          p0,
          I80F48.fromNumber(2),
          PerpOrderSide.bid,
          I80F48.fromNumber(50),
        )
        .toNumber(),
    ).equals(0);

    function findMaxTrade(
      hc: HealthCache,
      side: PerpOrderSide,
      ratio: number,
      priceFactor: number,
    ): number[] {
      const prices = hc.perpInfos[0].prices;
      const tradePrice = I80F48.fromNumber(priceFactor).mul(prices.oracle);
      const baseLots0 = hc
        .getMaxPerpForHealthRatio(
          p0,
          tradePrice,
          side,
          I80F48.fromNumber(ratio),
        )
        .toNumber();

      const direction = side == PerpOrderSide.bid ? 1 : -1;

      // compute the health ratio we'd get when executing the trade
      const baseLots1 = direction * baseLots0;
      let baseNative = I80F48.fromNumber(baseLots1).mul(
        I80F48.fromNumber(baseLotSize),
      );
      let hcClone: HealthCache = cloneDeep(hc);
      hcClone.perpInfos[0].baseLots.iadd(new BN(baseLots1));
      hcClone.perpInfos[0].quote.isub(baseNative.mul(tradePrice));
      const actualRatio = hcClone.healthRatio(HealthType.init);

      // the ratio for trading just one base lot extra
      const baseLots2 = direction * (baseLots0 + 1);
      baseNative = I80F48.fromNumber(baseLots2 * baseLotSize);
      hcClone = cloneDeep(hc);
      hcClone.perpInfos[0].baseLots.iadd(new BN(baseLots2));
      hcClone.perpInfos[0].quote.isub(baseNative.mul(tradePrice));
      const plusRatio = hcClone.healthRatio(HealthType.init);

      return [baseLots0, actualRatio.toNumber(), plusRatio.toNumber()];
    }

    function checkMaxTrade(
      hc: HealthCache,
      side: PerpOrderSide,
      ratio: number,
      priceFactor: number,
    ): void {
      const [baseLots, actualRatio, plusRatio] = findMaxTrade(
        hc,
        side,
        ratio,
        priceFactor,
      );
      console.log(
        `checking for price_factor: ${priceFactor}, target ratio ${ratio}: actual ratio: ${actualRatio}, plus ratio: ${plusRatio}, base_lots: ${baseLots}`,
      );
      expect(ratio).lessThan(actualRatio);
      expect(plusRatio - 0.1).lessThanOrEqual(ratio);
    }

    // adjust token
    hc.tokenInfos[0].balanceNative.iadd(I80F48.fromNumber(3000));
    for (const existing of [-5, 0, 3]) {
      const hcClone: HealthCache = cloneDeep(hc);
      hcClone.perpInfos[0].baseLots.iadd(new BN(existing));
      hcClone.perpInfos[0].quote.isub(
        I80F48.fromNumber(existing * baseLotSize * 2),
      );
      for (const side of [PerpOrderSide.bid, PerpOrderSide.ask]) {
        console.log(
          `existing ${existing} ${side === PerpOrderSide.bid ? 'bid' : 'ask'}`,
        );
        for (const priceFactor of [0.8, 1.0, 1.1]) {
          for (const ratio of range(1, 101, 1)) {
            checkMaxTrade(hcClone, side, ratio, priceFactor);
          }
        }
      }
    }

    // check some extremely bad prices
    checkMaxTrade(hc, PerpOrderSide.bid, 50, 2);
    checkMaxTrade(hc, PerpOrderSide.ask, 50, 0.1);

    // and extremely good prices
    expect(function () {
      findMaxTrade(hc, PerpOrderSide.bid, 50, 0.1);
    }).to.throw();
    expect(function () {
      findMaxTrade(hc, PerpOrderSide.ask, 50, 1.5);
    }).to.throw();

    done();
  });
});