jest.mock('@steerprotocol/sdk', () => {
  const Protocol = { Lynex: 'Lynex' };
  return { Protocol };
});

jest.mock('../../src/helpers/ProtocolDetector', () => {
  return {
    ProtocolDetector: jest.fn().mockImplementation(() => ({
      isAlgebraIntegralVault: jest.fn().mockReturnValue(false),
      isAlgebraVault: jest.fn().mockReturnValue(false),
      isPoolSharkVault: jest.fn().mockReturnValue(false),
      isAlgebraUniDirectionalVault: jest.fn().mockReturnValue(false),
      isMachineXV3Vault: jest.fn().mockReturnValue(false),
      isAerodromeVault: jest.fn().mockReturnValue(false),
      isAlgebraIntegral19Vault: jest.fn().mockReturnValue(false),
      isShadowVault: jest.fn().mockReturnValue(false),
      isThickV2Vault: jest.fn().mockReturnValue(false),
      getProtocol: jest.fn().mockReturnValue(null),
    })),
  };
});

jest.mock('../../src/abis/pools', () => ({
  AlgebraIntegralPool: { abi: ['algebra-integral-pool'] },
  IQuickSwapV3Pool: { abi: ['quickswap-pool'] },
  AlgebraV3UniDirectionalPool: { abi: ['algebra-uni-pool'] },
  LimitPool: { abi: ['limit-pool'] },
  MachineXV3Pool: { abi: ['machine-pool'] },
  AerodromV3Pool: { abi: ['aerodrome-pool'] },
  IUniswapV3Pool: { abi: ['uniswap-pool'] },
}));

jest.mock('../../src/abis/factories', () => ({
  AlgebraIntegralFactory: { abi: ['algebra-integral-factory'] },
  QuickSwapFactory: { abi: ['quickswap-factory'] },
  LimitPoolFactory: { abi: ['limit-factory'] },
  UniswapV3Factory: { abi: ['uniswap-factory'] },
}));

jest.mock('../../src/abis/quoters', () => ({
  QuoterV2AlgebraIntegral19: { abi: ['quoter-integral19'] },
  QuoterV2Shadow: ['shadow-quoter'],
  AlgebraIntegralCustomRouter: ['algebra-integral-quoter'],
  QuoterV2Lynex: ['lynex-quoter'],
  QuickSwapQuoterV2: { abi: ['quickswap-quoter'] },
  QuoterV2Thick: { abi: ['thick-quoter'] },
  QuoterV2Aerodrom: ['aerodrome-quoter'],
  QuoterV2: { abi: ['uniswap-quoter'] },
}));

jest.mock('../../src/abis/vaults', () => ({
  MultiPositionLiquidityManager: { abi: ['multi-vault'] },
  SinglePositionLiquidityManager: { abi: ['single-vault'] },
  MultiPositionLiquidityManagerOld: { abi: ['multi-vault-old'] },
  SinglePostionVaultOld: { abi: ['single-vault-old'] },
}));

jest.mock('../../src/abis/steer', () => ({
  SteerPeriphery: { abi: ['periphery'] },
}));

import { AbiManager } from '../../src/helpers/AbiManager';

describe('AbiManager behavior', () => {
  it('selects factory ABI based on protocol detection', () => {
    const manager = new AbiManager();
    const detector = (manager as any).protocolDetector;

    detector.isAlgebraIntegralVault.mockReturnValue(true);
    expect(manager.getFactoryAbi('beacon')).toEqual([
      'algebra-integral-factory',
    ]);

    detector.isAlgebraIntegralVault.mockReturnValue(false);
    detector.isAlgebraVault.mockReturnValue(true);
    expect(manager.getFactoryAbi('beacon')).toEqual(['quickswap-factory']);

    detector.isAlgebraVault.mockReturnValue(false);
    detector.isPoolSharkVault.mockReturnValue(true);
    expect(manager.getFactoryAbi('beacon')).toEqual(['limit-factory']);

    detector.isPoolSharkVault.mockReturnValue(false);
    expect(manager.getFactoryAbi('beacon')).toEqual(['uniswap-factory']);
  });

  it('selects pool ABI based on protocol detection', () => {
    const manager = new AbiManager();
    const detector = (manager as any).protocolDetector;

    detector.isAlgebraIntegralVault.mockReturnValue(true);
    expect(manager.getPoolAbi('beacon')).toEqual(['algebra-integral-pool']);

    detector.isAlgebraIntegralVault.mockReturnValue(false);
    detector.isAlgebraVault.mockReturnValue(true);
    expect(manager.getPoolAbi('beacon')).toEqual(['quickswap-pool']);

    detector.isAlgebraVault.mockReturnValue(false);
    detector.isAlgebraUniDirectionalVault.mockReturnValue(true);
    expect(manager.getPoolAbi('beacon')).toEqual(['algebra-uni-pool']);

    detector.isAlgebraUniDirectionalVault.mockReturnValue(false);
    detector.isPoolSharkVault.mockReturnValue(true);
    expect(manager.getPoolAbi('beacon')).toEqual(['limit-pool']);

    detector.isPoolSharkVault.mockReturnValue(false);
    detector.isMachineXV3Vault.mockReturnValue(true);
    expect(manager.getPoolAbi('beacon')).toEqual(['machine-pool']);

    detector.isMachineXV3Vault.mockReturnValue(false);
    detector.isAerodromeVault.mockReturnValue(true);
    expect(manager.getPoolAbi('beacon')).toEqual(['aerodrome-pool']);

    detector.isAerodromeVault.mockReturnValue(false);
    expect(manager.getPoolAbi('beacon')).toEqual(['uniswap-pool']);
  });

  it('selects vault ABI based on upgrade and multi position', () => {
    const manager = new AbiManager();

    expect(manager.getVaultAbi('multi-vault', true)).toEqual(['multi-vault']);
    expect(manager.getVaultAbi('multi-vault', false)).toEqual([
      'multi-vault-old',
    ]);
    expect(manager.getVaultAbi('single-vault', true)).toEqual(['single-vault']);
    expect(manager.getVaultAbi('single-vault', false)).toEqual([
      'single-vault-old',
    ]);
  });

  it('selects quoter ABI with priority rules', () => {
    const manager = new AbiManager();
    const detector = (manager as any).protocolDetector;

    detector.isAlgebraIntegral19Vault.mockReturnValue(true);
    expect(manager.getQuoterV2Abi('beacon')).toEqual(['quoter-integral19']);

    detector.isAlgebraIntegral19Vault.mockReturnValue(false);
    detector.isShadowVault.mockReturnValue(true);
    expect(manager.getQuoterV2Abi('beacon')).toEqual(['shadow-quoter']);

    detector.isShadowVault.mockReturnValue(false);
    detector.isAlgebraIntegralVault.mockReturnValue(true);
    expect(manager.getQuoterV2Abi('beacon')).toEqual([
      'algebra-integral-quoter',
    ]);

    detector.isAlgebraIntegralVault.mockReturnValue(false);
    detector.getProtocol.mockReturnValue('Lynex');
    expect(manager.getQuoterV2Abi('beacon')).toEqual(['lynex-quoter']);

    detector.getProtocol.mockReturnValue(null);
    detector.isAlgebraVault.mockReturnValue(true);
    expect(manager.getQuoterV2Abi('beacon')).toEqual(['quickswap-quoter']);

    detector.isAlgebraVault.mockReturnValue(false);
    detector.isThickV2Vault.mockReturnValue(true);
    expect(manager.getQuoterV2Abi('beacon')).toEqual(['thick-quoter']);

    detector.isThickV2Vault.mockReturnValue(false);
    detector.isAerodromeVault.mockReturnValue(true);
    expect(manager.getQuoterV2Abi('beacon')).toEqual(['aerodrome-quoter']);

    detector.isAerodromeVault.mockReturnValue(false);
    expect(manager.getQuoterV2Abi('beacon')).toEqual(['uniswap-quoter']);
  });

  it('returns Steer periphery ABI', () => {
    const manager = new AbiManager();
    expect(manager.getSteerPeripheryAbi()).toEqual(['periphery']);
  });
});