/**
 * {{APP_NAME}} — server component for the AI template.
 *
 * Thin proxy over Kazzle's AI gateway. Demonstrates the full modality
 * surface customers can build on top of one `kzl_…` API key:
 *
 *   POST /chat        →  /ai/chat/completions     (OpenAI-shape, including structured output)
 *   POST /image       →  /ai/images/generations   (standardized)
 *   POST /speech      →  /ai/audio/speech         (binary audio)
 *   POST /transcribe  →  /ai/audio/transcriptions (multipart in)
 *   POST /video       →  /ai/video/generations    (async job)
 *   GET  /video/:id   →  /ai/responses/:id        (poll)
 *   GET  /health      →  local server/proxy health    (no upstream call)
 *
 * The browser only ever talks to this server, never to Kazzle directly —
 * that's how the `kzl_…` key stays server-side and how customers add
 * their own auth/rate-limits/business rules around AI usage.
 *
 * Env:
 *   - `KAZZLE_API_KEY`              required.
 *   - `KAZZLE_API_URL`              required API root, for example `https://api.kazzle.app`.
 *   - `KAZZLE_AI_MODEL`             default `openai/gpt-5.5`.
 *   - `KAZZLE_IMAGE_MODEL`          default `google/gemini-2.5-flash-image`.
 *   - `KAZZLE_SPEECH_MODEL`         default `openai/gpt-audio`.
 *   - `KAZZLE_TRANSCRIPTION_MODEL`  default `google/gemini-3.5-flash`.
 *   - `KAZZLE_VIDEO_MODEL`          default `bytedance/seedance-2.0-mini`.
 *
 * Override any model via the request body (`{ model: '…' }`); the env
 * default is just a sensible fallback.
 */

import { serve } from '@hono/node-server';
import { Hono } from 'hono';
import type { Context } from 'hono';
import { cors } from 'hono/cors';

const apiKey = process.env.KAZZLE_API_KEY;
if (!apiKey) throw new Error('KAZZLE_API_KEY is required (mint with `api_key { create: {} }`)');
const apiUrl = process.env.KAZZLE_API_URL;
if (!apiUrl) throw new Error('KAZZLE_API_URL is required and must point at the matching Kazzle API environment');

const baseUrl = `${apiUrl.replace(/\/$/, '')}/ai`;
const defaults = {
  chat: process.env.KAZZLE_AI_MODEL || 'openai/gpt-5.5',
  image: process.env.KAZZLE_IMAGE_MODEL || 'google/gemini-2.5-flash-image',
  speech: process.env.KAZZLE_SPEECH_MODEL || 'openai/gpt-audio',
  transcription: process.env.KAZZLE_TRANSCRIPTION_MODEL || 'google/gemini-3.5-flash',
  video: process.env.KAZZLE_VIDEO_MODEL || 'bytedance/seedance-2.0-mini',
};

type ChatMessage = { role: 'system' | 'user' | 'assistant'; content: string };
type ChatCompletionPayload = { choices?: Array<{ message?: ChatMessage }>; model?: string };
type JsonSchemaResponseFormat = { type: 'json_schema'; json_schema?: unknown };
type ChatResponseBody = { message: ChatMessage; model: string; structured?: unknown };
const authHeader = `Bearer ${apiKey}`;

const app = new Hono();
app.use('*', cors());

app.get('/health', c => c.json({ ok: true, defaults }));

// ── Chat ─────────────────────────────────────────────────────────────
app.post('/chat', async c => {
  const body = await readJsonBody(c);
  if (!body) return c.json({ error: 'Invalid JSON body' }, 400);
  const messages = Array.isArray(body.messages) ? body.messages : null;
  if (!messages || messages.length === 0) {
    return c.json({ error: '`messages` must be a non-empty array' }, 400);
  }
  for (const m of messages as Partial<ChatMessage>[]) {
    if (m.role !== 'system' && m.role !== 'user' && m.role !== 'assistant') {
      return c.json({ error: 'Each message needs role of system|user|assistant' }, 400);
    }
    if (typeof m.content !== 'string') {
      return c.json({ error: 'Each message needs string content' }, 400);
    }
  }
  const { model, stream, messages: _m, ...rest } = body;
  const upstream = await fetch(`${baseUrl}/chat/completions`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', Authorization: authHeader },
    body: JSON.stringify({ model: model || defaults.chat, messages, ...rest, stream: false }),
  });
  if (!upstream.ok) return c.json({ error: `Upstream ${upstream.status}: ${await upstream.text()}` }, 502);
  const data = await upstream.json() as ChatCompletionPayload;
  const assistant = data.choices?.[0]?.message;
  if (!assistant?.content) return c.json({ error: 'Upstream returned no assistant message' }, 502);
  const response: ChatResponseBody = {
    message: assistant,
    model: data.model ?? (typeof model === 'string' ? model : defaults.chat),
  };
  if (isJsonSchemaResponseFormat(body.response_format)) {
    const parsed = parseStructuredContent(assistant.content);
    if (!parsed.ok) return c.json({ error: parsed.error }, 502);
    response.structured = parsed.value;
  }
  return c.json(response);
});

// ── Image ────────────────────────────────────────────────────────────
// Standardized output: `{ images: [{ url? b64? mimeType }] }`. The proxy
// hands us this shape regardless of provider so the UI can render either
// a data URL (from b64) or a remote URL without provider branching.
app.post('/image', async c => {
  const body = await readJsonBody(c);
  if (!body || typeof body.prompt !== 'string' || !body.prompt.trim()) {
    return c.json({ error: '`prompt` is required' }, 400);
  }
  const { model, prompt, ...rest } = body;
  const upstream = await fetch(`${baseUrl}/images/generations`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', Authorization: authHeader },
    body: JSON.stringify({ model: model || defaults.image, prompt, ...rest }),
  });
  return passthroughJson(upstream);
});

// ── Speech (TTS, binary) ─────────────────────────────────────────────
// Returns raw audio bytes. The Content-Type tells the browser/client
// which decoder to use; the UI just hands it to <audio>.
app.post('/speech', async c => {
  const body = await readJsonBody(c);
  if (!body || typeof body.text !== 'string' || !body.text.trim()) {
    return c.json({ error: '`text` is required' }, 400);
  }
  const { model, voice, format, ...rest } = body;
  const upstream = await fetch(`${baseUrl}/audio/speech`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', Authorization: authHeader },
    body: JSON.stringify({
      model: model || defaults.speech,
      voice: voice || 'alloy',
      format: format || 'mp3',
      ...rest,
      text: body.text,
    }),
  });
  if (!upstream.ok) return c.json({ error: `Upstream ${upstream.status}: ${await upstream.text()}` }, 502);
  const bytes = new Uint8Array(await upstream.arrayBuffer());
  return new Response(bytes, {
    status: 200,
    headers: { 'content-type': upstream.headers.get('content-type') || 'audio/mpeg' },
  });
});

// ── Transcription (multipart in, JSON out) ──────────────────────────
// Accepts `multipart/form-data` with `file` (audio bytes) and optional
// `model`, `language`, `prompt`. Forwards as multipart to Kazzle.
app.post('/transcribe', async c => {
  const form = await c.req.parseBody();
  const file = form.file as Blob | undefined;
  if (!file || typeof (file as Blob).arrayBuffer !== 'function') {
    return c.json({ error: '`file` is required (multipart/form-data)' }, 400);
  }
  const upstreamForm = new FormData();
  upstreamForm.append('model', String(form.model || defaults.transcription));
  if (typeof form.language === 'string') upstreamForm.append('language', form.language);
  if (typeof form.prompt === 'string') upstreamForm.append('prompt', form.prompt);
  // Re-wrap as a Blob so undici/Bun's FormData sets a clean file part —
  // forwarding the parsed Blob directly preserves whatever Hono parsed.
  const audio = new Blob([new Uint8Array(await file.arrayBuffer())], { type: file.type || 'audio/mpeg' });
  upstreamForm.append('file', audio, (file as Blob & { name?: string }).name || 'audio.bin');
  const upstream = await fetch(`${baseUrl}/audio/transcriptions`, {
    method: 'POST',
    headers: { Authorization: authHeader },
    body: upstreamForm,
  });
  return passthroughJson(upstream);
});

// ── Video (async) ────────────────────────────────────────────────────
// Returns `{ jobId, status, pollUrl }`. The UI submits a prompt, gets a
// job id, and polls `/video/:id` until status is `succeeded` (then
// reads `output.videoUrl`) or `failed`.
app.post('/video', async c => {
  const body = await readJsonBody(c);
  if (!body || typeof body.prompt !== 'string' || !body.prompt.trim()) {
    return c.json({ error: '`prompt` is required' }, 400);
  }
  const { model, prompt, ...rest } = body;
  const upstream = await fetch(`${baseUrl}/video/generations`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', Authorization: authHeader },
    body: JSON.stringify({ model: model || defaults.video, prompt, ...rest }),
  });
  return passthroughJson(upstream);
});

app.get('/video/:id', async c => {
  const id = c.req.param('id');
  const upstream = await fetch(`${baseUrl}/responses/${encodeURIComponent(id)}`, {
    headers: { Authorization: authHeader },
  });
  return passthroughJson(upstream);
});

// ── helpers ──────────────────────────────────────────────────────────

async function readJsonBody(c: Context): Promise<Record<string, unknown> | null> {
  try { return await c.req.json<Record<string, unknown>>(); } catch { return null; }
}

function isJsonSchemaResponseFormat(value: unknown): value is JsonSchemaResponseFormat {
  return typeof value === 'object'
    && value !== null
    && 'type' in value
    && value.type === 'json_schema';
}

function parseStructuredContent(content: string): { ok: true; value: unknown } | { ok: false; error: string } {
  try {
    return { ok: true, value: JSON.parse(content) as unknown };
  } catch {
    return { ok: false, error: 'Upstream returned invalid structured JSON' };
  }
}

async function passthroughJson(upstream: Response): Promise<Response> {
  // We don't trust the upstream's content-encoding/length when we
  // re-emit. The Kazzle proxy may pass through Cloudflare's framing
  // headers; reading the body as text strips that.
  const text = await upstream.text();
  return new Response(text, {
    status: upstream.status,
    headers: { 'content-type': 'application/json' },
  });
}

// ─────────────────────────────────────────────────────────────────────────
//  DO NOT CHANGE THE NEXT 4 LINES.  DO NOT ADD FALLBACKS.  DO NOT HARDCODE.
//  PORT and HOST are injected by `kazzle run`. Missing values must throw.
// ─────────────────────────────────────────────────────────────────────────
if (!process.env.PORT || !process.env.HOST) {
  throw new Error('PORT and HOST must be set by "kazzle run" — never hardcode them.');
}
const port = Number(process.env.PORT);
const hostname = process.env.HOST;
serve({ fetch: app.fetch, port, hostname });