// Server-only module
import { env } from '$env/dynamic/private';

type ChatMessage = { role: 'system' | 'user' | 'assistant'; content: string };

export async function chatCompletion(messages: ChatMessage[], opts?: {
  max_tokens?: number;
  temperature?: number;
  response_format?: any; // si tu veux du JSON mode "structured output" plus tard
}) {
  const res = await fetch(`${env.OPENROUTER_BASE_URL}/chat/completions`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${env.OPENROUTER_API_KEY}`,
      'Content-Type': 'application/json',
      'HTTP-Referer': env.APP_URL ?? 'http://localhost:5173',
      'X-Title': env.APP_NAME ?? 'Pebbles'
    },
    body: JSON.stringify({
      model: env.OPENROUTER_MODEL,
      messages,
      temperature: opts?.temperature ?? 0.3,
      max_tokens: opts?.max_tokens ?? 600
    })
  });

  if (!res.ok) {
    const err = await res.text();
    throw new Error(`OpenRouter error ${res.status}: ${err}`);
  }

  const data = await res.json();
  return data.choices?.[0]?.message?.content ?? '';
}

import { json } from '@sveltejs/kit';
import type { RequestHandler } from './$types';
import { createClient } from '@supabase/supabase-js';
import { chatCompletion } from '$lib/server/openrouter';
import { env } from '$env/dynamic/private';

export const POST: RequestHandler = async ({ params, locals }) => {
  const event_id = params.event_id;

  const supabase = createClient(env.PUBLIC_SUPABASE_URL!, env.SUPABASE_SERVICE_ROLE_KEY!);
  // service_role côté serveur uniquement

  // 1) Récupérer event + responses (situation, émotions, pensées, etc.)
  const { data: event, error: e1 } = await supabase
    .from('events')
    .select('*')
    .eq('id', event_id)
    .single();
  if (e1 || !event) return new Response('Event not found', { status: 404 });

  const { data: responses } = await supabase
    .from('responses')
    .select('question_id, value')
    .eq('event_id', event_id);

  // (optionnel) récupérer les émotions mappées
  const { data: emotions } = await supabase
    .from('emotion_mapping')
    .select('emotion_id, valence, emotions(name)')
    .eq('event_id', event_id)
    .returns<any[]>();

  // 2) Construire le prompt
  const userBlock = [
    `Event: ${event.name ?? '(sans titre)'} — ${event.occurrence_date}`,
    `Valence: ${event.valence ?? 'n/a'}`,
    `Responses:`,
    ...(responses ?? []).map((r) => `- ${r.question_id}: ${r.value}`),
    emotions?.length
      ? `Emotions:\n${emotions.map((m) => `- ${m.emotions?.name}: ${m.valence}`).join('\n')}`
      : ''
  ].join('\n');

  const system = `You are Pebbles' cognitive journaling summarizer.
Create a concise, neutral, psychologically-informed summary of the user's entry.
Output in French, markdown, <= 120 words, with 3 bullet highlights and 1 actionable reframe.
Avoid clinical jargon.`;

  // 3) Appel OpenRouter
  const summary = await chatCompletion([
    { role: 'system', content: system },
    { role: 'user', content: userBlock }
  ]);

  // 4) Sauvegarder le résumé (table à créer ci-dessous)
  const { error: e2 } = await supabase
    .from('summaries')
    .insert({ event_id, summary_text: summary });

  if (e2) return new Response(`Save error: ${e2.message}`, { status: 500 });

  return json({ summary });
};

const { data: bundle } = await supabase.rpc('get_event_bundle', { p_event_id: event_id });

// deno-lint-ignore-file no-explicit-any
import 'jsr:@supabase/functions-js/edge-runtime.d.ts';

Deno.serve(async (req) => {
  const { event_id, bundle } = await req.json();

  // build prompt à partir de bundle (ou fetch depuis DB avec service role si besoin)
  const messages = [
    { role: 'system', content: 'You are Pebbles summarizer in French...' },
    { role: 'user', content: JSON.stringify(bundle) }
  ];

  const res = await fetch('https://openrouter.ai/api/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${Deno.env.get('OPENROUTER_API_KEY')}`,
      'Content-Type': 'application/json',
      'HTTP-Referer': Deno.env.get('APP_URL')!,
      'X-Title': Deno.env.get('APP_NAME')!
    },
    body: JSON.stringify({
      model: 'mistralai/mistral-small-3.2-24b-instruct:free',
      messages,
      temperature: 0.3,
      max_tokens: 600
    })
  });

  if (!res.ok) return new Response(await res.text(), { status: res.status });

  const data = await res.json();
  const summary = data.choices?.[0]?.message?.content ?? '';

  // (option) écrire dans public.summaries ici…

  return new Response(JSON.stringify({ summary }), { headers: { 'Content-Type': 'application/json' }});
});

const system = `Return strict JSON: {"summary": "...","insights":["...","...","..."],"reframe":"..."}`;