import { NextRequest, NextResponse } from 'next/server';
import { z } from 'zod';
import OpenAI from 'openai';
import { jsonrepair } from 'jsonrepair';
import { getOpenRouterKey, getOpenRouterKeyOptional } from "@/core/settings";
import { withAuth } from '@/core/auth';

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

const RequestSchema = z.object({
  workspaceSlug: z.string().min(1),
  recipientCount: z.number().int().nonnegative(),
  audienceSource: z.enum(['business', 'orders', 'evb', 'csv']).default('business'),
  offer: z.string().optional(),
});

const SYSTEM_PROMPT = `Du bist ein Senior Email-Marketing-Strategist mit Fokus auf Versandzeit-Optimierung
für deutsche Märkte (DACH-Region, Europe/Berlin Zeitzone).

Deine Aufgabe: Aus dem gegebenen Kampagnen-Kontext die optimalen Versandzeiten ableiten,
um die Open-Rate zu maximieren.

DOMAIN-WISSEN (aus Studien GetResponse 2024, Mailchimp 2023, HubSpot 2024):

# B2B-Empfänger (Versicherungs-Vermittler, Geschäftspartner, KMU)
- Beste Tage: Dienstag, Mittwoch, Donnerstag (Mo zu volle Inbox, Fr Wochenend-Hangover)
- Beste Zeit: 09:00-11:00 (vor dem Mittagessen, Inbox ist gerade gecheckt)
- Sekundäres Fenster: 14:00-15:30 (nach Mittagessen, vor Energie-Tief)
- VERMEIDEN: Montag morgens (Inbox-Flut), Freitag nachmittags, Wochenenden

# B2C-Empfänger (Privatkunden, KZK-Versicherungen, Spartarif)
- Beste Tage: Dienstag-Donnerstag (Werktage), Sonntag abends (Wochen-Vorbereitung)
- Beste Zeit: 18:00-21:00 (Feierabend-Browsing), Sonntag 16:00-19:00
- Mobile-First: 70%+ öffnen auf Smartphone abends
- VERMEIDEN: Geschäftszeiten 9-17h (Privatkunden in der Arbeit)

# Segment-Modifier
- 'bestand' (Bestandskunden): regulärer Slot, hohe Engagement-Rate
- 'neu' (Neukunden): erste 2 Wochen prime time — Mo-Fr 10:00 ist OK
- 'lead' (Akquise): scharfe B2B-Slots wichtig (Di-Mi 9-10:30)
- 'inaktiv': Reaktivierung am Sonntagabend (B2C) oder Mittwoch 10 Uhr (B2B)

# Goal-Modifier
- 'conversion': zeitkritisch, Decision-Making-Zeit (Di/Mi morgens)
- 'information': flexibler, kann auch Do/Fr morgens
- 'onboarding': früh in der Woche damit Empfänger nachfragen kann
- 'reaktivierung': wichtig dass Empfänger Zeit zum Antworten hat (Mo-Mi)

# Audience-Source-Hint
- 'business' = B2B Vermittler-Daten (KFZ-Versicherer, Händler) → B2B-Slots
- 'orders' = B2C Spartarif-Käufer (Privatkunden) → B2C-Slots
- 'evb' = Versicherungsmandate (mixed, eher B2B) → B2B-Slots
- 'csv' = unbekannte Liste → konservativ B2B-Slots

# Recipient-Count-Modifier
- < 100: präzise Slot-Wahl macht den Unterschied
- 100-1000: bewährte B2B/B2C-Defaults
- > 1000: throttling-bewusst — frühe Slots empfehlen damit Versand bis Mittag fertig

OUTPUT:
- 1-3 beste Wochentage (englisch ODER deutsch konsistent)
- Ein konkretes Zeitfenster im Format 'HH:MM-HH:MM'
- Timezone immer 'Europe/Berlin'
- Reasoning: 1-2 Sätze die deutlich machen WARUM (B2B/B2C, Segment, Goal kombiniert)`;

const TOOL_DEFINITION = {
  type: 'function' as const,
  function: {
    name: 'suggest_send_time',
    description: 'Empfiehlt optimale Versandzeiten für eine Marketing-Email-Kampagne',
    parameters: {
      type: 'object',
      required: ['bestDays', 'bestTimeWindow', 'timezone', 'reasoning'],
      properties: {
        bestDays: {
          type: 'array',
          items: { type: 'string' },
          minItems: 1,
          maxItems: 3,
          description: 'Beste Wochentage als deutsche Namen (Montag, Dienstag, ..., Sonntag)',
        },
        bestTimeWindow: {
          type: 'string',
          description: 'Zeitfenster im Format HH:MM-HH:MM, z.B. "09:00-11:00"',
          pattern: '^[0-9]{2}:[0-9]{2}-[0-9]{2}:[0-9]{2}$',
        },
        timezone: {
          type: 'string',
          description: 'IANA-Zeitzone, immer "Europe/Berlin" für DACH',
        },
        reasoning: {
          type: 'string',
          description: '1-2 Sätze Begründung (z.B. "B2B-Empfänger lesen ihre Mails vor Mittag — Di+Mi sind die produktivsten Tage. Conversion-Goal profitiert vom 9:00-Slot.")',
        },
      },
    },
  },
};

const MODEL = 'anthropic/claude-sonnet-4.6';
const MAX_TOKENS = 800;

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

    const userBrief = [
      `# Kampagnen-Kontext`,
      `Workspace: ${parsed.data.workspaceSlug} ${parsed.data.workspaceSlug === 'spartarif' ? '(B2C — Privatkunden)' : '(B2B-tendiert)'}`,
      `Audience-Source: ${parsed.data.audienceSource}`,
      `Empfänger-Anzahl: ${parsed.data.recipientCount.toLocaleString('de-DE')}`,
      parsed.data.offer ? `Angebot: ${parsed.data.offer.slice(0, 200)}` : '',
      ``,
      `Aufgabe: Empfehle die optimalen Versandzeiten für diese Kampagne.`,
    ].filter(Boolean).join('\n');

    const client = new OpenAI({
      baseURL: 'https://openrouter.ai/api/v1',
      apiKey: getOpenRouterKey(),
      defaultHeaders: {
        'HTTP-Referer': process.env.OPENROUTER_APP_URL ?? 'http://localhost:3000',
        'X-Title': process.env.OPENROUTER_APP_TITLE ?? 'MailForge',
      },
    });

    const start = Date.now();
    const completion = await client.chat.completions.create({
      model: process.env.OPENROUTER_MODEL ?? MODEL,
      max_tokens: MAX_TOKENS,
      messages: [
        { role: 'system', content: SYSTEM_PROMPT },
        { role: 'user', content: userBrief },
      ],
      tools: [TOOL_DEFINITION],
      tool_choice: { type: 'function', function: { name: 'suggest_send_time' } },
    });

    const choice = completion.choices[0];
    const toolCall = choice?.message?.tool_calls?.[0];
    if (!toolCall || toolCall.type !== 'function') {
      return NextResponse.json({
        error: `Modell hat suggest_send_time nicht aufgerufen (finish_reason=${choice?.finish_reason})`,
      }, { status: 502 });
    }

    let args: Record<string, unknown>;
    try {
      args = JSON.parse(toolCall.function.arguments) as Record<string, unknown>;
    } catch {
      args = JSON.parse(jsonrepair(toolCall.function.arguments)) as Record<string, unknown>;
    }

    return NextResponse.json({
      ok: true,
      ...args,
      meta: { durationMs: Date.now() - start, model: completion.model },
    });
  } catch (err) {
    console.error('[/api/scheduler/suggest] error:', err);
    return NextResponse.json(
      { error: err instanceof Error ? err.message : 'Internal error' },
      { status: 500 },
    );
  }
});
