/**
 * Tests for BalanceQuerier
 *
 * Verifies vault balance retrieval with protocol-specific methods
 */

describe('BalanceQuerier', () => {
  it('should have BalanceQuerier module available', () => {
    const fs = require('fs');
    const path = require('path');
    const balanceQuerierPath = path.join(
      __dirname,
      '../../src/helpers/BalanceQuerier.ts',
    );
    expect(fs.existsSync(balanceQuerierPath)).toBe(true);
  });

  it('should be exported from helpers index', () => {
    const fs = require('fs');
    const path = require('path');
    const indexPath = path.join(__dirname, '../../src/helpers/index.ts');
    const indexContent = fs.readFileSync(indexPath, 'utf-8');
    expect(indexContent).toContain('BalanceQuerier');
    expect(indexContent).toContain('VaultBalances');
    expect(indexContent).toContain('VaultInput');
  });

  describe('Module structure', () => {
    it('should import required dependencies', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain("import { Contract } from 'ethers'");
      expect(content).toContain(
        "import { ProtocolDetector } from './ProtocolDetector'",
      );
    });

    it('should define BalanceQuerier class', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain('export class BalanceQuerier');
    });

    it('should have constructor accepting SteerPeriphery contract', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain('constructor(');
      expect(content).toContain('steerPeripheryContract: Contract');
      expect(content).toContain('protocolDetector?: ProtocolDetector');
    });
  });

  describe('VaultBalances interface', () => {
    it('should define VaultBalances interface', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain('export interface VaultBalances');
      expect(content).toContain('bal0: bigint');
      expect(content).toContain('bal1: bigint');
    });
  });

  describe('VaultInput interface', () => {
    it('should define VaultInput interface', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain('export interface VaultInput');
      expect(content).toContain('vaultAddress: string');
      expect(content).toContain('beaconName: string');
      expect(content).toContain('token0: string');
      expect(content).toContain('token1: string');
    });
  });

  describe('getVaultBalances', () => {
    it('should define getVaultBalances method', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain('getVaultBalances');
      expect(content).toContain('vault: VaultInput');
      expect(content).toContain('Promise<VaultBalances>');
    });

    it('should check for PoolShark protocol', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain(
        'this.protocolDetector.isPoolSharkVault(vault.beaconName)',
      );
    });

    it('should check for Blackhole protocol', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain(
        'this.protocolDetector.isBlackholeVault(vault.beaconName)',
      );
    });

    it('should check for Aerodrome protocol', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain(
        'this.protocolDetector.isAerodromeVault(vault.beaconName)',
      );
    });

    it('should use algebraVaultDetailsByAddress for special protocols', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain('algebraVaultDetailsByAddress');
      expect(content).toContain('vault.vaultAddress');
    });

    it('should extract token0Balance from algebraDetails', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain('algebraDetails.token0Balance');
      expect(content).toContain('algebraDetails.token1Balance');
    });

    it('should use vaultBalancesByAddressWithFees for standard protocols', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain('vaultBalancesByAddressWithFees');
      expect(content).toContain('staticCall');
    });

    it('should destructure balance array for standard protocols', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain('[bal0, bal1]');
    });

    it('should return VaultBalances structure', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain('return { bal0, bal1 }');
    });
  });

  describe('Protocol detection integration', () => {
    it('should use ProtocolDetector for protocol checks', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain('this.protocolDetector');
    });

    it('should initialize ProtocolDetector if not provided', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain('protocolDetector || new ProtocolDetector()');
    });
  });

  describe('SteerPeriphery contract usage', () => {
    it('should store SteerPeriphery contract reference', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain('private steerPeripheryContract: Contract');
      expect(content).toContain(
        'this.steerPeripheryContract = steerPeripheryContract',
      );
    });

    it('should use SteerPeriphery for balance queries', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain(
        'this.steerPeripheryContract.algebraVaultDetailsByAddress',
      );
      expect(content).toContain('vaultBalancesByAddressWithFees');
    });
  });

  describe('Variable declarations', () => {
    it('should declare balance variables', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain('let bal0: bigint');
      expect(content).toContain('let bal1: bigint');
    });
  });

  describe('Documentation', () => {
    it('should have JSDoc comments for class', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain('/**');
      expect(content).toContain('* BalanceQuerier');
    });

    it('should have JSDoc comments for getVaultBalances', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain('* Get vault token balances');
      expect(content).toContain('@param vault');
      expect(content).toContain('@returns');
    });

    it('should document protocol-specific methods', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain('PoolShark');
      expect(content).toContain('Blackhole');
      expect(content).toContain('Aerodrome');
      expect(content).toContain('algebraVaultDetailsByAddress');
      expect(content).toContain('vaultBalancesByAddressWithFees');
    });
  });

  describe('Control flow', () => {
    it('should have conditional logic for protocol types', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      expect(content).toContain('if (');
      expect(content).toContain('||');
      expect(content).toContain('} else {');
    });

    it('should use OR logic for multiple protocol checks', () => {
      const fs = require('fs');
      const path = require('path');
      const balanceQuerierPath = path.join(
        __dirname,
        '../../src/helpers/BalanceQuerier.ts',
      );
      const content = fs.readFileSync(balanceQuerierPath, 'utf-8');

      // Count OR operators in protocol checks
      const orMatches = content.match(/\|\|/g);
      expect(orMatches).not.toBeNull();
      expect(orMatches!.length).toBeGreaterThanOrEqual(2); // At least 2 OR operators for 3 protocols
    });
  });
});