import { logApiError } from "@/lib/api/security";
import { canManageWorkspace } from "@/lib/developers/auth";
import { createGmailDraft } from "@/lib/integrations/google-workspace";
import {
  buildInvoicePdfBlob,
  formatInvoiceMoney,
  getInvoiceDocumentLabel,
  sanitizeInvoiceFileSegment,
} from "@/lib/invoices";
import { createAdminClient } from "@/lib/supabase/admin";
import { createRouteClient } from "@/lib/supabase/route";
import type { IntegrationConnection, Invoice, InvoiceItem } from "@/types";
import { NextResponse } from "next/server";

export async function POST(
  req: Request,
  context: { params: Promise<{ id: string }> },
) {
  try {
    const supabase = await createRouteClient();
    const {
      data: { user },
    } = await supabase.auth.getUser();

    if (!user) {
      return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
    }

    const { id } = await context.params;
    const body = (await req.json().catch(() => ({}))) as {
      body?: string;
      connectionId?: string;
      subject?: string;
      to?: string;
    };

    const { data: invoice, error: invoiceError } = await supabase
      .from("invoices")
      .select("*")
      .eq("id", id)
      .single();

    if (invoiceError || !invoice) {
      return NextResponse.json({ error: "Dokument nicht gefunden." }, { status: 404 });
    }

    const typedInvoice = invoice as Invoice;
    const manageable = await canManageWorkspace(user.id, typedInvoice.team_id);
    if (!manageable) {
      return NextResponse.json({ error: "Forbidden" }, { status: 403 });
    }

    const { data: items, error: itemsError } = await supabase
      .from("invoice_items")
      .select("*")
      .eq("invoice_id", typedInvoice.id)
      .order("sort_order");

    if (itemsError) {
      return NextResponse.json({ error: itemsError.message }, { status: 400 });
    }

    const documentWithItems: Invoice = {
      ...typedInvoice,
      items: (items || []) as InvoiceItem[],
    };
    const documentLabel = getInvoiceDocumentLabel(documentWithItems);
    const to = body.to?.trim() || documentWithItems.counterparty_email?.trim();

    if (!to) {
      return NextResponse.json({ error: "Empfänger-E-Mail fehlt." }, { status: 400 });
    }

    const admin = createAdminClient();
    let connectionQuery = admin
      .from("integration_connections")
      .select(
        "id, user_id, team_id, provider, name, config, event_types, is_active, last_delivery_at, last_response_status, last_error, created_at, updated_at, secret_encrypted",
      )
      .eq("provider", "gmail")
      .eq("is_active", true)
      .limit(1);

    connectionQuery = body.connectionId
      ? connectionQuery.eq("id", body.connectionId)
      : documentWithItems.team_id
        ? connectionQuery.eq("team_id", documentWithItems.team_id)
        : connectionQuery.eq("user_id", user.id).is("team_id", null);

    const { data: connection } = await connectionQuery.maybeSingle();
    if (!connection) {
      return NextResponse.json({ error: "Keine aktive Gmail-Verbindung gefunden." }, { status: 400 });
    }

    const pdfBlob = await buildInvoicePdfBlob(documentWithItems);
    const pdfBuffer = Buffer.from(await pdfBlob.arrayBuffer());
    const fileBase = [
      sanitizeInvoiceFileSegment(documentWithItems.invoice_number || documentLabel),
      sanitizeInvoiceFileSegment(documentWithItems.counterparty_name || ""),
    ]
      .filter(Boolean)
      .join("-");

    const subject = body.subject?.trim() || `${documentLabel} ${documentWithItems.invoice_number}`;
    const draftBody =
      body.body?.trim() ||
      `Hallo,\n\nanbei sende ich das ${documentLabel.toLowerCase()} ${documentWithItems.invoice_number} über ${formatInvoiceMoney(
        documentWithItems.total_cents,
        documentWithItems.currency,
      )}.\n\nViele Grüße`;

    const result = await createGmailDraft(
      admin,
      connection as IntegrationConnection & { secret_encrypted: string },
      {
        attachments: [
          {
            content: pdfBuffer,
            fileName: `${fileBase || sanitizeInvoiceFileSegment(documentLabel)}.pdf`,
            mimeType: "application/pdf",
          },
        ],
        body: draftBody,
        eventType: documentWithItems.document_type === "quote" ? "invoice.quote_draft" : "invoice.gmail_draft",
        payload: {
          document_type: documentWithItems.document_type,
          invoice_id: documentWithItems.id,
          invoice_number: documentWithItems.invoice_number,
          total_cents: documentWithItems.total_cents,
        },
        subject,
        to,
      },
    );

    await supabase.from("invoice_events").insert({
      details: {
        draft_id: result.draftId,
        to: result.recipient,
      },
      event_type: "send_prepared",
      invoice_id: documentWithItems.id,
      team_id: documentWithItems.team_id,
      title: "Gmail-Entwurf mit PDF erstellt",
      user_id: user.id,
    });

    return NextResponse.json({
      draftId: result.draftId,
      recipient: result.recipient,
      webUrl: "https://mail.google.com/mail/u/0/#drafts",
    });
  } catch (error) {
    logApiError("Invoice Gmail draft POST error:", error);
    return NextResponse.json({ error: "Gmail-Entwurf konnte nicht erstellt werden." }, { status: 500 });
  }
}