/**
 * Interne CRUD-API für Trigger-Templates (vom Builder/Settings-UI genutzt).
 *
 *   GET  /api/trigger-templates           — listet alle Templates
 *   POST /api/trigger-templates           — schaltet ein Template aus einem Draft frei
 *
 * Diese Routes haben (noch) keine User-Auth — Mailforge ist intern. Wird über das
 * Reverse-Proxy / VPN abgesichert. Die öffentliche /api/trigger/{key}-Route hat
 * dagegen pro-Template Bearer-Token-Auth.
 */

import { NextRequest, NextResponse } from 'next/server';
import { z } from 'zod';
import {
  createTriggerTemplate,
  extractVariablesFromMjml,
  listTriggerTemplates,
} from '@/lib/db/trigger-template-repo';
import { withAuth } from '@/core/auth';

export const runtime = 'nodejs';
export const dynamic = 'force-dynamic';

const VariableSchema = z.object({
  key: z.string().min(1),
  required: z.boolean().default(true),
  defaultValue: z.string().optional(),
});

const CreateSchema = z.object({
  key: z.string().regex(/^[a-z0-9_-]{2,64}$/, 'Key: nur a-z, 0-9, _ und - (2-64 Zeichen)'),
  name: z.string().min(1).max(120),
  description: z.string().max(500).optional(),
  workspaceId: z.string().min(1),
  subject: z.string().min(1),
  preheader: z.string().default(''),
  mjml: z.string().min(20),
  html: z.string().min(50),
  htmlText: z.string().default(''),
  senderEmail: z.string().email().optional(),
  utmDefaults: z.record(z.string(), z.unknown()).optional(),
  rateLimitPerHour: z.number().int().min(1).max(100_000).optional(),
  /** Optional: Override des Auto-Schemas. Wenn nicht gesetzt → wird aus MJML extrahiert. */
  variableSchema: z.array(VariableSchema).optional(),
});

export function GET() {
  const templates = listTriggerTemplates().map(t => ({
    id: t.id,
    key: t.key,
    name: t.name,
    description: t.description,
    workspaceId: t.workspaceId,
    subject: t.subject,
    preheader: t.preheader,
    senderEmail: t.senderEmail,
    apiKeyPrefix: t.apiKeyPrefix,
    isActive: t.isActive,
    rateLimitPerHour: t.rateLimitPerHour,
    triggerCount: t.triggerCount,
    lastTriggeredAt: t.lastTriggeredAt,
    variableSchema: t.variableSchemaJson,
    createdAt: t.createdAt,
    updatedAt: t.updatedAt,
  }));
  return NextResponse.json({ templates });
}

export const POST = withAuth(async (req: NextRequest, _ctx) => {
  try {
    const raw = await req.json();
    const parsed = CreateSchema.safeParse(raw);
    if (!parsed.success) {
      return NextResponse.json({
        error: 'Validation failed',
        issues: parsed.error.issues.map(i => `${i.path.join('.')}: ${i.message}`),
      }, { status: 400 });
    }

    const result = createTriggerTemplate(parsed.data);

    // Vorschau der extrahierten Variablen — für UI-Hinweis "diese Tags werden erwartet"
    const extracted = extractVariablesFromMjml(parsed.data.mjml, parsed.data.subject, parsed.data.preheader);

    return NextResponse.json({
      ok: true,
      template: {
        id: result.template.id,
        key: result.template.key,
        name: result.template.name,
        apiKeyPrefix: result.template.apiKeyPrefix,
        variableSchema: result.template.variableSchemaJson,
      },
      // !!! Klartext-API-Key wird NUR JETZT zurückgegeben — UI muss ihn dem User
      // einmalig zeigen mit Hinweis "wird nicht erneut abrufbar sein".
      apiKey: result.apiKey,
      extractedVariables: extracted,
    });
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    console.error('[/api/trigger-templates POST] error:', err);
    // Eindeutige Konflikt-Fehler (Key bereits vergeben) als 409 zurückgeben
    if (msg.includes('bereits vergeben')) {
      return NextResponse.json({ error: msg }, { status: 409 });
    }
    return NextResponse.json({ error: msg }, { status: 500 });
  }
});
