/**
 * Tests for ABI imports
 * 
 * Verifies that all ABIs are properly imported and have valid structure
 */

import { existsSync } from 'fs'
import { join } from 'path'

describe('ABI Export Module', () => {
  const abisDir = join(__dirname, '../src/abis')
  
  it('should have main index.ts file', () => {
    const indexPath = join(abisDir, 'index.ts')
    expect(existsSync(indexPath)).toBe(true)
  })

  it('should have all subdirectory index files', () => {
    expect(existsSync(join(abisDir, 'pools', 'index.ts'))).toBe(true)
    expect(existsSync(join(abisDir, 'factories', 'index.ts'))).toBe(true)
    expect(existsSync(join(abisDir, 'quoters', 'index.ts'))).toBe(true)
    expect(existsSync(join(abisDir, 'vaults', 'index.ts'))).toBe(true)
    expect(existsSync(join(abisDir, 'steer', 'index.ts'))).toBe(true)
  })

  it('should have organized directory structure', () => {
    expect(existsSync(join(abisDir, 'pools'))).toBe(true)
    expect(existsSync(join(abisDir, 'factories'))).toBe(true)
    expect(existsSync(join(abisDir, 'quoters'))).toBe(true)
    expect(existsSync(join(abisDir, 'vaults'))).toBe(true)
    expect(existsSync(join(abisDir, 'steer'))).toBe(true)
  })

  it('should have all 22 ABI files', () => {
    // 7 pool ABIs
    expect(existsSync(join(abisDir, 'pools', 'IUniswapV3Pool.json'))).toBe(true)
    expect(existsSync(join(abisDir, 'pools', 'IQuickSwapV3Pool.json'))).toBe(true)
    expect(existsSync(join(abisDir, 'pools', 'AlgebraIntegralPool.json'))).toBe(true)
    expect(existsSync(join(abisDir, 'pools', 'AlgebraV3UniDirectionalPool.json'))).toBe(true)
    expect(existsSync(join(abisDir, 'pools', 'LimitPool.json'))).toBe(true)
    expect(existsSync(join(abisDir, 'pools', 'MachineXV3Pool.json'))).toBe(true)
    expect(existsSync(join(abisDir, 'pools', 'AerodromV3Pool.json'))).toBe(true)
    
    // 4 factory ABIs
    expect(existsSync(join(abisDir, 'factories', 'UniswapV3Factory.json'))).toBe(true)
    expect(existsSync(join(abisDir, 'factories', 'QuickSwapFactory.json'))).toBe(true)
    expect(existsSync(join(abisDir, 'factories', 'AlgebraIntegralFactory.json'))).toBe(true)
    expect(existsSync(join(abisDir, 'factories', 'LimitPoolFactory.json'))).toBe(true)
    
    // 8 quoter ABIs
    expect(existsSync(join(abisDir, 'quoters', 'QuoterV2.json'))).toBe(true)
    expect(existsSync(join(abisDir, 'quoters', 'QuickSwapQuoterV2.json'))).toBe(true)
    expect(existsSync(join(abisDir, 'quoters', 'AlgebraIntegralCustomRouter.json'))).toBe(true)
    expect(existsSync(join(abisDir, 'quoters', 'QuoterV2AlgebraIntegral19.json'))).toBe(true)
    expect(existsSync(join(abisDir, 'quoters', 'QuoterV2Shadow.json'))).toBe(true)
    expect(existsSync(join(abisDir, 'quoters', 'QuoterV2Lynex.json'))).toBe(true)
    expect(existsSync(join(abisDir, 'quoters', 'QuoterV2Thick.json'))).toBe(true)
    expect(existsSync(join(abisDir, 'quoters', 'QuoterV2Aerodrom.json'))).toBe(true)
    
    // 4 vault ABIs + 1 steer ABI
    expect(existsSync(join(abisDir, 'vaults', 'MultiPositionLiquidityManager.json'))).toBe(true)
    expect(existsSync(join(abisDir, 'vaults', 'MultiPositionLiquidityManagerOld.json'))).toBe(true)
    expect(existsSync(join(abisDir, 'vaults', 'SinglePositionLiquidityManager.json'))).toBe(true)
    expect(existsSync(join(abisDir, 'vaults', 'SinglePostionVaultOld.json'))).toBe(true)
    expect(existsSync(join(abisDir, 'steer', 'SteerPeriphery.json'))).toBe(true)
  })
})

describe('Vault ABIs', () => {
  const vaultsDir = join(__dirname, '../src/abis/vaults')
  
  const vaultABIs = [
    'MultiPositionLiquidityManager.json',
    'MultiPositionLiquidityManagerOld.json',
    'SinglePositionLiquidityManager.json',
    'SinglePostionVaultOld.json',
  ]

  vaultABIs.forEach((abiFile) => {
    describe(abiFile, () => {
      it('should exist', () => {
        const abiPath = join(vaultsDir, abiFile)
        expect(existsSync(abiPath)).toBe(true)
      })

      it('should be valid JSON', () => {
        const abiPath = join(vaultsDir, abiFile)
        const abi = require(abiPath)
        expect(abi).toBeDefined()
        expect(typeof abi).toBe('object')
      })

      it('should have abi array', () => {
        const abiPath = join(vaultsDir, abiFile)
        const abi = require(abiPath)
        // Some ABIs are objects with .abi property, others are arrays directly
        const abiArray = Array.isArray(abi) ? abi : abi.abi
        expect(abiArray).toBeDefined()
        expect(Array.isArray(abiArray)).toBe(true)
        expect(abiArray.length).toBeGreaterThan(0)
      })
    })
  })
})

describe('Steer ABIs', () => {
  const steerDir = join(__dirname, '../src/abis/steer')
  
  const steerABIs = [
    'SteerPeriphery.json',
  ]

  steerABIs.forEach((abiFile) => {
    describe(abiFile, () => {
      it('should exist', () => {
        const abiPath = join(steerDir, abiFile)
        expect(existsSync(abiPath)).toBe(true)
      })

      it('should be valid JSON', () => {
        const abiPath = join(steerDir, abiFile)
        const abi = require(abiPath)
        expect(abi).toBeDefined()
        expect(typeof abi).toBe('object')
      })

      it('should have abi array', () => {
        const abiPath = join(steerDir, abiFile)
        const abi = require(abiPath)
        // Some ABIs are objects with .abi property, others are arrays directly
        const abiArray = Array.isArray(abi) ? abi : abi.abi
        expect(abiArray).toBeDefined()
        expect(Array.isArray(abiArray)).toBe(true)
        expect(abiArray.length).toBeGreaterThan(0)
      })
    })
  })
})

describe('Quoter ABIs', () => {
  const quotersDir = join(__dirname, '../src/abis/quoters')
  
  const quoterABIs = [
    'QuoterV2.json',
    'QuickSwapQuoterV2.json',
    'AlgebraIntegralCustomRouter.json',
    'QuoterV2AlgebraIntegral19.json',
    'QuoterV2Shadow.json',
    'QuoterV2Lynex.json',
    'QuoterV2Thick.json',
    'QuoterV2Aerodrom.json',
  ]

  quoterABIs.forEach((abiFile) => {
    describe(abiFile, () => {
      it('should exist', () => {
        const abiPath = join(quotersDir, abiFile)
        expect(existsSync(abiPath)).toBe(true)
      })

      it('should be valid JSON', () => {
        const abiPath = join(quotersDir, abiFile)
        const abi = require(abiPath)
        expect(abi).toBeDefined()
        expect(typeof abi).toBe('object')
      })

      it('should have abi array', () => {
        const abiPath = join(quotersDir, abiFile)
        const abi = require(abiPath)
        // Some ABIs are objects with .abi property, others are arrays directly
        const abiArray = Array.isArray(abi) ? abi : abi.abi
        expect(abiArray).toBeDefined()
        expect(Array.isArray(abiArray)).toBe(true)
        expect(abiArray.length).toBeGreaterThan(0)
      })
    })
  })
})

describe('Factory ABIs', () => {
  const factoriesDir = join(__dirname, '../src/abis/factories')
  
  const factoryABIs = [
    'UniswapV3Factory.json',
    'QuickSwapFactory.json',
    'AlgebraIntegralFactory.json',
    'LimitPoolFactory.json',
  ]

  factoryABIs.forEach((abiFile) => {
    describe(abiFile, () => {
      it('should exist', () => {
        const abiPath = join(factoriesDir, abiFile)
        expect(existsSync(abiPath)).toBe(true)
      })

      it('should be valid JSON', () => {
        const abiPath = join(factoriesDir, abiFile)
        const abi = require(abiPath)
        expect(abi).toBeDefined()
        expect(typeof abi).toBe('object')
      })

      it('should have abi array', () => {
        const abiPath = join(factoriesDir, abiFile)
        const abi = require(abiPath)
        expect(abi.abi).toBeDefined()
        expect(Array.isArray(abi.abi)).toBe(true)
        expect(abi.abi.length).toBeGreaterThan(0)
      })
    })
  })
})

describe('Pool ABIs', () => {
  const poolsDir = join(__dirname, '../src/abis/pools')
  
  const poolABIs = [
    'IUniswapV3Pool.json',
    'IQuickSwapV3Pool.json',
    'AlgebraIntegralPool.json',
    'AlgebraV3UniDirectionalPool.json',
    'LimitPool.json',
    'MachineXV3Pool.json',
    'AerodromV3Pool.json',
  ]

  poolABIs.forEach((abiFile) => {
    describe(abiFile, () => {
      it('should exist', () => {
        const abiPath = join(poolsDir, abiFile)
        expect(existsSync(abiPath)).toBe(true)
      })

      it('should be valid JSON', () => {
        const abiPath = join(poolsDir, abiFile)
        const abi = require(abiPath)
        expect(abi).toBeDefined()
        expect(typeof abi).toBe('object')
      })

      it('should have abi array', () => {
        const abiPath = join(poolsDir, abiFile)
        const abi = require(abiPath)
        expect(abi.abi).toBeDefined()
        expect(Array.isArray(abi.abi)).toBe(true)
        expect(abi.abi.length).toBeGreaterThan(0)
      })
    })
  })

  describe('IUniswapV3Pool specific', () => {
    it('should contain slot0 function', () => {
      const abi = require(join(poolsDir, 'IUniswapV3Pool.json'))
      const slot0 = abi.abi.find(
        (item: any) => item.name === 'slot0' && item.type === 'function'
      )
      expect(slot0).toBeDefined()
    })
  })

  describe('AlgebraIntegralPool specific', () => {
    it('should contain globalState function', () => {
      const abi = require(join(poolsDir, 'AlgebraIntegralPool.json'))
      const globalState = abi.abi.find(
        (item: any) => item.name === 'globalState' && item.type === 'function'
      )
      expect(globalState).toBeDefined()
    })
  })
})

// describe('Factory ABIs', () => {
//   // Placeholder tests - will be implemented when factory ABIs are copied
//   it.skip('should have factory ABIs', () => {
//     expect(Factories).toBeDefined()
//   })
// })

// describe('Quoter ABIs', () => {
//   // Placeholder tests - will be implemented when quoter ABIs are copied
//   it.skip('should have quoter ABIs', () => {
//     expect(Quoters).toBeDefined()
//   })
// })

// describe('Vault ABIs', () => {
//   // Placeholder tests - will be implemented when vault ABIs are copied
//   it.skip('should have vault ABIs', () => {
//     expect(Vaults).toBeDefined()
//   })
// })

// describe('Steer ABIs', () => {
//   // Placeholder tests - will be implemented when steer ABIs are copied
//   it.skip('should have steer ABIs', () => {
//     expect(Steer).toBeDefined()
//   })
// })