import { prisma } from "@/lib/prisma";
import PublicDashboard, { PubData } from "./PublicDashboard";

export const dynamic = "force-dynamic";

function Blocked({ title, msg }: { title: string; msg: string }) {
  return (
    <main className="flex min-h-screen items-center justify-center bg-slate-100 p-6">
      <div className="card max-w-md p-8 text-center">
        <div className="text-5xl">🔒</div>
        <h1 className="mt-3 text-xl font-bold">{title}</h1>
        <p className="mt-2 text-slate-500">{msg}</p>
      </div>
    </main>
  );
}

export default async function PublicPanel({ params }: { params: Promise<{ token: string }> }) {
  const { token } = await params;

  const traveler = await prisma.traveler.findUnique({
    where: { publicToken: token },
    include: {
      agency: true,
      emergencyContacts: true,
      documents: { orderBy: { createdAt: "desc" } },
      assignments: {
        include: {
          payments: true,
          trip: {
            include: {
              itineraryDays: { orderBy: { order: "asc" }, include: { items: { orderBy: { order: "asc" } } } },
              emergencyNumbers: true,
            },
          },
        },
        orderBy: { createdAt: "desc" },
      },
    },
  });

  if (!traveler) {
    return <Blocked title="Panel no encontrado" msg="El enlace no es válido o el viajero ya no existe." />;
  }
  if (traveler.agency.status === "SUSPENDED") {
    return (
      <Blocked
        title="Panel no disponible"
        msg="La agencia tiene su servicio suspendido temporalmente. Contáctala para más información."
      />
    );
  }

  // Ordena viajes: próximos/actuales primero
  const sorted = [...traveler.assignments].sort((a, b) => {
    const da = a.trip.startDate?.getTime() ?? 0;
    const db = b.trip.startDate?.getTime() ?? 0;
    return db - da;
  });

  const data: PubData = {
    traveler: {
      firstName: traveler.firstName,
      lastName: traveler.lastName,
      photoUrl: traveler.photoUrl,
      language: traveler.language,
      residenceCountry: traveler.residenceCountry,
      bloodType: traveler.bloodType,
      allergies: traveler.allergies,
      conditions: traveler.conditions,
      medications: traveler.medications,
      medicalNotes: traveler.medicalNotes,
      emergencyContacts: traveler.emergencyContacts.map((c) => ({
        name: c.name,
        relationship: c.relationship,
        country: c.country,
        phone: c.phone,
      })),
    },
    agency: {
      name: traveler.agency.name,
      logoUrl: traveler.agency.logoUrl,
      phone: traveler.agency.phone,
      whatsapp: traveler.agency.whatsapp,
    },
    trips: sorted.map((a) => ({
      id: a.trip.id,
      assignmentId: a.id,
      name: a.trip.name,
      originCountry: a.trip.originCountry,
      destinationCountry: a.trip.destinationCountry,
      startDate: a.trip.startDate?.toISOString() ?? null,
      endDate: a.trip.endDate?.toISOString() ?? null,
      currencyFrom: a.trip.currencyFrom,
      currencyTo: a.trip.currencyTo,
      exchangeRate: a.trip.exchangeRate,
      cost: a.cost,
      paid: a.payments.reduce((s, p) => s + p.amount, 0),
      itinerary: a.trip.itineraryDays.map((d) => ({
        title: d.title,
        date: d.date?.toISOString() ?? null,
        items: d.items.map((it) => ({
          time: it.time,
          title: it.title,
          location: it.location,
          description: it.description,
        })),
      })),
      emergencyNumbers: a.trip.emergencyNumbers.map((n) => ({
        label: n.label,
        phone: n.phone,
        country: n.country,
      })),
    })),
    documents: traveler.documents.map((d) => ({
      type: d.type,
      title: d.title,
      fileUrl: d.fileUrl,
      assignmentId: d.assignmentId,
    })),
  };

  return <PublicDashboard data={data} />;
}