// scripts/test-services.ts
// Test that all services initialize without crashing
// Usage: bun scripts/test-services.ts

import '../src/shims/preload.js'

// Ensure we don't accidentally talk to real servers
process.env.NODE_ENV = process.env.NODE_ENV || 'test'

type TestResult = { name: string; status: 'pass' | 'fail' | 'skip'; detail?: string }
const results: TestResult[] = []

function pass(name: string, detail?: string) {
  results.push({ name, status: 'pass', detail })
  console.log(`  ✅ ${name}${detail ? ` — ${detail}` : ''}`)
}

function fail(name: string, detail: string) {
  results.push({ name, status: 'fail', detail })
  console.log(`  ❌ ${name} — ${detail}`)
}

function skip(name: string, detail: string) {
  results.push({ name, status: 'skip', detail })
  console.log(`  ⏭️  ${name} — ${detail}`)
}

async function testGrowthBook() {
  console.log('\n--- GrowthBook (Feature Flags) ---')
  try {
    const gb = await import('../src/services/analytics/growthbook.js')

    // Test cached feature value returns default when GrowthBook is unavailable
    const boolResult = gb.getFeatureValue_CACHED_MAY_BE_STALE('nonexistent_feature', false)
    if (boolResult === false) {
      pass('getFeatureValue_CACHED_MAY_BE_STALE (bool)', 'returns default false')
    } else {
      fail('getFeatureValue_CACHED_MAY_BE_STALE (bool)', `expected false, got ${boolResult}`)
    }

    const strResult = gb.getFeatureValue_CACHED_MAY_BE_STALE('nonexistent_str', 'default_val')
    if (strResult === 'default_val') {
      pass('getFeatureValue_CACHED_MAY_BE_STALE (str)', 'returns default string')
    } else {
      fail('getFeatureValue_CACHED_MAY_BE_STALE (str)', `expected "default_val", got "${strResult}"`)
    }

    // Test Statsig gate check returns false
    const gateResult = gb.checkStatsigFeatureGate_CACHED_MAY_BE_STALE('nonexistent_gate')
    if (gateResult === false) {
      pass('checkStatsigFeatureGate_CACHED_MAY_BE_STALE', 'returns false for unknown gate')
    } else {
      fail('checkStatsigFeatureGate_CACHED_MAY_BE_STALE', `expected false, got ${gateResult}`)
    }
  } catch (err: any) {
    fail('GrowthBook import', err.message)
  }
}

async function testAnalyticsSink() {
  console.log('\n--- Analytics Sink ---')
  try {
    const analytics = await import('../src/services/analytics/index.js')

    // logEvent should queue without crashing when no sink is attached
    analytics.logEvent('test_event', { test_key: 1 })
    pass('logEvent (no sink)', 'queues without crash')

    await analytics.logEventAsync('test_async_event', { test_key: 2 })
    pass('logEventAsync (no sink)', 'queues without crash')
  } catch (err: any) {
    fail('Analytics sink', err.message)
  }
}

async function testPolicyLimits() {
  console.log('\n--- Policy Limits ---')
  try {
    const pl = await import('../src/services/policyLimits/index.js')

    // isPolicyAllowed should return true (fail open) when no restrictions loaded
    const result = pl.isPolicyAllowed('allow_remote_sessions')
    if (result === true) {
      pass('isPolicyAllowed (no cache)', 'fails open — returns true')
    } else {
      fail('isPolicyAllowed (no cache)', `expected true (fail open), got ${result}`)
    }

    // isPolicyLimitsEligible should return false without valid auth
    const eligible = pl.isPolicyLimitsEligible()
    pass('isPolicyLimitsEligible', `returns ${eligible} (expected false in test env)`)
  } catch (err: any) {
    fail('Policy limits', err.message)
  }
}

async function testRemoteManagedSettings() {
  console.log('\n--- Remote Managed Settings ---')
  try {
    const rms = await import('../src/services/remoteManagedSettings/index.js')

    // isEligibleForRemoteManagedSettings should return false without auth
    const eligible = rms.isEligibleForRemoteManagedSettings()
    pass('isEligibleForRemoteManagedSettings', `returns ${eligible} (expected false in test env)`)

    // waitForRemoteManagedSettingsToLoad should resolve immediately if not eligible
    await rms.waitForRemoteManagedSettingsToLoad()
    pass('waitForRemoteManagedSettingsToLoad', 'resolves immediately when not eligible')
  } catch (err: any) {
    fail('Remote managed settings', err.message)
  }
}

async function testBootstrapData() {
  console.log('\n--- Bootstrap Data ---')
  try {
    const bootstrap = await import('../src/services/api/bootstrap.js')

    // fetchBootstrapData should not crash — just skip when no auth
    await bootstrap.fetchBootstrapData()
    pass('fetchBootstrapData', 'completes without crash (skips when no auth)')
  } catch (err: any) {
    // fetchBootstrapData catches its own errors, so this means an import-level issue
    fail('Bootstrap data', err.message)
  }
}

async function testSessionMemoryUtils() {
  console.log('\n--- Session Memory ---')
  try {
    const smUtils = await import('../src/services/SessionMemory/sessionMemoryUtils.js')

    // Default config should be sensible
    const config = smUtils.DEFAULT_SESSION_MEMORY_CONFIG
    if (config.minimumMessageTokensToInit > 0 && config.minimumTokensBetweenUpdate > 0) {
      pass('DEFAULT_SESSION_MEMORY_CONFIG', `init=${config.minimumMessageTokensToInit} tokens, update=${config.minimumTokensBetweenUpdate} tokens`)
    } else {
      fail('DEFAULT_SESSION_MEMORY_CONFIG', 'unexpected config values')
    }

    // getLastSummarizedMessageId should return undefined initially
    const lastId = smUtils.getLastSummarizedMessageId()
    if (lastId === undefined) {
      pass('getLastSummarizedMessageId', 'returns undefined initially')
    } else {
      fail('getLastSummarizedMessageId', `expected undefined, got ${lastId}`)
    }
  } catch (err: any) {
    fail('Session memory utils', err.message)
  }
}

async function testCostTracker() {
  console.log('\n--- Cost Tracking ---')
  try {
    const ct = await import('../src/cost-tracker.js')

    // Total cost should start at 0
    const cost = ct.getTotalCost()
    if (cost === 0) {
      pass('getTotalCost', 'starts at $0.00')
    } else {
      pass('getTotalCost', `current: $${cost.toFixed(4)} (non-zero means restored session)`)
    }

    // Duration should be available
    const duration = ct.getTotalDuration()
    pass('getTotalDuration', `${duration}ms`)

    // Token counters should be available
    const inputTokens = ct.getTotalInputTokens()
    const outputTokens = ct.getTotalOutputTokens()
    pass('Token counters', `input=${inputTokens}, output=${outputTokens}`)

    // Lines changed
    const added = ct.getTotalLinesAdded()
    const removed = ct.getTotalLinesRemoved()
    pass('Lines changed', `+${added} -${removed}`)
  } catch (err: any) {
    fail('Cost tracker', err.message)
  }
}

async function testInit() {
  console.log('\n--- Init (entrypoint) ---')
  try {
    const { init } = await import('../src/entrypoints/init.js')
    await init()
    pass('init()', 'completed successfully')
  } catch (err: any) {
    fail('init()', err.message)
  }
}

async function main() {
  console.log('=== Services Layer Smoke Test ===')
  console.log(`Environment: NODE_ENV=${process.env.NODE_ENV}`)
  console.log(`Auth: ANTHROPIC_API_KEY=${process.env.ANTHROPIC_API_KEY ? '(set)' : '(not set)'}`)

  // Test individual services first (order: least-dependent → most-dependent)
  await testAnalyticsSink()
  await testGrowthBook()
  await testPolicyLimits()
  await testRemoteManagedSettings()
  await testBootstrapData()
  await testSessionMemoryUtils()
  await testCostTracker()

  // Then test the full init sequence
  await testInit()

  // Summary
  console.log('\n=== Summary ===')
  const passed = results.filter(r => r.status === 'pass').length
  const failed = results.filter(r => r.status === 'fail').length
  const skipped = results.filter(r => r.status === 'skip').length
  console.log(`  ${passed} passed, ${failed} failed, ${skipped} skipped`)

  if (failed > 0) {
    console.log('\nFailed tests:')
    for (const r of results.filter(r => r.status === 'fail')) {
      console.log(`  ❌ ${r.name}: ${r.detail}`)
    }
    process.exit(1)
  }

  console.log('\n✅ All services handle graceful degradation correctly')
}

main().catch(err => {
  console.error('Fatal error in smoke test:', err)
  process.exit(1)
})