import { logApiError } from "@/lib/api/security";
import { NextResponse } from "next/server";
import {
  buildWorkspaceCalendarFeed,
  hashCalendarFeedToken,
  type CalendarFeedEntry,
} from "@/lib/integrations/calendar-feed";
import { createAdminClient } from "@/lib/supabase/admin";
import type { CalendarEvent, Task } from "@/types";

export const dynamic = "force-dynamic";

function getWorkspaceFilename(name: string) {
  const safe = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
  return safe || "mindavio-calendar";
}

export async function GET(
  _req: Request,
  context: { params: Promise<{ token: string }> }
) {
  try {
    const { token } = await context.params;
    const admin = createAdminClient();
    const tokenHash = hashCalendarFeedToken(token);

    const { data: feed } = await admin
      .from("calendar_feed_tokens")
      .select("id, user_id, team_id, name, is_active")
      .eq("token_hash", tokenHash)
      .maybeSingle();

    if (!feed || !feed.is_active) {
      return new NextResponse("Calendar feed not found", { status: 404 });
    }

    const workspaceName = feed.team_id
      ? (
          await admin.from("teams").select("name").eq("id", feed.team_id).maybeSingle()
        ).data?.name || feed.name
      : feed.name;

    let eventsQuery = admin
      .from("events")
      .select("id, title, description, start_time, end_time, all_day, updated_at, user_id, team_id")
      .order("start_time", { ascending: true });
    eventsQuery = feed.team_id
      ? eventsQuery.eq("team_id", feed.team_id)
      : eventsQuery.eq("user_id", feed.user_id).is("team_id", null);

    let tasksQuery = admin
      .from("tasks")
      .select("id, title, description, deadline, status, updated_at, user_id, team_id")
      .not("deadline", "is", null)
      .neq("status", "done")
      .neq("status", "cancelled")
      .order("deadline", { ascending: true });
    tasksQuery = feed.team_id
      ? tasksQuery.eq("team_id", feed.team_id)
      : tasksQuery.eq("user_id", feed.user_id).is("team_id", null);

    const [{ data: events }, { data: tasks }] = await Promise.all([eventsQuery, tasksQuery]);

    const entries: CalendarFeedEntry[] = [
      ...((events || []) as CalendarEvent[]).map((event) => ({
        uid: `mindavio-event-${event.id}`,
        title: event.title,
        description: event.description,
        start: event.start_time,
        end: event.end_time,
        allDay: event.all_day,
        updatedAt: event.updated_at,
      })),
      ...((tasks || []) as Array<Task & { deadline: string }>).map((task) => ({
        uid: `mindavio-task-${task.id}`,
        title: `Task due: ${task.title}`,
        description: task.description || null,
        start: task.deadline,
        end: task.deadline,
        allDay: true,
        updatedAt: task.updated_at,
      })),
    ];

    const body = buildWorkspaceCalendarFeed({
      calendarName: workspaceName,
      entries,
    });

    await admin
      .from("calendar_feed_tokens")
      .update({ last_accessed_at: new Date().toISOString() })
      .eq("id", feed.id);

    return new NextResponse(body, {
      status: 200,
      headers: {
        "Content-Type": "text/calendar; charset=utf-8",
        "Cache-Control": "no-store",
        "Content-Disposition": `inline; filename=\"${getWorkspaceFilename(workspaceName)}.ics\"`,
      },
    });
  } catch (error) {
    logApiError("Calendar feed GET error:", error);
    return new NextResponse("Failed to build calendar feed", { status: 500 });
  }
}