// ✅ Redis-backed token-bucket rate limiter (per org)
// file: src/gateway/RateLimiter.ts

import { createClient } from 'redis'

const redis = createClient({ url: process.env.REDIS_URL })

interface RateLimitConfig {
  tokensPerMinute: number   // Long-run average
  burstCapacity: number     // Maximum burst size
  refillRatePerMs: number   // Derived: tokensPerMinute / 60000
}

const ORG_LIMITS: Record<string, RateLimitConfig> = {
  free:       { tokensPerMinute: 10_000,  burstCapacity: 20_000,  refillRatePerMs: 10_000/60000 },
  pro:        { tokensPerMinute: 100_000, burstCapacity: 200_000, refillRatePerMs: 100_000/60000 },
  enterprise: { tokensPerMinute: 500_000, burstCapacity: 1_000_000, refillRatePerMs: 500_000/60000 },
}

export async function checkRateLimit(
  orgId: string,
  tier: keyof typeof ORG_LIMITS,
  requestedTokens: number,
): Promise<{ allowed: boolean; remainingTokens: number; retryAfterMs: number }> {
  const config = ORG_LIMITS[tier]
  const key = `ratelimit:${orgId}`
  const now = Date.now()

  // Atomic token-bucket check using Redis Lua script (prevents race conditions)
  const result = await redis.eval(
    `
    local key = KEYS[1]
    local now = tonumber(ARGV[1])
    local requested = tonumber(ARGV[2])
    local capacity = tonumber(ARGV[3])
    local refillRate = tonumber(ARGV[4])

    local bucket = redis.call('HMGET', key, 'tokens', 'lastRefill')
    local tokens = tonumber(bucket[1]) or capacity
    local lastRefill = tonumber(bucket[2]) or now

    -- Refill based on elapsed time
    local elapsed = now - lastRefill
    tokens = math.min(capacity, tokens + elapsed * refillRate)

    local allowed = tokens >= requested
    if allowed then tokens = tokens - requested end

    redis.call('HMSET', key, 'tokens', tokens, 'lastRefill', now)
    redis.call('EXPIRE', key, 3600)

    return {allowed and 1 or 0, math.floor(tokens), allowed and 0 or math.floor((requested - tokens) / refillRate)}
    `,
    [key],
    [now, requestedTokens, config.burstCapacity, config.refillRatePerMs],
  ) as [number, number, number]

  return {
    allowed: result[0] === 1,
    remainingTokens: result[1],
    retryAfterMs: result[2],
  }
}

// ✅ Circuit breaker for LLM provider reliability
// file: src/gateway/CircuitBreaker.ts

type CircuitState = 'CLOSED' | 'OPEN' | 'HALF_OPEN'

interface CircuitConfig {
  failureThreshold: number    // Failures before opening
  successThreshold: number    // Successes in HALF_OPEN to close
  timeoutMs: number           // Time in OPEN before HALF_OPEN
  monitoringWindowMs: number  // Rolling window for failure counting
}

export class CircuitBreaker {
  private state: CircuitState = 'CLOSED'
  private failures = 0
  private successes = 0
  private lastFailureAt = 0

  constructor(
    private readonly providerName: string,
    private readonly config: CircuitConfig = {
      failureThreshold: 5,
      successThreshold: 2,
      timeoutMs: 60_000,  // 60 seconds in OPEN
      monitoringWindowMs: 30_000,
    },
  ) {}

  async execute<T>(fn: () => Promise<T>): Promise<T> {
    this.maybeMoveToHalfOpen()

    if (this.state === 'OPEN') {
      throw new CircuitOpenError(`Circuit OPEN for provider: ${this.providerName}`)
    }

    try {
      const result = await fn()
      this.onSuccess()
      return result
    } catch (error) {
      this.onFailure()
      throw error
    }
  }

  private maybeMoveToHalfOpen(): void {
    if (this.state === 'OPEN' && Date.now() - this.lastFailureAt > this.config.timeoutMs) {
      this.state = 'HALF_OPEN'
      this.successes = 0
    }
  }

  private onSuccess(): void {
    if (this.state === 'HALF_OPEN') {
      this.successes++
      if (this.successes >= this.config.successThreshold) {
        this.state = 'CLOSED'
        this.failures = 0
      }
    } else {
      this.failures = 0
    }
  }

  private onFailure(): void {
    this.lastFailureAt = Date.now()
    this.failures++
    if (this.failures >= this.config.failureThreshold) {
      this.state = 'OPEN'
    }
    if (this.state === 'HALF_OPEN') {
      this.state = 'OPEN'
    }
  }

  get isOpen(): boolean { return this.state === 'OPEN' }
}

export class CircuitOpenError extends Error {
  readonly name = 'CircuitOpenError' as const
}

// ✅ Multi-provider gateway — automatic failover + circuit breakers
// file: src/gateway/MultiProviderGateway.ts

import Anthropic from '@anthropic-ai/sdk'
import OpenAI from 'openai'

interface ProviderEntry {
  name: string
  breaker: CircuitBreaker
  priority: number  // Lower = try first
}

const PROVIDERS: ProviderEntry[] = [
  { name: 'anthropic', breaker: new CircuitBreaker('anthropic'), priority: 1 },
  { name: 'openai',    breaker: new CircuitBreaker('openai'),    priority: 2 },
  { name: 'deepseek',  breaker: new CircuitBreaker('deepseek'),  priority: 3 },
]

export class MultiProviderGateway {
  async *streamWithFallback(
    request: GatewayRequest,
    signal: AbortSignal,
  ): AsyncGenerator<WorkspaceAction> {
    const available = PROVIDERS
      .filter(p => !p.breaker.isOpen)
      .sort((a, b) => a.priority - b.priority)

    if (available.length === 0) {
      throw new Error('All AI providers unavailable (circuit breakers OPEN)')
    }

    let lastError: Error | null = null

    for (const provider of available) {
      try {
        yield* await provider.breaker.execute(async () =>
          this.streamFromProvider(provider.name, request, signal)
        )
        return  // Success — stop trying fallbacks
      } catch (error) {
        lastError = error as Error
        if (error instanceof CircuitOpenError) continue
        // If it's a non-transient error (schema, auth), don't retry other providers
        if (error instanceof GatewaySchemaError) throw error
        // Transient error (rate limit, 529, timeout) — try next provider
        console.warn(`[Gateway] Provider ${provider.name} failed: ${(error as Error).message}`)
      }
    }

    throw lastError ?? new Error('All providers failed')
  }
}

// ✅ Hedged request — returns first successful response, cancels the other
// file: src/gateway/HedgedGateway.ts

export class HedgedGateway {
  async *streamHedged(
    request: GatewayRequest,
    primaryProvider: string,
    hedgeProvider: string,
    hedgeDelayMs = 1000,  // Start hedge only if primary hasn't responded in 1s
  ): AsyncGenerator<WorkspaceAction> {
    const primaryController = new AbortController()
    const hedgeController = new AbortController()

    // Start primary immediately
    const primary = this.streamFromProvider(primaryProvider, request, primaryController.signal)

    // Start hedge after delay (avoids unnecessary double-billing on fast responses)
    const hedgePromise = new Promise<AsyncGenerator<WorkspaceAction>>((resolve) => {
      setTimeout(() => {
        resolve(this.streamFromProvider(hedgeProvider, request, hedgeController.signal))
      }, hedgeDelayMs)
    })

    // Race: whichever generator yields first wins
    const winner = await Promise.race([
      primary.next().then(first => ({ source: 'primary', first, gen: primary })),
      hedgePromise.then(gen => gen.next().then(first => ({ source: 'hedge', first, gen }))),
    ])

    // Cancel the loser
    if (winner.source === 'primary') {
      hedgeController.abort()
    } else {
      primaryController.abort()
    }

    // Yield the first token already received
    if (!winner.first.done) yield winner.first.value

    // Stream the rest from the winner
    for await (const action of winner.gen) {
      yield action
    }
  }
}