import { NextRequest, NextResponse } from 'next/server';
import { getSupabaseAdmin } from '@/lib/supabase';
import { Supplier, AnalysisLine } from '@/types';
import { SUPPLIERS, getMonthLabel } from '@/config/suppliers';

// Contact first names per supplier
const SUPPLIER_CONTACTS: Record<string, string> = {
  signia: 'Adrien',
  resound: 'Kuangdi',
  starkey: '',
};

export async function POST(req: NextRequest) {
  try {
    const { analysis_id } = await req.json();

    if (!analysis_id) {
      return NextResponse.json({ error: 'analysis_id requis' }, { status: 400 });
    }

    const supabase = getSupabaseAdmin();

    const { data: analysis } = await supabase
      .from('analyses')
      .select('*')
      .eq('id', analysis_id)
      .single();

    if (!analysis) {
      return NextResponse.json({ error: 'Analyse non trouvée' }, { status: 404 });
    }

    // Fetch lines with discrepancies (discrepancy is GENERATED column)
    const { data: lines } = await supabase
      .from('analysis_lines')
      .select('*')
      .eq('analysis_id', analysis_id)
      .gt('discrepancy', 0)
      .order('discrepancy', { ascending: false });

    if (!lines?.length) {
      return NextResponse.json({ error: 'Aucun écart à signaler' }, { status: 400 });
    }

    const supplier = analysis.supplier as Supplier;
    const config = SUPPLIERS[supplier];
    const monthLabel = getMonthLabel(analysis.month);
    const year = analysis.month.split('-')[0];
    const contactName = SUPPLIER_CONTACTS[supplier] || '';
    const greeting = contactName ? `Bonjour ${contactName}` : 'Bonjour';

    // Group discrepancies by product
    const productGroups = new Map<string, {
      product: string;
      invoiced_price: number;
      negotiated_price: number;
      unit_diff: number;
      count: number;
    }>();

    for (const line of lines as AnalysisLine[]) {
      const productName = line.matched_product || line.description || line.code_article || 'Produit inconnu';
      const existing = productGroups.get(productName);
      if (existing) {
        existing.count++;
      } else {
        productGroups.set(productName, {
          product: productName,
          invoiced_price: Number(line.invoiced_price),
          negotiated_price: Number(line.negotiated_price),
          unit_diff: Number(line.discrepancy),
          count: 1,
        });
      }
    }

    const totalOvercharged = Math.round(Number(analysis.total_overcharged) * 100) / 100;
    const totalDiscrepancies = lines.length;

    // Build product listing
    const productListing = Array.from(productGroups.values())
      .map((p) =>
        `• ${p.product} (${p.count} ligne${p.count > 1 ? 's' : ''}) : Prix facturé : ${p.invoiced_price.toFixed(2)}€ / Prix négocié : ${p.negotiated_price.toFixed(2)}€ / Écart unitaire : ${p.unit_diff.toFixed(2)}€`
      )
      .join('\n');

    const subject = `${config.label} / VIVASON : Écarts de facturation ${monthLabel} ${year}`;
    const body = `${greeting},

Nous avons procédé à l'analyse de nos factures du mois de ${monthLabel} ${year} et avons constaté des écarts entre les prix facturés et les tarifs négociés.

Nous avons identifié ${totalDiscrepancies} écart${totalDiscrepancies > 1 ? 's' : ''} de facturation représentant un montant total de surfacturation de ${totalOvercharged.toFixed(2)}€ HT, répartis comme suit :

${productListing}

Peux-tu :
1. Vérifier ces écarts dans vos systèmes de facturation
2. Nous adresser un avoir de ${totalOvercharged.toFixed(2)}€ HT le cas échéant pour régulariser cette situation
3. Nous confirmer les mesures prises pour éviter de tels écarts dans la facturation future

Merci !`;

    // Save to email_drafts
    const { data: draft } = await supabase
      .from('email_drafts')
      .insert({
        analysis_id,
        supplier,
        subject,
        body,
      })
      .select()
      .single();

    return NextResponse.json(draft);
  } catch (error) {
    const message = error instanceof Error ? error.message : 'Erreur inconnue';
    return NextResponse.json({ error: message }, { status: 500 });
  }
}

// GET: fetch email drafts
export async function GET(req: NextRequest) {
  try {
    const { searchParams } = new URL(req.url);
    const analysisId = searchParams.get('analysis_id');

    const supabase = getSupabaseAdmin();

    let query = supabase.from('email_drafts').select('*');
    if (analysisId) query = query.eq('analysis_id', analysisId);
    query = query.order('created_at', { ascending: false });

    const { data, error } = await query;
    if (error) return NextResponse.json({ error: error.message }, { status: 500 });

    return NextResponse.json(data);
  } catch (error) {
    const message = error instanceof Error ? error.message : 'Erreur inconnue';
    return NextResponse.json({ error: message }, { status: 500 });
  }
}