"use server";

import { revalidatePath } from "next/cache";
import { hasPermission } from "@/lib/adminAuth";
import { getSessionClientId } from "@/lib/auth";
import { connectDB } from "@/lib/db";
import { Order } from "@/models/Order";
import { Settings } from "@/models/Settings";
import { getPriceState } from "@/lib/priceProposal";
import { getSettings } from "@/lib/settings";
import { getStripeClient, isStripeConfigured } from "@/lib/stripe";
import { formatPaymentReference } from "@/lib/orderConstants";
import { getPayableAmount, getTotalOrderDiscount } from "@/lib/discounts";
import { logAdminActivity } from "@/lib/teamActivity";

export async function setPaymentEnabledAction(enabled: boolean) {
  if (!(await hasPermission("settings"))) return;
  if (enabled && !isStripeConfigured()) return;
  await connectDB();
  await Settings.findOneAndUpdate(
    { key: "main" },
    { $set: { "paymentSettings.enabled": enabled }, $setOnInsert: { key: "main" } },
    { upsert: true }
  );
  await logAdminActivity("Online-Zahlung geändert", enabled ? "Aktiviert" : "Deaktiviert");
  revalidatePath("/de/admin/settings");
}

type CheckoutResult = { url: string } | { error: string };

// Erzeugt eine Stripe-Checkout-Session für einen Auftrag — welche
// Zahlungsmethoden (Karte/PayPal/Klarna) angeboten werden, steuert Rakku
// direkt im Stripe-Dashboard, nicht der Code hier.
export async function createCheckoutSessionAction(orderId: string, locale: "de" | "en" = "de"): Promise<CheckoutResult> {
  const clientId = await getSessionClientId();
  if (!clientId) return { error: "Bitte logge dich ein." };

  await connectDB();
  const [order, settings] = await Promise.all([Order.findById(orderId).lean(), getSettings()]);
  if (!order || String(order.clientId) !== clientId) return { error: "Auftrag nicht gefunden." };
  if (!settings.paymentSettings?.enabled) return { error: "Online-Zahlung ist derzeit nicht aktiviert." };
  if (order.compensationType !== "paid" || order.paid) return { error: "Für diesen Auftrag nicht möglich." };

  const { state } = await getPriceState(orderId);
  if (state.phase !== "agreed") return { error: "Es ist noch kein Preis final vereinbart." };

  const stripe = getStripeClient();
  if (!stripe) return { error: "Online-Zahlung ist noch nicht eingerichtet." };

  // Inkl. aufgelaufener Mahngebühren (siehe reminderEscalation.ts) — sonst
  // würde die Direktzahlung einen zu niedrigen Betrag abbuchen, sobald schon
  // eine Mahnstufe mit Zusatzgebühr existiert.
  const totalPayable = getPayableAmount(state.latest.amount, getTotalOrderDiscount(order)) + (order.reminderFeeTotal || 0);

  // Anzahlung: solange eine gesetzte Anzahlung noch nicht bezahlt ist, wird
  // NUR die Anzahlung abgerechnet (paymentKind "deposit") — erst danach
  // greift der normale Restbetrag (paymentKind "balance"). Ohne gesetzte
  // Anzahlung läuft es wie bisher als eine einzige Vollzahlung.
  const hasOpenDeposit = order.depositAmount > 0 && !order.depositPaid;
  const paymentKind: "deposit" | "balance" = hasOpenDeposit ? "deposit" : "balance";
  const amountDue = hasOpenDeposit ? order.depositAmount : totalPayable - (order.depositPaid ? order.depositAmount : 0);
  const amountCents = Math.round(amountDue * 100);
  if (amountCents < 50) return { error: "Kein Online-Zahlungsbetrag offen." };
  const reference = formatPaymentReference(orderId);
  const baseUrl = process.env.SITE_URL;

  const session = await stripe.checkout.sessions.create({
    mode: "payment",
    line_items: [
      {
        price_data: {
          currency: "eur",
          unit_amount: amountCents,
          product_data: {
            name: `${order.characterOrConcept} — Rakku Photography${paymentKind === "deposit" ? " (Anzahlung)" : ""}`,
            description: `Referenz ${reference}`,
          },
        },
        quantity: 1,
      },
    ],
    metadata: { orderId, paymentKind },
    payment_intent_data: { metadata: { orderId, paymentKind } },
    success_url: `${baseUrl}/${locale}/account/orders/${orderId}?payment=success`,
    cancel_url: `${baseUrl}/${locale}/account/orders/${orderId}?payment=cancelled`,
  });

  if (!session.url) return { error: "Zahlung konnte nicht gestartet werden." };
  return { url: session.url };
}