import ICAL from "ical.js";

type CalendarTone = "cyan" | "amber" | "violet" | "emerald" | "rose";

type CalendarEvent = {
  id: string;
  calendar: string;
  title: string;
  location?: string;
  start: string;
  end: string;
  allDay: boolean;
  tone: CalendarTone;
};

const tones: CalendarTone[] = ["cyan", "amber", "violet", "emerald", "rose"];
const maxFeedBytes = 5 * 1024 * 1024;
const maxOccurrencesPerEvent = 10_000;

export const dynamic = "force-dynamic";

function cleanText(value: unknown, fallback: string, maxLength: number) {
  return String(value ?? fallback).replace(/\s+/g, " ").trim().slice(0, maxLength) || fallback;
}

function calendarDate(value: ICAL.Time) {
  return `${String(value.year).padStart(4, "0")}-${String(value.month).padStart(2, "0")}-${String(value.day).padStart(2, "0")}`;
}

function organizerDate(date: Date) {
  const parts = new Intl.DateTimeFormat("en-US", {
    timeZone: process.env.ORGANIZER_TIMEZONE || "America/Chicago",
    year: "numeric",
    month: "2-digit",
    day: "2-digit",
  }).formatToParts(date);
  const value = (part: string) => parts.find((entry) => entry.type === part)?.value ?? "";
  return `${value("year")}-${value("month")}-${value("day")}`;
}

function addCalendarDays(isoDate: string, days: number) {
  const [year, month, day] = isoDate.split("-").map(Number);
  const value = new Date(Date.UTC(year, month - 1, day + days));
  return value.toISOString().slice(0, 10);
}

function hashId(value: string) {
  let hash = 0x811c9dc5;
  for (let index = 0; index < value.length; index += 1) {
    hash ^= value.charCodeAt(index);
    hash = Math.imul(hash, 0x01000193);
  }
  return (hash >>> 0).toString(36);
}

function parseFeedUrls() {
  const raw = process.env.CALENDAR_ICAL_URLS;
  if (!raw) return [];

  const values = JSON.parse(raw) as unknown;
  if (!Array.isArray(values) || values.length < 1 || values.length > 10) {
    throw new Error("Calendar feed configuration is invalid");
  }

  return values.map((value) => {
    const url = new URL(String(value));
    if (url.protocol !== "https:" || url.hostname !== "calendar.google.com" || !url.pathname.endsWith("/basic.ics")) {
      throw new Error("Calendar feed host is not allowed");
    }
    return url.toString();
  });
}

async function readLimitedText(response: Response) {
  const declaredLength = Number(response.headers.get("content-length") ?? 0);
  if (declaredLength > maxFeedBytes) throw new Error("Calendar feed is too large");
  if (!response.body) return "";

  const reader = response.body.getReader();
  const decoder = new TextDecoder();
  let total = 0;
  let text = "";

  while (true) {
    const chunk = await reader.read();
    if (chunk.done) break;
    total += chunk.value.byteLength;
    if (total > maxFeedBytes) {
      await reader.cancel();
      throw new Error("Calendar feed is too large");
    }
    text += decoder.decode(chunk.value, { stream: true });
  }

  return text + decoder.decode();
}

function componentString(component: ICAL.Component, name: string) {
  const value = component.getFirstPropertyValue(name);
  return typeof value === "string" ? value : "";
}

function isCancelled(event: ICAL.Event) {
  return componentString(event.component, "status").toUpperCase() === "CANCELLED";
}

function detach(component: ICAL.Component) {
  return new ICAL.Component(structuredClone(component.toJSON()));
}

function eventIsInWindow(
  start: ICAL.Time,
  end: ICAL.Time,
  windowStart: number,
  horizon: number,
  windowStartDate: string,
  horizonDate: string,
) {
  if (start.isDate) {
    return calendarDate(end) > windowStartDate && calendarDate(start) <= horizonDate;
  }
  return end.toJSDate().getTime() > windowStart && start.toJSDate().getTime() <= horizon;
}

function occurrenceIsPastHorizon(start: ICAL.Time, horizon: number, horizonDate: string) {
  return start.isDate ? calendarDate(start) > horizonDate : start.toJSDate().getTime() > horizon;
}

function serializeOccurrence(
  event: ICAL.Event,
  start: ICAL.Time,
  end: ICAL.Time,
  calendar: string,
  tone: CalendarTone,
  feedIndex: number,
) {
  const allDay = start.isDate;
  const startValue = allDay ? calendarDate(start) : start.toJSDate().toISOString();
  const endValue = allDay ? calendarDate(end) : end.toJSDate().toISOString();
  const uid = cleanText(event.uid, "event", 180);
  const location = cleanText(event.location, "", 120);

  return {
    id: hashId(`${feedIndex}|${uid}|${startValue}`),
    calendar,
    title: cleanText(event.summary, "Busy", 140),
    ...(location ? { location } : {}),
    start: startValue,
    end: endValue,
    allDay,
    tone,
  } satisfies CalendarEvent;
}

function expandCalendar(
  ics: string,
  feedIndex: number,
  windowStart: number,
  horizon: number,
  windowStartDate: string,
  horizonDate: string,
) {
  const root = new ICAL.Component(ICAL.parse(ics));
  for (const timezone of root.getAllSubcomponents("vtimezone")) {
    try {
      ICAL.TimezoneService.register(timezone);
    } catch {
      // A feed may repeat a timezone that was already registered.
    }
  }

  const sourceName = cleanText(root.getFirstPropertyValue("x-wr-calname"), `Calendar ${feedIndex + 1}`, 50);
  const calendar = sourceName.includes("@") ? "Personal" : sourceName;
  const tone = tones[feedIndex % tones.length];
  const components = root.getAllSubcomponents("vevent");
  const exceptions = new Map<string, ICAL.Component[]>();

  for (const component of components) {
    if (!component.hasProperty("recurrence-id")) continue;
    const uid = componentString(component, "uid");
    if (!uid) continue;
    exceptions.set(uid, [...(exceptions.get(uid) ?? []), component]);
  }

  const items: CalendarEvent[] = [];
  for (const component of components) {
    if (component.hasProperty("recurrence-id")) continue;

    try {
      const event = new ICAL.Event(detach(component));
      for (const exception of exceptions.get(event.uid) ?? []) {
        event.relateException(detach(exception));
      }
      if (isCancelled(event)) continue;

      if (!event.isRecurring()) {
        if (eventIsInWindow(event.startDate, event.endDate, windowStart, horizon, windowStartDate, horizonDate)) {
          items.push(serializeOccurrence(event, event.startDate, event.endDate, calendar, tone, feedIndex));
        }
        continue;
      }

      const iterator = event.iterator();
      for (let count = 0; count < maxOccurrencesPerEvent; count += 1) {
        const occurrence = iterator.next();
        if (!occurrence) break;
        if (occurrenceIsPastHorizon(occurrence, horizon, horizonDate)) break;

        const details = event.getOccurrenceDetails(occurrence);
        if (isCancelled(details.item)) continue;
        if (eventIsInWindow(details.startDate, details.endDate, windowStart, horizon, windowStartDate, horizonDate)) {
          items.push(serializeOccurrence(details.item, details.startDate, details.endDate, calendar, tone, feedIndex));
        }
      }
    } catch {
      // Ignore a malformed event while keeping the rest of the calendar usable.
    }
  }

  return { calendar, items };
}

async function readCalendar(
  url: string,
  feedIndex: number,
  windowStart: number,
  horizon: number,
  windowStartDate: string,
  horizonDate: string,
) {
  let currentUrl = url;
  let response: Response | undefined;
  for (let redirectCount = 0; redirectCount <= 3; redirectCount += 1) {
    const validatedUrl = new URL(currentUrl);
    if (validatedUrl.protocol !== "https:" || validatedUrl.hostname !== "calendar.google.com" || !validatedUrl.pathname.endsWith("/basic.ics")) {
      throw new Error("Calendar redirect host is not allowed");
    }
    response = await fetch(validatedUrl, {
      headers: { Accept: "text/calendar" },
      redirect: "manual",
      signal: AbortSignal.timeout(10_000),
    });
    if (![301, 302, 303, 307, 308].includes(response.status)) break;
    const location = response.headers.get("location");
    if (!location || redirectCount === 3) throw new Error("Calendar feed redirected too many times");
    currentUrl = new URL(location, validatedUrl).toString();
  }
  if (!response) throw new Error("Calendar feed request failed");
  if (!response.ok) throw new Error("Calendar feed request failed");
  return expandCalendar(await readLimitedText(response), feedIndex, windowStart, horizon, windowStartDate, horizonDate);
}

export async function GET() {
  let urls: string[];
  try {
    urls = parseFeedUrls();
  } catch {
    return Response.json({ items: [], calendarsAvailable: 0, calendarsTotal: 0, updatedAt: new Date().toISOString() }, { status: 503 });
  }

  if (!urls.length) {
    return Response.json({ items: [], calendarsAvailable: 0, calendarsTotal: 0, updatedAt: new Date().toISOString() }, { status: 503 });
  }

  const now = Date.now();
  const windowStart = now - 45 * 24 * 60 * 60 * 1_000;
  const horizon = now + 60 * 24 * 60 * 60 * 1_000;
  const today = organizerDate(new Date(now));
  const windowStartDate = addCalendarDays(today, -45);
  const horizonDate = addCalendarDays(today, 60);
  const results = await Promise.allSettled(
    urls.map((url, index) => readCalendar(url, index, windowStart, horizon, windowStartDate, horizonDate)),
  );
  const successful = results.filter((result): result is PromiseFulfilledResult<Awaited<ReturnType<typeof readCalendar>>> => result.status === "fulfilled");
  const items = successful
    .flatMap((result) => result.value.items)
    .filter((item, index, all) => all.findIndex((candidate) => candidate.id === item.id) === index)
    .sort((left, right) => {
      const leftValue = left.allDay ? `${left.start}T00:00:00` : left.start;
      const rightValue = right.allDay ? `${right.start}T00:00:00` : right.start;
      return leftValue.localeCompare(rightValue);
    })
    .slice(0, 160);

  return Response.json(
    {
      items,
      calendarsAvailable: successful.length,
      calendarsTotal: urls.length,
      updatedAt: new Date().toISOString(),
    },
    {
      status: successful.length ? 200 : 503,
      headers: { "Cache-Control": "private, max-age=60, stale-while-revalidate=240" },
    },
  );
}