import {
  Calendar,
  MapPin,
  Users,
  Vote,
  Clock,
  Home,
} from "lucide-react";
import { unstable_noStore } from "next/cache";
import { cn } from "@/lib/utils";
import { getAllAgenda, type AgendaEvent } from "@/lib/db/agenda";

// Toujours interroger la BDD à chaque requête (pas de cache)
export const dynamic = "force-dynamic";
export const revalidate = 0;

const getEventTypeConfig = (type: string) => {
  switch (type) {
    case "reunion-quartier":
      return {
        icon: MapPin,
        color: "bg-turquoise text-white",
        borderColor: "border-turquoise",
        label: "Réunion de quartier",
      };
    case "reunion-publique":
      return {
        icon: Users,
        color: "bg-violet text-white",
        borderColor: "border-violet",
        label: "Réunion publique",
      };
    case "election":
      return {
        icon: Vote,
        color: "bg-orange text-white",
        borderColor: "border-orange",
        label: "Élection",
      };
    case "inauguration":
      return {
        icon: Home,
        color: "bg-vert text-white",
        borderColor: "border-vert",
        label: "Inauguration de la permanence",
      };
    default:
      return {
        icon: Calendar,
        color: "bg-zinc-500 text-white",
        borderColor: "border-zinc-500",
        label: "Autre",
      };
  }
};

const formatDate = (dateString: string) => {
  const date = new Date(dateString);
  const options: Intl.DateTimeFormatOptions = {
    weekday: "long",
    day: "numeric",
    month: "long",
    year: "numeric",
  };
  return date.toLocaleDateString("fr-FR", options);
};

const getMonthYear = (dateString: string) => {
  const date = new Date(dateString);
  return date.toLocaleDateString("fr-FR", { month: "long", year: "numeric" });
};

function groupEventsByMonth(events: AgendaEvent[]): Record<string, AgendaEvent[]> {
  const grouped = events.reduce((acc, event) => {
    const monthYear = getMonthYear(event.date);
    if (!acc[monthYear]) acc[monthYear] = [];
    acc[monthYear].push(event);
    return acc;
  }, {} as Record<string, AgendaEvent[]>);
  Object.keys(grouped).forEach((month) => {
    grouped[month].sort((a, b) =>
      a.date !== b.date ? a.date.localeCompare(b.date) : (a.time || "").localeCompare(b.time || "")
    );
  });
  return grouped;
}

function getMonthStartDate(monthYear: string, groupedEvents: Record<string, AgendaEvent[]>): Date {
  const firstEvent = groupedEvents[monthYear]?.[0];
  if (firstEvent) {
    const date = new Date(firstEvent.date);
    return new Date(date.getFullYear(), date.getMonth(), 1);
  }
  return new Date();
}

function isPastEvent(event: AgendaEvent): boolean {
  const today = new Date();
  const y = today.getFullYear();
  const m = String(today.getMonth() + 1).padStart(2, "0");
  const d = String(today.getDate()).padStart(2, "0");
  const todayStr = `${y}-${m}-${d}`;
  return event.date < todayStr;
}

export default async function Agenda() {
  unstable_noStore();
  const events = await getAllAgenda();
  const upcomingEvents = events.filter((e) => !isPastEvent(e));
  const pastEvents = events.filter(isPastEvent);
  const groupedUpcoming = groupEventsByMonth(upcomingEvents);
  const groupedPast = groupEventsByMonth(pastEvents);

  return (
    <div className="flex flex-col gap-12 w-full">
      <div>
        <h1 className="text-3xl font-semibold leading-10 tracking-tight text-black dark:text-zinc-50 mb-4">
          AGENDA
        </h1>
        <p className="text-lg leading-8 text-zinc-600 dark:text-zinc-400 max-w-3xl">
          Retrouvez toutes les dates importantes de la campagne : réunions de
          quartier, meetings publics et élections municipales. Votre
          participation est essentielle pour construire ensemble l&apos;avenir
          de Bergerac.
        </p>
      </div>

      {events.length === 0 ? (
        <p className="text-zinc-600 dark:text-zinc-400 text-lg">
          Aucun événement prévu pour le moment. Revenez bientôt !
        </p>
      ) : (
        <>
      {/* Dates importantes à venir */}
{/*       {upcomingEvents.filter((e) => e.important === true).length > 0 && (
      <div className="grid grid-cols-1 md:grid-cols-2 gap-4 mb-8">
        {upcomingEvents
          .filter((event) => event.important === true)
          .map((event) => {
            const config = getEventTypeConfig(event.type);
            const Icon = config.icon;
            return (
              <div
                key={event.id}
                className={cn(
                  "bg-white rounded-lg p-6 shadow-lg border-2",
                  config.borderColor,
                  "hover:shadow-xl transition-all duration-300"
                )}
              >
                <div className="flex items-start gap-4">
                  <div
                    className={cn(
                      "w-16 h-16 rounded-lg flex items-center justify-center shrink-0",
                      config.color
                    )}
                  >
                    <Icon size={28} />
                  </div>
                  <div className="flex-1">
                    <div className="flex items-center gap-2 mb-2">
                      <span
                        className={cn(
                          "text-xs font-semibold px-2 py-1 rounded",
                          config.color
                        )}
                      >
                        {config.label}
                      </span>
                      {(event.important === true) && (
                        <span className="text-xs font-semibold px-2 py-1 rounded bg-orange text-white">
                          Important
                        </span>
                      )}
                    </div>
                    <h3 className="text-xl font-semibold text-foreground mb-2">
                      {event.title}
                    </h3>
                    <div className="flex flex-wrap gap-4 text-sm text-zinc-600 dark:text-zinc-400 mb-3">
                      <div className="flex items-center gap-2">
                        <Calendar size={16} />
                        <span>{formatDate(event.date)}</span>
                      </div>
                      <div className="flex items-center gap-2">
                        <Clock size={16} />
                        <span>{event.time}</span>
                      </div>
                    </div>
                    <div className="flex items-start gap-2 text-sm text-zinc-600 dark:text-zinc-400 mb-3">
                      <MapPin size={16} className="mt-0.5 shrink-0" />
                      <span>{event.location}</span>
                    </div>
                    <p className="text-sm leading-6 text-zinc-600 dark:text-zinc-400">
                      {event.description}
                    </p>
                  </div>
                </div>
              </div>
            );
          })}
      </div>
      )} */}

      {/* Événements à venir groupés par mois */}
      {upcomingEvents.length > 0 && (
      <div className="flex flex-col gap-8">
        {Object.entries(groupedUpcoming)
          .sort(([a], [b]) => {
            const dateA = getMonthStartDate(a, groupedUpcoming);
            const dateB = getMonthStartDate(b, groupedUpcoming);
            return dateA.getTime() - dateB.getTime();
          })
          .map(([monthYear, monthEvents]) => (
            <div key={monthYear} className="flex flex-col gap-6">
              <h2 className="text-2xl font-semibold text-violet capitalize">
                {monthYear}
              </h2>

              <div className="relative">
                <div className="absolute left-6 top-0 bottom-0 w-0.5 bg-violet/20 hidden md:block" />
                <div className="flex flex-col gap-6">
                  {monthEvents.map((event) => {
                    const config = getEventTypeConfig(event.type);
                    const Icon = config.icon;
                    return (
                      <div key={event.id} className="relative flex gap-6">
                        <div className="relative z-10 shrink-0">
                          <div
                            className={cn(
                              "w-12 h-12 rounded-full flex items-center justify-center shadow-md",
                              config.color
                            )}
                          >
                            <Icon size={20} />
                          </div>
                        </div>
                        <div
                          className={cn(
                            "flex-1 bg-white rounded-lg p-6 shadow-md hover:shadow-lg transition-all duration-300 border border-border",
                            event.important === true && "border-2 " + config.borderColor
                          )}
                        >
                          <div className="flex flex-wrap items-center gap-3 mb-3">
                            <span className={cn("text-xs font-semibold px-3 py-1 rounded-full", config.color)}>
                              {config.label}
                            </span>
                            {event.important === true && (
                              <span className="text-xs font-semibold px-3 py-1 rounded-full bg-orange text-white">
                                Important
                              </span>
                            )}
                            <div className="flex items-center gap-2 text-sm text-zinc-600 dark:text-zinc-400">
                              <Calendar size={14} />
                              <span className="font-medium">{formatDate(event.date)}</span>
                            </div>
                            <div className="flex items-center gap-2 text-sm text-zinc-600 dark:text-zinc-400">
                              <Clock size={14} />
                              <span>{event.time}</span>
                            </div>
                          </div>
                          <h3 className="text-xl font-semibold text-foreground mb-3">{event.title}</h3>
                          <div className="flex items-start gap-2 text-sm text-zinc-600 dark:text-zinc-400 mb-4">
                            <MapPin size={16} className="mt-0.5 shrink-0" />
                            <span>{event.location}</span>
                          </div>
                          <p className="text-sm leading-6 text-zinc-600 dark:text-zinc-400">{event.description}</p>
                        </div>
                      </div>
                    );
                  })}
                </div>
              </div>
            </div>
          ))}
      </div>
      )}

      {upcomingEvents.length === 0 && pastEvents.length > 0 && (
        <p className="text-zinc-600 dark:text-zinc-400 text-lg">
          Aucun événement à venir pour le moment.
        </p>
      )}

      {/* Événements passés — affichage atténué */}
      {pastEvents.length > 0 && (
      <div className="flex flex-col gap-8 mt-4 pt-8 border-t border-zinc-200 dark:border-zinc-800">
        <h2 className="text-xl font-semibold text-zinc-500 dark:text-zinc-400">
          Événements passés
        </h2>
        <div className="flex flex-col gap-8">
          {Object.entries(groupedPast)
            .sort(([a], [b]) => {
              const dateA = getMonthStartDate(a, groupedPast);
              const dateB = getMonthStartDate(b, groupedPast);
              return dateB.getTime() - dateA.getTime(); // plus récent en premier
            })
            .map(([monthYear, monthEvents]) => (
              <div key={`past-${monthYear}`} className="flex flex-col gap-6">
                <h3 className="text-lg font-medium text-zinc-500 dark:text-zinc-400 capitalize">
                  {monthYear}
                </h3>
                <div className="relative">
                  <div className="absolute left-5 top-0 bottom-0 w-0.5 bg-zinc-200 dark:bg-zinc-700 hidden md:block" />
                  <div className="flex flex-col gap-4">
                    {monthEvents.map((event) => {
                      const config = getEventTypeConfig(event.type);
                      const Icon = config.icon;
                      return (
                        <div key={event.id} className="relative flex gap-5">
                          <div className="relative z-10 shrink-0">
                            <div
                              className={cn(
                                "w-10 h-10 rounded-full flex items-center justify-center bg-zinc-200 dark:bg-zinc-700 text-zinc-500 dark:text-zinc-400"
                              )}
                            >
                              <Icon size={18} />
                            </div>
                          </div>
                          <div
                            className={cn(
                              "flex-1 rounded-lg p-5 border border-zinc-200 dark:border-zinc-800",
                              "bg-zinc-50/80 dark:bg-zinc-900/40",
                              "text-zinc-600 dark:text-zinc-400"
                            )}
                          >
                            <div className="flex flex-wrap items-center gap-2 mb-2">
                              <span className="text-xs font-medium px-2 py-0.5 rounded bg-zinc-200 dark:bg-zinc-700 text-zinc-600 dark:text-zinc-400">
                                {config.label}
                              </span>
                              <span className="text-xs font-medium px-2 py-0.5 rounded bg-zinc-300 dark:bg-zinc-600 text-zinc-500 dark:text-zinc-300">
                                Passé
                              </span>
                              <span className="text-sm text-zinc-500 dark:text-zinc-500">
                                {formatDate(event.date)} · {event.time}
                              </span>
                            </div>
                            <h3 className="text-base font-semibold text-zinc-700 dark:text-zinc-300 mb-2">
                              {event.title}
                            </h3>
                            <div className="flex items-start gap-2 text-sm text-zinc-500 dark:text-zinc-500 mb-2">
                              <MapPin size={14} className="mt-0.5 shrink-0" />
                              <span>{event.location}</span>
                            </div>
                            <p className="text-sm text-zinc-500 dark:text-zinc-500 leading-relaxed">
                              {event.description}
                            </p>
                          </div>
                        </div>
                      );
                    })}
                  </div>
                </div>
              </div>
            ))}
        </div>
      </div>
      )}
        </>
      )}
    </div>
  );
}
