import 'server-only'

import { appendFile, mkdir, rename, stat } from 'node:fs/promises'
import path from 'node:path'

const DEFAULT_FILE = 'logs/permit_ratecon_errors.jsonl'
const DEFAULT_MAX_BYTES = 20 * 1024 * 1024

type ExtractionKind = 'permit' | 'ratecon'
type FailureStage = 'gpt_api' | 'workspace_processing'

export interface ExtractionFailure {
  kind: ExtractionKind
  stage: FailureStage
  tripId?: string | null
  documentId?: string | null
  permitId?: string | null
  httpStatus?: number | null
  upstreamError?: string | null
  upstreamDetails?: string | null
  transportError?: string | null
  internalCode?: string | null
  requestId?: string | null
  durationMs?: number | null
}

let writeQueue: Promise<void> = Promise.resolve()

/** Classify untrusted GPT/provider text without storing the text itself. */
export function extractionFailureReason(failure: ExtractionFailure): string {
  if (failure.internalCode && /^[a-z_]{3,80}$/.test(failure.internalCode)) return failure.internalCode
  if (failure.transportError === 'ConfigMissing') return 'gpt_not_configured'
  if (failure.transportError === 'AbortError' || failure.transportError === 'TimeoutError') return 'gpt_timeout'
  if (failure.transportError === 'SyntaxError') return 'invalid_gpt_response'
  if (failure.httpStatus === 401 || failure.httpStatus === 403) return 'gpt_auth_denied'
  if (failure.httpStatus === 404) return 'gpt_endpoint_not_found'
  if (failure.httpStatus === 413) return 'file_too_large'
  if (failure.httpStatus === 429) return 'gpt_rate_limited'

  const detail = `${failure.upstreamError || ''} ${failure.upstreamDetails || ''}`.slice(0, 2048).toLowerCase()
  if (/groq/.test(detail)) {
    if (/api.key|unauthori[sz]ed|forbidden/.test(detail)) return 'groq_auth_error'
    if (/rate.limit|quota|429/.test(detail)) return 'groq_rate_limited'
    if (/connect|network|dns/.test(detail)) return 'groq_connection_error'
    return 'groq_extraction_error'
  }
  if (/gemini|google.*generat/.test(detail)) {
    if (/api.key|unauthori[sz]ed|forbidden/.test(detail)) return 'gemini_auth_error'
    if (/rate.limit|quota|429/.test(detail)) return 'gemini_rate_limited'
    if (/connect|network|dns/.test(detail)) return 'gemini_connection_error'
    return 'gemini_extraction_error'
  }
  if (/no.data|no.text|nothing.to.extract/.test(detail)) return 'no_extractable_data'
  if (/pdf|document|file/.test(detail) && /invalid|corrupt|read|parse/.test(detail)) return 'document_read_error'
  if (failure.transportError) return 'gpt_connection_error'
  if (failure.httpStatus && failure.httpStatus >= 500) return 'gpt_server_error'
  if (failure.httpStatus) return 'gpt_http_error'
  return 'extraction_failed'
}

function knownUpstreamError(value: string | null | undefined): string | null {
  switch (value) {
    case 'Permit extraction failed': return 'permit_extraction_failed'
    case 'Permit extraction produced no data': return 'permit_extraction_produced_no_data'
    case 'RateCon extraction failed': return 'ratecon_extraction_failed'
    case 'Unauthorized': return 'unauthorized'
    case 'Missing or invalid Authorization header': return 'invalid_authorization_header'
    case 'Server Misconfigured': return 'server_misconfigured'
    default: return null
  }
}

function logFile(): string {
  const configured = process.env.EXTRACTION_ERROR_LOG_FILE?.trim() || DEFAULT_FILE
  return path.isAbsolute(configured) ? configured : path.join(process.cwd(), configured)
}

function maxBytes(): number {
  const configured = Number(process.env.EXTRACTION_ERROR_LOG_MAX_BYTES)
  return Number.isFinite(configured) && configured > 0 ? configured : DEFAULT_MAX_BYTES
}

async function appendLine(line: string): Promise<void> {
  const file = logFile()
  await mkdir(path.dirname(file), { recursive: true, mode: 0o700 })
  try {
    const current = await stat(file)
    if (current.size + Buffer.byteLength(line) > maxBytes()) {
      const stamp = new Date().toISOString().replace(/[:.]/g, '-')
      await rename(file, `${file}.${stamp}`)
    }
  } catch (error) {
    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error
  }
  await appendFile(file, line, { encoding: 'utf8', mode: 0o600 })
}

/** Best effort: an unavailable log directory must never change extraction behavior. */
export async function logExtractionFailure(failure: ExtractionFailure): Promise<void> {
  const record = {
    timestamp: new Date().toISOString(),
    service: 'workspace',
    component: 'document_extraction',
    kind: failure.kind,
    stage: failure.stage,
    outcome: 'failed',
    trip_id: failure.tripId || null,
    document_id: failure.documentId || null,
    permit_id: failure.permitId || null,
    request_id: failure.requestId && /^[A-Za-z0-9._:-]{1,128}$/.test(failure.requestId) ? failure.requestId : null,
    http_status: failure.httpStatus ?? null,
    reason: extractionFailureReason(failure),
    upstream_error: knownUpstreamError(failure.upstreamError),
    duration_ms: failure.durationMs ?? null,
  }
  const line = `${JSON.stringify(record)}\n`
  console.error(line.trim())
  writeQueue = writeQueue.then(() => appendLine(line)).catch((error: unknown) => {
    console.error(JSON.stringify({
      timestamp: new Date().toISOString(),
      service: 'workspace',
      component: 'document_extraction',
      event: 'log_write_failed',
      error_type: error instanceof Error ? error.name : 'UnknownError',
    }))
  })
  await writeQueue
}
