/**
 * Drift Market Discovery Script
 * 
 * Queries the Drift SDK to list all available perpetual markets with their
 * complete specifications including market index, oracle address, and order sizes.
 * 
 * Usage:
 *   npm run discover-markets
 *   npx tsx scripts/discover-drift-markets.ts
 *   npx tsx scripts/discover-drift-markets.ts FARTCOIN  # Search for specific symbol
 */

import { initializeDriftService, getDriftService } from '../lib/drift/client'
import { OracleSource } from '@drift-labs/sdk'

// Helper to decode market name from bytes (Drift stores names as 32-byte arrays)
function decodeMarketName(nameBytes: number[] | Uint8Array | undefined): string {
  if (!nameBytes) return ''
  
  // Convert to string and trim null bytes
  const bytes = Array.isArray(nameBytes) ? nameBytes : Array.from(nameBytes)
  const name = String.fromCharCode(...bytes.filter(b => b !== 0))
  return name.trim()
}

// Map oracle source enum to human-readable string
function getOracleSourceName(oracleSource: OracleSource | number): string {
  // OracleSource enum values from Drift SDK
  const sourceMap: Record<number, string> = {
    0: 'Pyth',
    1: 'Switchboard',
    2: 'QuoteAsset',
    3: 'Pyth1K',
    4: 'Pyth1M',
    5: 'PythStableCoin',
    6: 'Prelaunch',
    7: 'PythPull',
    8: 'Pyth1KPull',
    9: 'Pyth1MPull',
    10: 'PythStableCoinPull',
    11: 'SwitchboardOnDemand',
  }
  
  // Handle both enum and number types
  const sourceValue = typeof oracleSource === 'number' ? oracleSource : Object.values(oracleSource)[0]
  return sourceMap[sourceValue as number] || `Unknown(${sourceValue})`
}

// Format number with appropriate decimals
function formatNumber(value: number, decimals: number = 6): string {
  if (value === 0) return '0'
  if (value < 0.0001) return value.toExponential(2)
  return value.toFixed(decimals).replace(/\.?0+$/, '')
}

interface MarketInfo {
  index: number
  symbol: string
  oracleSource: string
  minOrderSize: number
  orderStepSize: number
  tickSize: number
  oracleAddress: string
  contractType: string
  imfFactor: number
  marginRatioInitial: number
  marginRatioMaintenance: number
  status: string
}

async function discoverMarkets(searchSymbol?: string): Promise<void> {
  console.log('\n🔍 Discovering Drift Protocol Markets...\n')
  
  try {
    // Initialize Drift service
    await initializeDriftService()
    const driftService = getDriftService()
    const driftClient = driftService.getClient()
    
    console.log('✅ Connected to Drift Protocol\n')
    
    // Get all perp market accounts
    const perpMarketAccounts = driftClient.getPerpMarketAccounts()
    
    if (!perpMarketAccounts || perpMarketAccounts.length === 0) {
      console.log('❌ No perpetual markets found')
      return
    }
    
    console.log(`📊 Found ${perpMarketAccounts.length} Perpetual Markets:\n`)
    
    // Collect market information
    const markets: MarketInfo[] = []
    let foundSearchSymbol: MarketInfo | null = null
    
    for (let i = 0; i < perpMarketAccounts.length; i++) {
      const market = perpMarketAccounts[i]
      
      if (!market) continue
      
      // Extract market name from the name field (stored as bytes)
      let symbol = decodeMarketName(market.name as unknown as number[])
      if (!symbol) {
        symbol = `Market-${i}`
      }
      
      // Get oracle information
      const oracleAddress = market.amm?.oracle?.toString() || 'N/A'
      const oracleSource = market.amm?.oracleSource
      
      // Get order sizing (values are stored with different precision)
      // Base asset precision is typically 9 decimals
      const minOrderSize = market.amm?.minOrderSize 
        ? Number(market.amm.minOrderSize) / 1e9 
        : 0
      
      const orderStepSize = market.amm?.orderStepSize
        ? Number(market.amm.orderStepSize) / 1e9
        : 0
      
      // Tick size for price (quote asset precision is 6 decimals for USDC)
      const tickSize = market.amm?.orderTickSize
        ? Number(market.amm.orderTickSize) / 1e6
        : 0.0001
      
      // Get margin requirements (stored as percentages with 4 decimal precision)
      const marginRatioInitial = market.marginRatioInitial 
        ? Number(market.marginRatioInitial) / 10000
        : 0
      
      const marginRatioMaintenance = market.marginRatioMaintenance
        ? Number(market.marginRatioMaintenance) / 10000
        : 0
      
      // IMF factor (insurance margin fraction)
      const imfFactor = market.imfFactor
        ? Number(market.imfFactor) / 1e6
        : 0
      
      // Market status
      const statusMap: Record<number, string> = {
        0: 'Initialized',
        1: 'Active',
        2: 'FundingPaused',
        3: 'AmmPaused',
        4: 'FillPaused',
        5: 'WithdrawPaused',
        6: 'ReduceOnly',
        7: 'Settlement',
        8: 'Delisted',
      }
      const status = statusMap[Object.values(market.status)[0] as number] || 'Unknown'
      
      // Contract type
      const contractTypeMap: Record<number, string> = {
        0: 'Perpetual',
        1: 'Future',
      }
      const contractType = contractTypeMap[Object.values(market.contractType)[0] as number] || 'Unknown'
      
      const marketInfo: MarketInfo = {
        index: i,
        symbol,
        oracleSource: getOracleSourceName(oracleSource),
        minOrderSize,
        orderStepSize,
        tickSize,
        oracleAddress,
        contractType,
        imfFactor,
        marginRatioInitial,
        marginRatioMaintenance,
        status,
      }
      
      markets.push(marketInfo)
      
      // Check if this matches our search
      if (searchSymbol && symbol.toUpperCase().includes(searchSymbol.toUpperCase())) {
        foundSearchSymbol = marketInfo
      }
    }
    
    // Print table header
    console.log('Index | Symbol               | Oracle      | Min Order  | Step Size  | Tick Size  | Status    | Oracle Address')
    console.log('------|----------------------|-------------|------------|------------|------------|-----------|' + '-'.repeat(50))
    
    // Print each market
    for (const market of markets) {
      const isHighlighted = searchSymbol && market.symbol.toUpperCase().includes(searchSymbol.toUpperCase())
      const highlight = isHighlighted ? ' ← FOUND!' : ''
      
      const row = [
        market.index.toString().padStart(5),
        market.symbol.padEnd(20),
        market.oracleSource.padEnd(11),
        formatNumber(market.minOrderSize).padStart(10),
        formatNumber(market.orderStepSize).padStart(10),
        formatNumber(market.tickSize).padStart(10),
        market.status.padEnd(9),
        market.oracleAddress.substring(0, 44) + '...' + highlight,
      ].join(' | ')
      
      if (isHighlighted) {
        console.log(`\x1b[32m${row}\x1b[0m`) // Green highlight
      } else {
        console.log(row)
      }
    }
    
    // If searching for a specific symbol
    if (searchSymbol) {
      console.log('\n' + '='.repeat(100))
      
      if (foundSearchSymbol) {
        console.log(`\n🎯 ${foundSearchSymbol.symbol} Configuration:\n`)
        
        // Generate copy-paste config for config/trading.ts
        console.log('Copy this into config/trading.ts (SUPPORTED_MARKETS):')
        console.log('```typescript')
        console.log(`'${foundSearchSymbol.symbol}': {`)
        console.log(`  symbol: '${foundSearchSymbol.symbol}',`)
        console.log(`  driftMarketIndex: ${foundSearchSymbol.index},`)
        console.log(`  pythPriceFeedId: '${foundSearchSymbol.oracleAddress}',`)
        console.log(`  minOrderSize: ${foundSearchSymbol.minOrderSize},`)
        console.log(`  tickSize: ${foundSearchSymbol.tickSize},`)
        console.log(`  positionSize: 50,  // Customize as needed`)
        console.log(`  leverage: 15,      // Customize as needed`)
        console.log(`},`)
        console.log('```')
        
        // Generate symbol normalizer snippet
        const symbolBase = foundSearchSymbol.symbol.replace('-PERP', '').replace('-SPOT', '')
        console.log('\nAlso add to normalizeTradingViewSymbol():')
        console.log('```typescript')
        console.log(`if (upper.includes('${symbolBase}')) return '${foundSearchSymbol.symbol}'`)
        console.log('```')
        
        // Print detailed market info
        console.log('\n📋 Full Market Details:')
        console.log('  Market Index:', foundSearchSymbol.index)
        console.log('  Symbol:', foundSearchSymbol.symbol)
        console.log('  Contract Type:', foundSearchSymbol.contractType)
        console.log('  Status:', foundSearchSymbol.status)
        console.log('  Oracle Source:', foundSearchSymbol.oracleSource)
        console.log('  Oracle Address:', foundSearchSymbol.oracleAddress)
        console.log('  Min Order Size:', foundSearchSymbol.minOrderSize, 'units')
        console.log('  Order Step Size:', foundSearchSymbol.orderStepSize, 'units')
        console.log('  Tick Size (Price):', foundSearchSymbol.tickSize, 'USD')
        console.log('  Initial Margin Ratio:', (foundSearchSymbol.marginRatioInitial * 100).toFixed(2) + '%')
        console.log('  Maintenance Margin Ratio:', (foundSearchSymbol.marginRatioMaintenance * 100).toFixed(2) + '%')
        console.log('  IMF Factor:', foundSearchSymbol.imfFactor)
        
        // Calculate max leverage from margin requirement
        if (foundSearchSymbol.marginRatioInitial > 0) {
          const maxLeverage = Math.floor(1 / foundSearchSymbol.marginRatioInitial)
          console.log('  Max Leverage (calculated):', maxLeverage + 'x')
        }
        
      } else {
        console.log(`\n⚠️  ${searchSymbol.toUpperCase()} not found in available markets.`)
        console.log('\nPossible reasons:')
        console.log('  1. The market may not exist on Drift yet')
        console.log('  2. The symbol name might be different (try variations)')
        console.log('  3. The market might be delisted or not yet active')
        console.log('\nTip: Check Drift app manually: https://app.drift.trade')
        
        // Suggest similar symbols
        const similar = markets.filter(m => 
          m.symbol.toUpperCase().includes(searchSymbol.substring(0, 3).toUpperCase())
        )
        if (similar.length > 0) {
          console.log('\nSimilar symbols found:')
          similar.forEach(m => console.log(`  - ${m.symbol} (index: ${m.index})`))
        }
      }
    }
    
    // Summary
    console.log('\n' + '='.repeat(100))
    console.log(`\n📊 Summary: ${markets.length} perpetual markets available`)
    
    const activeMarkets = markets.filter(m => m.status === 'Active')
    console.log(`   Active markets: ${activeMarkets.length}`)
    
    const pythMarkets = markets.filter(m => m.oracleSource.includes('Pyth'))
    console.log(`   Pyth oracle markets: ${pythMarkets.length}`)
    
    // Cleanup
    await driftService.disconnect()
    console.log('\n✅ Discovery complete\n')
    
  } catch (error) {
    console.error('❌ Error discovering markets:', error)
    throw error
  }
}

// Main entry point
const searchArg = process.argv[2]
discoverMarkets(searchArg)
  .then(() => {
    process.exit(0)
  })
  .catch((error) => {
    console.error('\n❌ Discovery failed:', error)
    process.exit(1)
  })