Incident Timeline

"use client";

import * as React from "react";
import { motion, useReducedMotion } from "motion/react";
import { Badge } from "@/registry/paragon/ui/badge";
import { cn } from "@/lib/utils";

export type IncidentSeverity = "sev1" | "sev2" | "sev3";
export type IncidentPhase =
  | "investigating"
  | "identified"
  | "monitoring"
  | "resolved";

export interface IncidentUpdate {
  phase: IncidentPhase;
  /** Timestamp label. */
  time: string;
  body: string;
}

export interface IncidentTimelineProps
  extends Omit<React.ComponentProps<"div">, "title"> {
  title?: string;
  severity?: IncidentSeverity;
  /** Ordered updates, one per phase reached. */
  updates?: IncidentUpdate[];
}

const PHASES: IncidentPhase[] = [
  "investigating",
  "identified",
  "monitoring",
  "resolved",
];

const phaseLabel: Record<IncidentPhase, string> = {
  investigating: "Investigating",
  identified: "Identified",
  monitoring: "Monitoring",
  resolved: "Resolved",
};

const phaseTint: Record<
  IncidentPhase,
  { dot: string; badge: React.ComponentProps<typeof Badge>["variant"] }
> = {
  investigating: { dot: "bg-destructive", badge: "destructive" },
  identified: { dot: "bg-warning", badge: "warning" },
  monitoring: { dot: "bg-primary", badge: "default" },
  resolved: { dot: "bg-success", badge: "success" },
};

const sevVariant: Record<
  IncidentSeverity,
  React.ComponentProps<typeof Badge>["variant"]
> = {
  sev1: "destructive",
  sev2: "warning",
  sev3: "default",
};

const sevLabel: Record<IncidentSeverity, string> = {
  sev1: "SEV-1",
  sev2: "SEV-2",
  sev3: "SEV-3",
};

const DEFAULT_UPDATES: IncidentUpdate[] = [
  {
    phase: "investigating",
    time: "14:02 UTC",
    body: "Elevated 5xx rates on the checkout API. Engineering is investigating.",
  },
  {
    phase: "identified",
    time: "14:19 UTC",
    body: "Root cause identified as a saturated connection pool in us-east-1.",
  },
  {
    phase: "monitoring",
    time: "14:41 UTC",
    body: "Pool limits raised and traffic rebalanced. Monitoring recovery.",
  },
  {
    phase: "resolved",
    time: "15:07 UTC",
    body: "Error rates back to baseline for 20 minutes. Incident resolved.",
  },
];

/**
 * A live incident timeline. The header status badge advances through
 * Investigating → Identified → Monitoring → Resolved, blur-crossfading between
 * phases (the badge already crossfades on variant change; the phase label
 * crossfades in step). Each posted update drops into the list on mount with the
 * house enter. The current phase is derived from the latest update, so driving
 * it is just appending. Reduced motion swaps phases in place.
 */
export function IncidentTimeline({
  title = "Elevated checkout error rates",
  severity = "sev1",
  updates = DEFAULT_UPDATES,
  className,
  ...props
}: IncidentTimelineProps) {
  const reduced = useReducedMotion();
  const current = updates[updates.length - 1]?.phase ?? "investigating";
  const tint = phaseTint[current];
  const currentIndex = PHASES.indexOf(current);

  return (
    <div
      data-slot="incident-timeline"
      className={cn(
        "w-full max-w-md rounded-xl bg-card p-5 text-card-foreground shadow-border",
        className,
      )}
      {...props}
    >
      <div className="flex items-start justify-between gap-3">
        <div className="min-w-0">
          <div className="mb-1.5 flex items-center gap-2">
            <Badge variant={sevVariant[severity]} dot>
              {sevLabel[severity]}
            </Badge>
            <span aria-live="polite" className="inline-flex">
              <Badge variant={tint.badge}>{phaseLabel[current]}</Badge>
            </span>
          </div>
          <h3 className="text-sm font-semibold text-balance">{title}</h3>
        </div>
      </div>

      {/* Phase rail — segments fill as the incident advances. */}
      <div className="mt-4 flex items-center gap-1.5" aria-hidden>
        {PHASES.map((phase, i) => (
          <div
            key={phase}
            className={cn(
              "h-1 flex-1 rounded-full transition-colors duration-(--duration-base)",
              i <= currentIndex ? phaseTint[phase].dot : "bg-border",
            )}
          />
        ))}
      </div>

      <ol className="mt-4 space-y-0">
        {updates.map((update, i) => {
          const utint = phaseTint[update.phase];
          const isLast = i === updates.length - 1;
          const inner = (
            <>
              {/* Connector line + dot. */}
              <div className="relative flex flex-col items-center">
                <span
                  className={cn(
                    "mt-0.5 size-2.5 shrink-0 rounded-full ring-4 ring-card",
                    utint.dot,
                  )}
                />
                {!isLast && (
                  <span className="mt-0.5 w-px flex-1 bg-border" aria-hidden />
                )}
              </div>
              <div className="min-w-0 flex-1 pb-1">
                <div className="flex items-baseline justify-between gap-2">
                  <span className="text-[13px] font-medium">
                    {phaseLabel[update.phase]}
                  </span>
                  <span className="shrink-0 text-[11px] text-muted-foreground tabular-nums">
                    {update.time}
                  </span>
                </div>
                <p className="mt-0.5 text-xs text-muted-foreground text-pretty">
                  {update.body}
                </p>
              </div>
            </>
          );

          const cls = "relative flex gap-3 pb-4 last:pb-0";
          if (reduced)
            return (
              <li key={update.phase} className={cls}>
                {inner}
              </li>
            );
          return (
            <motion.li
              key={update.phase}
              className={cls}
              initial={{ opacity: 0, y: 12, filter: "blur(4px)" }}
              animate={{ opacity: 1, y: 0, filter: "blur(0px)" }}
              transition={{
                duration: 0.3,
                ease: [0.22, 1, 0.36, 1],
                delay: i * 0.05,
              }}
            >
              {inner}
            </motion.li>
          );
        })}
      </ol>
    </div>
  );
}