import { createServerFn } from "@tanstack/react-start";
import { z } from "zod";
import { createClient } from "@supabase/supabase-js";
import type { Database } from "@/integrations/supabase/types";
import { requireSupabaseAuth } from "@/integrations/supabase/auth-middleware";

export type EventRow = Database["public"]["Tables"]["events"]["Row"];
export type PublicationRow = Database["public"]["Tables"]["event_publications"]["Row"];

/**
 * Publishable (anon) Supabase client for public event reads.
 * Created inside the handler — env vars are only available at call time.
 */
function publishableClient() {
  const url = process.env["SUPABASE_URL"];
  const key = process.env["SUPABASE_PUBLISHABLE_KEY"];
  if (!url || !key) {
    throw new Error("Missing Supabase env vars. Connect Lovable Cloud.");
  }
  return createClient<Database>(url, key, {
    auth: { persistSession: false, autoRefreshToken: false },
  });
}

function todayISO(): string {
  return new Date().toISOString().slice(0, 10);
}

const eventInput = z.object({
  title: z.string().min(1, "Le titre est requis"),
  description: z.string().nullish(),
  category: z.string().default("Soirée"),
  event_date: z.string().min(1, "La date est requise"),
  time_label: z.string().nullish(),
  image_url: z.string().nullish(),
  is_featured: z.boolean().default(false),
  publish_instagram: z.boolean().default(true),
  publish_facebook: z.boolean().default(true),
  publish_wyylde: z.boolean().default(true),
  social_caption: z.string().nullish(),
});

const updateInput = z.object({
  id: z.string().min(1),
  title: z.string().min(1, "Le titre est requis"),
  description: z.string().nullish(),
  category: z.string().default("Soirée"),
  event_date: z.string().min(1, "La date est requise"),
  time_label: z.string().nullish(),
  image_url: z.string().nullish(),
  is_featured: z.boolean().default(false),
  publish_instagram: z.boolean().default(true),
  publish_facebook: z.boolean().default(true),
  publish_wyylde: z.boolean().default(true),
  social_caption: z.string().nullish(),
});

type EventInput = z.infer<typeof eventInput>;

/** Map parsed input to a DB row, coercing undefined → null for nullable cols. */
function toRow(d: EventInput) {
  return {
    title: d.title,
    description: d.description ?? null,
    category: d.category,
    event_date: d.event_date,
    time_label: d.time_label ?? null,
    image_url: d.image_url ?? null,
    is_featured: d.is_featured,
    publish_instagram: d.publish_instagram,
    publish_facebook: d.publish_facebook,
    publish_wyylde: d.publish_wyylde,
    social_caption: d.social_caption?.trim() || null,
  };
}

/**
 * Public reads must never blank the site: if the database is briefly
 * unreachable, return an empty list instead of throwing during SSR.
 */
async function safePublicEvents(limit?: number): Promise<EventRow[]> {
  try {
    const supabase = publishableClient();
    let query = supabase
      .from("events")
      .select("*")
      .gte("event_date", todayISO())
      .order("event_date", { ascending: true });
    if (limit) query = query.limit(limit);
    const { data, error } = await query;
    if (error) {
      console.error("[events] public read failed:", error.message);
      return [];
    }
    return (data ?? []) as EventRow[];
  } catch (err) {
    console.error("[events] public read threw:", err);
    return [];
  }
}

/** Upcoming events, soonest first — public. */
export const fetchFeaturedEvents = createServerFn({ method: "GET" }).handler(async () =>
  safePublicEvents(3),
);

/** All upcoming events — public. */
export const fetchAllEvents = createServerFn({ method: "GET" }).handler(async () =>
  safePublicEvents(),
);

export const createEvent = createServerFn({ method: "POST" })
  .middleware([requireSupabaseAuth])
  .validator(eventInput)
  .handler(async ({ data, context }) => {
    const { data: row, error } = await context.supabase
      .from("events")
      .insert(toRow(data))
      .select()
      .single();
    if (error) throw new Error(error.message);
    // Diffusion automatique sur les réseaux cochés (ne bloque jamais la création).
    const { publishEvent: publish } = await import("./social.server");
    const publications = await publish(context.supabase, row as EventRow);
    return { event: row as EventRow, publications };
  });

export const updateEvent = createServerFn({ method: "POST" })
  .middleware([requireSupabaseAuth])
  .validator(updateInput)
  .handler(async ({ data, context }) => {
    const { id, ...rest } = data;
    const { data: row, error } = await context.supabase
      .from("events")
      .update(toRow(rest))
      .eq("id", id)
      .select()
      .single();
    if (error) throw new Error(error.message);
    return row as EventRow;
  });

export const deleteEvent = createServerFn({ method: "POST" })
  .middleware([requireSupabaseAuth])
  .validator(z.object({ id: z.string().min(1) }))
  .handler(async ({ data, context }) => {
    const { error } = await context.supabase.from("events").delete().eq("id", data.id);
    if (error) throw new Error(error.message);
    return { ok: true as const };
  });

export const fetchAllEventsAdmin = createServerFn({ method: "GET" })
  .middleware([requireSupabaseAuth])
  .handler(async ({ context }) => {
    const { data, error } = await context.supabase
      .from("events")
      .select("*")
      .order("event_date", { ascending: false });
    if (error) throw new Error(error.message);
    return (data ?? []) as EventRow[];
  });

/** (Re)diffuse un événement : canaux en erreur ou pas encore publiés. */
export const publishEventToSocials = createServerFn({ method: "POST" })
  .middleware([requireSupabaseAuth])
  .validator(
    z.object({
      id: z.string().min(1),
      force: z.boolean().default(false),
      only: z.array(z.enum(["instagram", "facebook", "wyylde"])).optional(),
    }),
  )
  .handler(async ({ data, context }) => {
    const { data: ev, error } = await context.supabase
      .from("events")
      .select("*")
      .eq("id", data.id)
      .single();
    if (error || !ev) throw new Error(error?.message ?? "Événement introuvable");
    const { publishEvent: publish } = await import("./social.server");
    return publish(context.supabase, ev as EventRow, { force: data.force, only: data.only });
  });

export const fetchPublicationsAdmin = createServerFn({ method: "GET" })
  .middleware([requireSupabaseAuth])
  .handler(async ({ context }) => {
    const { data, error } = await context.supabase.from("event_publications").select("*");
    if (error) throw new Error(error.message);
    return (data ?? []) as PublicationRow[];
  });
