/**
 * Tests for PositionExtractor
 * 
 * Verifies position extraction from vaults and execution results
 */

describe('PositionExtractor', () => {
  it('should have PositionExtractor module available', () => {
    const fs = require('fs')
    const path = require('path')
    const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
    expect(fs.existsSync(positionExtractorPath)).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('PositionExtractor')
    expect(indexContent).toContain('Position')
    expect(indexContent).toContain('VaultPositions')
  })

  describe('Module structure', () => {
    it('should import Contract from ethers', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('import { Contract } from "ethers"')
    })

    it('should define PositionExtractor class', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('export class PositionExtractor')
    })
  })

  describe('Position interface', () => {
    it('should define Position interface', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('export interface Position')
      expect(content).toContain('lowerTick: number')
      expect(content).toContain('upperTick: number')
      expect(content).toContain('weight: number')
    })
  })

  describe('VaultPositions interface', () => {
    it('should define VaultPositions interface', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('export interface VaultPositions')
      expect(content).toContain('multiPositions')
      expect(content).toContain('singlePosition')
    })

    it('should define multiPositions structure', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('upperTick: number')
      expect(content).toContain('lowerTick: number')
      expect(content).toContain('relativeWeight: 1')
    })

    it('should define singlePosition as nullable', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('singlePosition')
      expect(content).toContain('| null')
    })
  })

  describe('getCurrentVaultPositions', () => {
    it('should define getCurrentVaultPositions method', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('getCurrentVaultPositions')
      expect(content).toContain('vaultContract: Contract')
      expect(content).toContain('isMultiPosition: boolean')
      expect(content).toContain('Promise<VaultPositions>')
    })

    it('should handle multi-position vaults', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('if (isMultiPosition)')
      expect(content).toContain('vaultContract.getPositions()')
    })

    it('should handle single-position vaults', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('vaultContract.upperTick()')
      expect(content).toContain('vaultContract.lowerTick()')
    })

    it('should return VaultPositions structure', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('return {')
      expect(content).toContain('multiPositions:')
      expect(content).toContain('singlePosition:')
    })
  })

  describe('extractNewPositions', () => {
    it('should define extractNewPositions method', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('extractNewPositions')
      expect(content).toContain('executionResult: any')
      expect(content).toContain('Position[]')
    })

    it('should extract from valuesArray[1]', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('executionResult.valuesArray[1]')
    })

    it('should extract lowerTicks, upperTicks, and weights', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('lowerTicks')
      expect(content).toContain('upperTicks')
      expect(content).toContain('weights')
    })

    it('should convert values to numbers', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('Number(')
    })

    it('should create Position objects', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('const position: Position')
      expect(content).toContain('lowerTick:')
      expect(content).toContain('upperTick:')
      expect(content).toContain('weight:')
    })

    it('should handle extraction errors', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('try {')
      expect(content).toContain('catch')
      expect(content).toContain('throw new Error')
      expect(content).toContain('Failed to extract new positions')
    })

    it('should return array of positions', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('newPositions.push(position)')
      expect(content).toContain('return newPositions')
    })
  })

  describe('Data structure handling', () => {
    it('should initialize empty multi-positions array', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('vaultCurrentMultiPositions')
      expect(content).toContain('[]')
    })

    it('should initialize null single position', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('vaultCurrentSinglePosition')
      expect(content).toContain('null')
    })

    it('should iterate through position arrays', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('for (let i = 0')
      expect(content).toContain('i < ')
      expect(content).toContain('.length')
    })
  })

  describe('Documentation', () => {
    it('should have JSDoc comments for class', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('/**')
      expect(content).toContain('* PositionExtractor')
    })

    it('should have JSDoc comments for methods', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('* Get current positions')
      expect(content).toContain('* Extract new positions')
    })

    it('should document execution result structure', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('valuesArray[1]')
      expect(content).toContain('@param executionResult')
    })
  })

  describe('Edge cases', () => {
    it('should handle empty position arrays', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      // Empty arrays should result in empty newPositions array
      expect(content).toContain('const newPositions: Position[] = []')
    })

    it('should handle error messages properly', () => {
      const fs = require('fs')
      const path = require('path')
      const positionExtractorPath = path.join(__dirname, '../../src/helpers/PositionExtractor.ts')
      const content = fs.readFileSync(positionExtractorPath, 'utf-8')
      
      expect(content).toContain('error instanceof Error')
      expect(content).toContain('error.message')
      expect(content).toContain('String(error)')
    })
  })
})