import db, { cached } from "./db";

// –
// Types
// –

/** A GitHub Status incident. */
export interface Incident {
  created_at: string;
  id: string;
  impact: string;
  name: string;
  resolved_at: string | null;
  shortlink: string;
  started_at: string;
  status: string;
  updated_at: string;
}

/** Incident severity level. */
export type Impact = "critical" | "major" | "minor" | "none";

/** Severity weights per impact level. */
export const impactWeights: Record<Impact, number> = {
  critical: 4,
  major: 3,
  minor: 2,
  none: 1,
};

/** A day cell in the heatmap grid. */
export interface HeatmapDay {
  count: number;
  date: string;
  incidents: Incident[];
  severity: number;
}

// –
// Status
// –

interface StatusResponse {
  status: { description: string; indicator: string };
}

export interface UnresolvedResponse {
  incidents: (Incident & { incident_updates: { body: string }[] })[];
}

const toJSON = (r: Response) => r.json();

/** Fetch live status from GitHub, sync recent incidents to DB. */
export async function sync() {
  const [status, unresolved, result] = await Promise.all([
    cached<StatusResponse>(
      "status",
      () => fetch("https://www.githubstatus.com/api/v2/status.json").then(toJSON),
    ),
    cached<UnresolvedResponse>(
      "unresolved",
      () => fetch("https://www.githubstatus.com/api/v2/incidents/unresolved.json").then(toJSON),
    ),
    cached<{ incidents: Incident[] }>(
      "incidents",
      () => fetch("https://www.githubstatus.com/api/v2/incidents.json").then(toJSON),
    ),
  ]);

  if (result) {
    const insert = db.prepare(`
      INSERT OR REPLACE INTO incidents
      (id, name, status, created_at, updated_at, resolved_at, impact, shortlink, started_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
    `);

    for (const incident of result.incidents) {
      insert.run(
        incident.id,
        incident.name,
        incident.status,
        incident.created_at,
        incident.updated_at,
        incident.resolved_at,
        incident.impact,
        incident.shortlink,
        incident.started_at,
      );
    }
  }

  return { status, unresolved };
}

// –
// Status info
// –

/** Derived status with human-readable label and duration. */
export interface StatusInfo {
  /** Human-readable duration (e.g. "for 3 hr"). */
  duration: string;
  /** Raw indicator ("none" | "minor" | "major" | "critical"). */
  indicator: string;
  /** Human-readable label. */
  label: string;
}

/** Derive unified status label and duration from live data. */
export function statusInfo(
  { status, unresolved }: Awaited<ReturnType<typeof sync>>,
  { incidents }: Pick<ReturnType<typeof heatmap>, "incidents">,
): StatusInfo {
  const indicator = status?.status.indicator ?? "none";
  const label =
  indicator === "critical" ? "Critical Outage"
  : indicator === "major" ? "Major Outage"
  : indicator === "minor" ? "Minor Outage"
  : "All Systems Operational";

  // How long the current status has been ongoing (branch on indicator to match label)
  const now = Date.now();
  const ongoingSince =
    // Outage: since earliest unresolved incident started
    indicator !== "none" && unresolved?.incidents.length
      ? Math.min(...unresolved.incidents.map((i) => new Date(i.started_at).getTime()))
    // Operational but incidents not yet formally closed: since latest update (recovery moment)
    : unresolved?.incidents.length
      ? Math.max(...unresolved.incidents.map((i) => new Date(i.updated_at).getTime()))
    // Operational, all closed: since latest resolution
    : incidents.length
      ? Math.max(...incidents.filter((i) => i.resolved_at).map((i) => new Date(i.resolved_at!).getTime()), 0) || now
      : now;
  const durationMs = now - ongoingSince;
  const duration =
    durationMs < 3_600_000 ? `for ${Math.max(1, Math.round(durationMs / 60_000))} min`
    : durationMs < 86_400_000 ? `for ${Math.round(durationMs / 3_600_000)} hr`
    : `for ${Math.round(durationMs / 86_400_000)} days`;

  return { duration, indicator, label };
}

// –
// Heatmap
// –

/** Build the year-long heatmap grid from all stored incidents. */
export function heatmap() {
  const incidents = db.prepare(
    `SELECT * FROM incidents ORDER BY started_at DESC`,
  ).all() as Incident[];

  // Group by day
  const dayMap = new Map<string, { incidents: Incident[]; severity: number }>();

  for (const incident of incidents) {
    const dayKey = new Date(incident.started_at).toISOString().split("T")[0];
    if (!dayMap.has(dayKey)) {
      dayMap.set(dayKey, { severity: 0, incidents: [] });
    }

    const day = dayMap.get(dayKey)!;
    day.severity += impactWeights[incident.impact as Impact] || 1;
    day.incidents.push(incident);
  }

  // Generate last year of days (UTC throughout to match toISOString keys)
  const today = new Date();
  today.setUTCHours(0, 0, 0, 0);
  const oneYearAgo = new Date(today);
  oneYearAgo.setUTCFullYear(today.getUTCFullYear() - 1);

  const weeks: HeatmapDay[][] = [];
  let currentWeek: HeatmapDay[] = [];
  let currentDate = new Date(oneYearAgo);

  // Start on Sunday
  currentDate.setUTCDate(currentDate.getUTCDate() - currentDate.getUTCDay());

  while (currentDate <= today) {
    const dayKey = currentDate.toISOString().split("T")[0];
    const dayData = dayMap.get(dayKey);

    currentWeek.push({
      date: dayKey,
      severity: dayData?.severity || 0,
      count: dayData?.incidents.length || 0,
      incidents: dayData?.incidents || [],
    });

    if (currentWeek.length === 7) {
      weeks.push(currentWeek);
      currentWeek = [];
    }

    currentDate.setUTCDate(currentDate.getUTCDate() + 1);
  }

  if (currentWeek.length > 0) weeks.push(currentWeek);

  const maxSeverity = Math.max(
    ...Array.from(dayMap.values()).map((d) => d.severity),
    1,
  );

  return { dayMap, incidents, maxSeverity, weeks };
}