/**
 * ULTRAPLINIAN API Route — The Flagship Endpoint
 *
 * POST /v1/ultraplinian/completions
 *
 * Queries N models in parallel with the GODMODE system prompt + Depth Directive,
 * scores all responses on substance/directness/completeness, and returns the winner
 * alongside full race metadata.
 *
 * LIQUID RESPONSE MODE (stream=true, default):
 * - Streams SSE events as models finish
 * - Serves the first good response immediately (race:leader event)
 * - Auto-upgrades when a new model beats the current leader by `liquid_min_delta`
 *   score points (default 8). Small improvements are suppressed to avoid flicker.
 * - Final polished result sent as race:complete
 *
 * Full pipeline per model:
 * 1. GODMODE system prompt + Depth Directive injected
 * 2. AutoTune computes context-adaptive parameters
 * 3. GODMODE parameter boost applied (+temp, +presence, +freq)
 * 4. Parseltongue obfuscates trigger words (if enabled)
 * 5. All models queried in parallel via OpenRouter
 * 6. Responses scored and ranked (threshold-gated leader upgrades)
 * 7. STM modules applied to winner response
 * 8. Winner + all race data returned
 */

import { Router } from 'express'
import { computeAutoTuneParams, type AutoTuneStrategy } from '../../src/lib/autotune'
import { applyParseltongue, type ParseltongueConfig } from '../../src/lib/parseltongue'
import { allModules, applySTMs, type STMModule } from '../../src/stm/modules'
import { getSharedProfiles } from './autotune'
import {
  GODMODE_SYSTEM_PROMPT,
  DEPTH_DIRECTIVE,
  getModelsForTier,
  raceModels,
  scoreResponse,
  applyGodmodeBoost,
  type SpeedTier,
  type ModelResult,
} from '../lib/ultraplinian'
import { addEntry } from '../lib/dataset'

export const ultraplinianRoutes = Router()

ultraplinianRoutes.post('/completions', async (req, res) => {
  const startTime = Date.now()

  try {
    const {
      messages,
      openrouter_api_key: caller_key,
      // ULTRAPLINIAN options
      tier = 'fast' as SpeedTier,
      godmode = true,
      custom_system_prompt,
      // AutoTune options
      autotune = true,
      strategy = 'adaptive',
      // Parseltongue options
      parseltongue = true,
      parseltongue_technique = 'leetspeak',
      parseltongue_intensity = 'medium',
      // STM options
      stm_modules = ['hedge_reducer', 'direct_mode'],
      // Param overrides
      temperature,
      max_tokens = 4096,
      top_p,
      top_k,
      frequency_penalty,
      presence_penalty,
      repetition_penalty,
      // Liquid Response (SSE streaming with live leader upgrades)
      stream = true,  // ON by default — serve first good response, upgrade live
      liquid_min_delta = 8, // Min score improvement to trigger a leader upgrade (1-50)
      // Dataset opt-in
      contribute_to_dataset = false,
    } = req.body

    // Validate
    if (!messages || !Array.isArray(messages) || messages.length === 0) {
      res.status(400).json({ error: 'messages (array) is required and must not be empty' })
      return
    }

    // Resolve OpenRouter key: caller-provided > server-side env var
    const openrouter_api_key = caller_key || process.env.OPENROUTER_API_KEY || ''
    if (!openrouter_api_key) {
      res.status(400).json({
        error: 'No OpenRouter API key available. Either pass openrouter_api_key in the request body, or set OPENROUTER_API_KEY on the server. Get a key at https://openrouter.ai/keys',
      })
      return
    }

    const validTiers: SpeedTier[] = ['fast', 'standard', 'full']
    if (!validTiers.includes(tier)) {
      res.status(400).json({
        error: `Invalid tier. Must be one of: ${validTiers.join(', ')}`,
      })
      return
    }

    // Clamp liquid_min_delta to valid range
    const minDelta = Math.max(1, Math.min(50, Number(liquid_min_delta) || 8))

    // ── Build messages with GODMODE prompt ────────────────────────────
    const normalizedMessages = messages.map((m: any) => ({
      role: m.role as 'system' | 'user' | 'assistant',
      content: String(m.content || ''),
    }))

    // Get the last user message
    const lastUserMsg = [...normalizedMessages].reverse().find(m => m.role === 'user')
    const userContent = lastUserMsg?.content || ''

    // Build the system prompt: GODMODE + Depth Directive (or custom)
    const systemPrompt = godmode
      ? (custom_system_prompt || GODMODE_SYSTEM_PROMPT) + DEPTH_DIRECTIVE
      : custom_system_prompt || ''

    // Build final message array for each model
    const baseMessages = [
      ...(systemPrompt ? [{ role: 'system' as const, content: systemPrompt }] : []),
      // Include conversation history (non-system messages from caller)
      ...normalizedMessages.filter(m => m.role !== 'system'),
    ]

    // ── AutoTune ─────────────────────────────────────────────────────
    const conversationHistory = normalizedMessages
      .filter(m => m.role !== 'system')
      .map(m => ({ role: m.role, content: m.content }))

    let autotuneResult = null
    let finalParams: Record<string, number | undefined> = {
      temperature: temperature ?? 0.7,
      top_p,
      top_k,
      frequency_penalty,
      presence_penalty,
      repetition_penalty,
    }

    if (autotune && temperature === undefined) {
      autotuneResult = computeAutoTuneParams({
        strategy: strategy as AutoTuneStrategy,
        message: userContent,
        conversationHistory,
        overrides: {
          ...(top_p !== undefined && { top_p }),
          ...(top_k !== undefined && { top_k }),
          ...(frequency_penalty !== undefined && { frequency_penalty }),
          ...(presence_penalty !== undefined && { presence_penalty }),
          ...(repetition_penalty !== undefined && { repetition_penalty }),
        },
        learnedProfiles: getSharedProfiles(),
      })

      finalParams = {
        temperature: autotuneResult.params.temperature,
        top_p: autotuneResult.params.top_p,
        top_k: autotuneResult.params.top_k,
        frequency_penalty: autotuneResult.params.frequency_penalty,
        presence_penalty: autotuneResult.params.presence_penalty,
        repetition_penalty: autotuneResult.params.repetition_penalty,
      }
    }

    // Apply GODMODE boost
    if (godmode) {
      finalParams = applyGodmodeBoost(finalParams)
    }

    // ── Parseltongue ─────────────────────────────────────────────────
    let parseltongueResult = null
    let processedMessages = baseMessages

    if (parseltongue) {
      const ptConfig: ParseltongueConfig = {
        enabled: true,
        technique: parseltongue_technique,
        intensity: parseltongue_intensity,
        customTriggers: [],
      }

      processedMessages = baseMessages.map(m => {
        if (m.role === 'user') {
          const result = applyParseltongue(m.content, ptConfig)
          if (!parseltongueResult && result.triggersFound.length > 0) {
            parseltongueResult = {
              triggers_found: result.triggersFound,
              technique_used: result.techniqueUsed,
              transformations_count: result.transformations.length,
            }
          }
          return { ...m, content: result.transformedText }
        }
        return m
      })
    }

    // ── Shared race setup ────────────────────────────────────────────
    const models = getModelsForTier(tier)
    const raceParams = {
      temperature: finalParams.temperature,
      max_tokens,
      top_p: finalParams.top_p,
      top_k: finalParams.top_k,
      frequency_penalty: finalParams.frequency_penalty,
      presence_penalty: finalParams.presence_penalty,
      repetition_penalty: finalParams.repetition_penalty,
    }

    // ══════════════════════════════════════════════════════════════════
    // STREAMING PATH: SSE "liquid response" mode
    // Serves the first good response immediately, then upgrades live
    // as better responses come in. Client sees text morph in real-time.
    // ══════════════════════════════════════════════════════════════════
    if (stream) {
      res.setHeader('Content-Type', 'text/event-stream')
      res.setHeader('Cache-Control', 'no-cache')
      res.setHeader('Connection', 'keep-alive')
      res.setHeader('X-Accel-Buffering', 'no') // disable nginx buffering
      res.flushHeaders()

      const sse = (event: string, data: unknown) => {
        res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`)
      }

      // Send race:start immediately
      sse('race:start', {
        tier,
        models_queried: models.length,
        liquid_min_delta: minDelta,
        params_used: finalParams,
        pipeline: {
          godmode,
          autotune: autotuneResult
            ? { detected_context: autotuneResult.detectedContext, confidence: autotuneResult.confidence, strategy }
            : null,
          parseltongue: parseltongueResult,
        },
      })

      let currentLeader: ModelResult | null = null
      let modelsResponded = 0

      const results = await raceModels(
        models,
        processedMessages,
        openrouter_api_key,
        raceParams,
        {
          minResults: Math.min(5, models.length),
          gracePeriod: 5000,
          hardTimeout: 45000,
          onResult: (result) => {
            modelsResponded++
            const scored: ModelResult = {
              ...result,
              score: result.success ? scoreResponse(result.content, userContent) : 0,
            }

            // Send progress tick for every model
            sse('race:model', {
              model: scored.model,
              score: scored.score,
              duration_ms: scored.duration_ms,
              success: scored.success,
              error: scored.error || undefined,
              content_length: scored.content?.length || 0,
              models_responded: modelsResponded,
              models_total: models.length,
            })

            // New leader? Only upgrade if score beats current by liquid_min_delta
            // First leader: any positive score qualifies
            // Subsequent leaders: must exceed current by at least minDelta points
            const currentScore = currentLeader?.score ?? 0
            const isFirstLeader = !currentLeader
            const beatsByThreshold = scored.score >= currentScore + minDelta

            if (scored.success && (isFirstLeader ? scored.score > 0 : beatsByThreshold)) {
              const prevScore = currentScore
              currentLeader = scored

              // Apply STM to the current leader's content
              let leaderContent = scored.content
              if (stm_modules && Array.isArray(stm_modules) && stm_modules.length > 0) {
                const enabledModules: STMModule[] = allModules.map(m => ({
                  ...m,
                  enabled: stm_modules.includes(m.id),
                }))
                leaderContent = applySTMs(scored.content, enabledModules)
              }

              sse('race:leader', {
                model: scored.model,
                score: scored.score,
                delta: isFirstLeader ? null : scored.score - prevScore,
                duration_ms: scored.duration_ms,
                content: leaderContent,
                upgrade_number: isFirstLeader ? 1 : undefined,
              })
            }
          },
        },
      )

      // ── Final scoring & complete event ─────────────────────────────
      const scoredResults: ModelResult[] = results.map(r => ({
        ...r,
        score: r.success ? scoreResponse(r.content, userContent) : 0,
      }))

      const respondedModels = new Set(results.map(r => r.model))
      for (const model of models) {
        if (!respondedModels.has(model)) {
          scoredResults.push({
            model, content: '', duration_ms: Date.now() - startTime,
            success: false, error: 'Race ended (early exit)', score: 0,
          })
        }
      }
      scoredResults.sort((a, b) => b.score - a.score)

      const winner = scoredResults.find(r => r.success)
      let finalResponse = winner?.content || ''
      let stmResult = null

      if (winner && stm_modules && Array.isArray(stm_modules) && stm_modules.length > 0) {
        const enabledModules: STMModule[] = allModules.map(m => ({
          ...m,
          enabled: stm_modules.includes(m.id),
        }))
        finalResponse = applySTMs(winner.content, enabledModules)
        stmResult = {
          modules_applied: stm_modules,
          original_length: winner.content.length,
          transformed_length: finalResponse.length,
        }
      }

      const totalDuration = Date.now() - startTime
      const successCount = scoredResults.filter(r => r.success).length

      // Dataset collection
      let datasetId: string | null = null
      if (contribute_to_dataset && winner) {
        datasetId = addEntry({
          endpoint: '/v1/ultraplinian/completions',
          model: winner.model, mode: 'ultraplinian',
          messages: normalizedMessages.filter(m => m.role !== 'system'),
          response: finalResponse,
          autotune: autotuneResult ? { strategy, detected_context: autotuneResult.detectedContext, confidence: autotuneResult.confidence, params: autotuneResult.params, reasoning: autotuneResult.reasoning } : undefined,
          parseltongue: parseltongueResult || undefined,
          stm: stmResult ? { modules_applied: stmResult.modules_applied } : undefined,
          ultraplinian: { tier, models_queried: models, winner_model: winner.model, all_scores: scoredResults.map(r => ({ model: r.model, score: r.score, duration_ms: r.duration_ms, success: r.success })), total_duration_ms: totalDuration },
        })
      }

      // Send the final complete event with full metadata
      sse('race:complete', {
        response: finalResponse,
        winner: winner ? { model: winner.model, score: winner.score, duration_ms: winner.duration_ms } : null,
        race: {
          tier,
          liquid_min_delta: minDelta,
          models_queried: models.length,
          models_succeeded: successCount,
          total_duration_ms: totalDuration,
          rankings: scoredResults.map(r => ({
            model: r.model, score: r.score, duration_ms: r.duration_ms,
            success: r.success, error: r.error || undefined,
            content_length: r.content?.length || 0,
          })),
        },
        params_used: finalParams,
        pipeline: {
          godmode,
          autotune: autotuneResult ? { detected_context: autotuneResult.detectedContext, confidence: autotuneResult.confidence, reasoning: autotuneResult.reasoning, strategy } : null,
          parseltongue: parseltongueResult,
          stm: stmResult,
        },
        dataset: contribute_to_dataset ? { contributed: true, entry_id: datasetId } : { contributed: false },
      })

      res.end()
      return
    }

    // ══════════════════════════════════════════════════════════════════
    // NON-STREAMING PATH: Original behavior (wait for race, return JSON)
    // ══════════════════════════════════════════════════════════════════
    const results = await raceModels(
      models,
      processedMessages,
      openrouter_api_key,
      raceParams,
      {
        minResults: Math.min(5, models.length),
        gracePeriod: 5000,
        hardTimeout: 45000,
      },
    )

    // ── Score and rank ───────────────────────────────────────────────
    const scoredResults: ModelResult[] = results.map(r => ({
      ...r,
      score: r.success ? scoreResponse(r.content, userContent) : 0,
    }))

    const respondedModels = new Set(results.map(r => r.model))
    for (const model of models) {
      if (!respondedModels.has(model)) {
        scoredResults.push({
          model, content: '', duration_ms: Date.now() - startTime,
          success: false, error: 'Race ended (early exit)', score: 0,
        })
      }
    }

    scoredResults.sort((a, b) => b.score - a.score)

    const successCount = scoredResults.filter(r => r.success).length
    const winner = scoredResults.find(r => r.success)

    if (!winner || !winner.content) {
      res.status(502).json({
        error: 'All models failed in ULTRAPLINIAN mode',
        models_queried: models.length,
        results: scoredResults.map(r => ({
          model: r.model, success: r.success,
          error: r.error, duration_ms: r.duration_ms,
        })),
      })
      return
    }

    // ── STM transforms on winner ─────────────────────────────────────
    let stmResult = null
    let finalResponse = winner.content

    if (stm_modules && Array.isArray(stm_modules) && stm_modules.length > 0) {
      const enabledModules: STMModule[] = allModules.map(m => ({
        ...m,
        enabled: stm_modules.includes(m.id),
      }))
      finalResponse = applySTMs(winner.content, enabledModules)
      stmResult = {
        modules_applied: stm_modules,
        original_length: winner.content.length,
        transformed_length: finalResponse.length,
      }
    }

    const totalDuration = Date.now() - startTime

    // ── Dataset collection (opt-in) ──────────────────────────────────
    let datasetId: string | null = null
    if (contribute_to_dataset) {
      datasetId = addEntry({
        endpoint: '/v1/ultraplinian/completions',
        model: winner.model, mode: 'ultraplinian',
        messages: normalizedMessages.filter(m => m.role !== 'system'),
        response: finalResponse,
        autotune: autotuneResult ? { strategy, detected_context: autotuneResult.detectedContext, confidence: autotuneResult.confidence, params: autotuneResult.params, reasoning: autotuneResult.reasoning } : undefined,
        parseltongue: parseltongueResult || undefined,
        stm: stmResult ? { modules_applied: stmResult.modules_applied } : undefined,
        ultraplinian: { tier, models_queried: models, winner_model: winner.model, all_scores: scoredResults.map(r => ({ model: r.model, score: r.score, duration_ms: r.duration_ms, success: r.success })), total_duration_ms: totalDuration },
      })
    }

    // ── Build response ───────────────────────────────────────────────
    res.json({
      response: finalResponse,
      winner: { model: winner.model, score: winner.score, duration_ms: winner.duration_ms },
      race: {
        tier, liquid_min_delta: minDelta,
        models_queried: models.length, models_succeeded: successCount,
        total_duration_ms: totalDuration,
        rankings: scoredResults.map(r => ({
          model: r.model, score: r.score, duration_ms: r.duration_ms,
          success: r.success, error: r.error || undefined, content_length: r.content?.length || 0,
        })),
      },
      params_used: finalParams,
      pipeline: {
        godmode,
        autotune: autotuneResult ? { detected_context: autotuneResult.detectedContext, confidence: autotuneResult.confidence, reasoning: autotuneResult.reasoning, strategy } : null,
        parseltongue: parseltongueResult,
        stm: stmResult,
      },
      dataset: contribute_to_dataset ? { contributed: true, entry_id: datasetId } : { contributed: false },
    })
  } catch (err: any) {
    if (stream) {
      try {
        res.write(`event: race:error\ndata: ${JSON.stringify({ error: err.message })}\n\n`)
        res.end()
      } catch {}
    } else {
      res.status(500).json({ error: err.message })
    }
  }
})