Inbox App

// Shared motion tokens. Easing curves mirror the CSS custom properties in
// globals.css; springs are the canonical physics used across components.
// Strong custom variants — defaults like `ease-in`/`ease-out` feel weak.

export const EASE_OUT = [0.16, 1, 0.3, 1] as const;
export const EASE_IN_OUT = [0.77, 0, 0.175, 1] as const;
export const EASE_DRAWER = [0.32, 0.72, 0, 1] as const;

/** CSS string form of EASE_OUT for inline style transitions. */
export const EASE_OUT_CSS = "cubic-bezier(0.16, 1, 0.3, 1)";

/** Press feedback on buttons and other tappable surfaces. */
export const SPRING_PRESS = {
  type: "spring",
  stiffness: 500,
  damping: 30,
  mass: 0.6,
} as const;

/** Content swaps — label/icon slots trading places inside a control. */
export const SPRING_SWAP = {
  type: "spring",
  stiffness: 460,
  damping: 30,
  mass: 0.55,
} as const;

/** Overlay panel entrances — modals and sheets summoned by pointer. */
export const SPRING_PANEL = {
  type: "spring",
  stiffness: 420,
  damping: 40,
  mass: 0.5,
} as const;

/** Shared-layout glides — pills, indicators and panels morphing between positions. */
export const SPRING_LAYOUT = {
  type: "spring",
  stiffness: 360,
  damping: 32,
  mass: 0.6,
} as const;

/** Cursor-follow physics for decorative mouse tracking (magnetic, tilt, dock). */
export const SPRING_MOUSE = {
  stiffness: 200,
  damping: 15,
  mass: 0.3,
} as const;

/** Dragged handles and fills (sliders) — critically damped `useSpring` config,
 * so the value follows the pointer butterily and never rebounds off an end. */
export const SPRING_GLIDE = {
  stiffness: 700,
  damping: 50,
  mass: 0.5,
} as const;

import { clsx, type ClassValue } from "clsx"
import { twMerge } from "tailwind-merge"

export function cn(...inputs: ClassValue[]) {
  return twMerge(clsx(inputs))
}

// Shared touch primitives. iOS and iPadOS run their own gestures on top of the
// page — the long-press selection callout and the selection it drags in with
// it — and they win: once the platform claims a touch it cancels ours
// mid-gesture, so a press-and-hold or a drag simply dies. Surfaces that own
// their gesture have to opt out.
//
// What the two classes below cover, precisely:
// - `-webkit-touch-callout: none` stops iOS's long-press callout. WebKit-only:
//   it is not a property other engines have, so it is inert everywhere else.
// - `user-select: none` stops the long-press selection on every engine,
//   Android included, and stops a drag from painting a selection under the
//   cursor. It is inherited, so it reaches every descendant — which is why the
//   two classes differ only in whether they apply it unconditionally.
// What neither covers:
// - Chrome for Android's long-press menu on a link or an image. No CSS
//   suppresses it; a gesture surface that wraps one needs its own
//   `onContextMenu` with `preventDefault()`.
// - The native drag of an `<img>` or `<a>` descendant. `-webkit-user-drag` is
//   not inherited and plain divs and buttons are not drag sources, so setting
//   it on the surface does nothing — the child itself needs `draggable={false}`.

/**
 * Classes for a surface that *is* the control: a thumb, a drum, a stage, a
 * handle, a hold button. Selection is suppressed on every input, because a
 * drag that highlights the control's own label is wrong on a mouse too.
 * Compose with `touch-none` when the surface also owns the scroll axis — leave
 * it off when the page must still scroll from there.
 */
export const TOUCH_GESTURE_CLASS = "select-none [-webkit-touch-callout:none]";

/**
 * The same opt-out for a gesture surface that wraps content the consumer owns:
 * a scroller, a context-menu trigger, a sheet header, a list row. Selection is
 * suppressed only where the platform runs its own press gestures — a coarse
 * pointer — so a mouse user can still select and copy that content. If the
 * gesture itself would paint a selection under the cursor, add `select-none`
 * for the duration of the gesture rather than reaching for
 * `TOUCH_GESTURE_CLASS`.
 *
 * `pointer: coarse` describes the *primary* pointer and nothing else, so a
 * hybrid machine reads it wrong in both directions: a tablet with a mouse
 * plugged in keeps touch as primary and loses mouse selection, and a laptop
 * with a touchscreen keeps the mouse as primary and leaves selection live
 * under a finger. No media query can answer per interaction — the query is
 * about the device, and the question is about the gesture in progress. The
 * default stays here because it is right on the machines that are one thing or
 * the other, and losing a selection is a nuisance; where the miss costs a
 * *gesture* instead, the surface pairs it with `holdSelection` on the press.
 */
export const TOUCH_GESTURE_CONTENT_CLASS =
  "[-webkit-touch-callout:none] pointer-coarse:select-none";

/**
 * Grow a small control's *hit area* to at least 44×44px (WCAG 2.5.5, Apple
 * HIG) on a coarse pointer, without changing what it looks like or the space
 * it takes in layout. An invisible `::after` box, centered on the control and
 * `max(100%, 2.75rem)` on each axis, catches the taps: a 32px icon button
 * reaches 6px past each edge, a wide 40px button only grows vertically, and a
 * control already 44px or larger is left as it is. Hit-testing a pseudo
 * element lands on its owner, so handlers, focus and `:active` all behave.
 *
 * Mouse and trackpad rendering is untouched — nothing here applies outside
 * `pointer: coarse`. Requirements on the element it goes on:
 * - It must be the containing block: add `relative` (and keep it mergeable, so
 *   a consumer's `absolute` still wins through `cn`).
 * - It must not clip itself (`overflow-hidden`), or the overhang is clipped
 *   away along with its hit area.
 * - It must render children: `<input>` and other void elements have no
 *   `::after`. Put it on the wrapper or label instead.
 * - It must not already use `::after` for something visible.
 *
 * Centered 44px means two 32px buttons with a 4px gap overlap by 8px; the
 * later one wins that strip, which still ends well short of the earlier
 * button's visual center. Below a ~32px pitch the later neighbour starts
 * eating into that center — use `TOUCH_TARGET_Y_CLASS` for such dense rows.
 *
 * The overhang is real geometry: inside a scroll container it counts as
 * scrollable overflow, so a control flush against a scroller's edge can add a
 * few pixels of scroll on touch screens. Give such a scroller a little padding
 * on that side.
 */
export const TOUCH_TARGET_CLASS =
  "pointer-coarse:after:absolute pointer-coarse:after:top-1/2 pointer-coarse:after:left-1/2 pointer-coarse:after:size-[max(100%,2.75rem)] pointer-coarse:after:-translate-x-1/2 pointer-coarse:after:-translate-y-1/2 pointer-coarse:after:content-['']";

/**
 * `TOUCH_TARGET_CLASS` on the vertical axis only, for controls packed tighter
 * than ~32px apart in a row (pagination dots, dense swatches), where growing
 * sideways would hand most of each control to its neighbour. Same rules.
 */
export const TOUCH_TARGET_Y_CLASS =
  "pointer-coarse:after:absolute pointer-coarse:after:inset-x-0 pointer-coarse:after:top-1/2 pointer-coarse:after:h-[max(100%,2.75rem)] pointer-coarse:after:-translate-y-1/2 pointer-coarse:after:content-['']";

/**
 * Suppress selection on `element` for as long as a gesture is running on it,
 * whatever the primary pointer of the machine happens to be. Returns the
 * release. Inline, so it wins over the class above and is gone again the
 * moment the gesture ends.
 *
 * For the press gestures a native selection would otherwise steal — a
 * long-press that opens a menu. Elsewhere prefer the classes: a surface that
 * takes selection away for the whole session is a surface whose text nobody
 * can copy.
 */
export function holdSelection(element: HTMLElement) {
  element.style.setProperty("user-select", "none");
  element.style.setProperty("-webkit-user-select", "none");
  return () => {
    element.style.removeProperty("user-select");
    element.style.removeProperty("-webkit-user-select");
  };
}

/**
 * Pointer capture, best effort. WebKit throws `NotFoundError` when the pointer
 * is already gone by the time the handler runs — routine on iOS, where the
 * system can claim the touch first — and an uncaught throw takes the rest of
 * the handler, the gesture included, down with it. Touch pointers carry
 * implicit capture anyway, so losing it is never fatal.
 */
export function capturePointer(element: Element, pointerId: number) {
  try {
    element.setPointerCapture(pointerId);
  } catch {
    // Pointer is no longer active — implicit capture still applies on touch.
  }
}

/** Release a capture taken with `capturePointer`, ignoring a stale pointer. */
export function releasePointer(element: Element, pointerId: number) {
  try {
    if (element.hasPointerCapture(pointerId)) {
      element.releasePointerCapture(pointerId);
    }
  } catch {
    // Capture was already dropped by the browser.
  }
}

/**
 * Whether this event came from a pointer that is *hovering*: not a touch, and
 * not currently pressed. Which input the user is holding right now is not
 * something a device capability can answer — a touchscreen laptop hovers and
 * taps, and iPadOS reports a fine hovering pointer for a finger — so both
 * paths stay live and each handler branches on the event it was given.
 *
 * A pen resting on the glass is making contact, not hovering: `buttons` is the
 * tell, and it sends a pen tap down the same route a finger takes.
 *
 * This answers what an *enter* asks. A leave is the other half of a pair and
 * has to be read against the enter that started it — `useHoverGesture` in
 * `lib/hooks/use-hover-gesture` does that, and hover surfaces should use it
 * rather than asking this question twice.
 */
export const isHoveringPointer = (event: {
  pointerType: string;
  buttons: number;
}) => event.pointerType !== "touch" && event.buttons === 0;

"use client";
// karaui.kamisama-v0.my.id/components/blocks/inbox-app

import {
  Archive,
  ArrowLeft,
  Inbox,
  MailOpen,
  Search,
  Star,
  Trash2,
  Undo2,
  X,
} from "lucide-react";
import {
  AnimatePresence,
  LayoutGroup,
  motion,
  type PanInfo,
  useMotionValue,
  useReducedMotion,
  useTransform,
} from "motion/react";
import {
  type ReactNode,
  useCallback,
  useEffect,
  useId,
  useMemo,
  useRef,
  useState,
} from "react";
import { Checkbox } from "@/components/motion/checkbox";
import { EASE_OUT, SPRING_LAYOUT } from "@/lib/ease";
import { cn } from "@/lib/utils";

export interface InboxFolder {
  id: string;
  label: string;
  icon?: ReactNode;
  /** Virtual folder (e.g. Starred): decides membership instead of `message.folder`. */
  filter?: (message: InboxMessage) => boolean;
}

function inFolder(message: InboxMessage, folder: InboxFolder) {
  return folder.filter ? folder.filter(message) : message.folder === folder.id;
}

export interface InboxMessage {
  id: string;
  folder: string;
  from: { name: string; email?: string };
  subject: string;
  /** One-line preview shown in the list. */
  preview: string;
  /** Full body for the reading pane. Strings keep their line breaks. */
  body?: ReactNode;
  /** ISO date string; formatted with `locale` + `timeZone`. */
  date: string;
  unread?: boolean;
  starred?: boolean;
}

export type InboxAction = "archive" | "delete";

export interface InboxAppProps {
  folders: InboxFolder[];
  /** Controlled messages. */
  messages?: InboxMessage[];
  /** Uncontrolled initial messages. */
  defaultMessages?: InboxMessage[];
  onMessagesChange?: (messages: InboxMessage[]) => void;
  /** Controlled open folder. */
  folder?: string;
  defaultFolder?: string;
  onFolderChange?: (folder: string) => void;
  /** Controlled open message id. */
  selectedId?: string | null;
  defaultSelectedId?: string | null;
  onSelectedChange?: (id: string | null) => void;
  /** Fires after archive/delete with the affected ids (before any undo). */
  onAction?: (action: InboxAction, ids: string[]) => void;
  /** Fires when an archive/delete is undone. */
  onUndo?: (action: InboxAction, ids: string[]) => void;
  /** Folder that archived mail moves to. Default "archive". */
  archiveFolder?: string;
  /** Folder that deleted mail moves to; deleting inside it removes for good. Default "trash". */
  trashFolder?: string;
  /** How long the undo bar stays, in ms. Default 5000. */
  undoTimeout?: number;
  /** Default "en-US" so server and client agree. */
  locale?: string;
  /** Default "UTC" so server and client agree. */
  timeZone?: string;
  className?: string;
}

// Past this drag distance (px) a row commits to archive (right) or delete (left).
const SWIPE_COMMIT = 96;

function useControllable<T>(
  value: T | undefined,
  defaultValue: T,
  onChange: ((next: T) => void) | undefined,
) {
  const [internal, setInternal] = useState(defaultValue);
  const controlled = value !== undefined;
  const current = controlled ? value : internal;
  const set = useCallback(
    (next: T) => {
      if (!controlled) setInternal(next);
      onChange?.(next);
    },
    [controlled, onChange],
  );
  return [current, set] as const;
}

type UndoState = {
  key: number;
  action: InboxAction;
  ids: string[];
  previous: InboxMessage[];
};

/**
 * Mail client block: folder rail with unread counts, a searchable message
 * list (unread dots, stars, checkboxes, gliding selection) and a reading pane
 * that cross-fades between messages. Rows swipe right to archive and left to
 * delete (or use the toolbar), slide out, and an undo bar restores them.
 */
export function InboxApp({
  folders,
  messages: messagesProp,
  defaultMessages = [],
  onMessagesChange,
  folder: folderProp,
  defaultFolder,
  onFolderChange,
  selectedId: selectedProp,
  defaultSelectedId = null,
  onSelectedChange,
  onAction,
  onUndo,
  archiveFolder = "archive",
  trashFolder = "trash",
  undoTimeout = 5000,
  locale = "en-US",
  timeZone = "UTC",
  className,
}: InboxAppProps) {
  const reduce = useReducedMotion();
  const baseId = useId();
  const [messages, setMessages] = useControllable(
    messagesProp,
    defaultMessages,
    onMessagesChange,
  );
  const [folder, setFolder] = useControllable(
    folderProp,
    defaultFolder ?? folders[0]?.id ?? "",
    onFolderChange,
  );
  const [selectedId, setSelectedId] = useControllable<string | null>(
    selectedProp,
    defaultSelectedId,
    onSelectedChange,
  );
  const [query, setQuery] = useState("");
  const [checked, setChecked] = useState<Set<string>>(() => new Set());
  const [exitDir, setExitDir] = useState<1 | -1>(1);
  const [undo, setUndo] = useState<UndoState | null>(null);
  // Narrow containers show either the list or the reader.
  const [reading, setReading] = useState(false);
  const undoKey = useRef(0);

  const dateFormat = useMemo(
    () => new Intl.DateTimeFormat(locale, { month: "short", day: "numeric", timeZone }),
    [locale, timeZone],
  );
  const fullDateFormat = useMemo(
    () =>
      new Intl.DateTimeFormat(locale, {
        dateStyle: "medium",
        timeStyle: "short",
        timeZone,
      }),
    [locale, timeZone],
  );

  const activeFolder = folders.find((f) => f.id === folder);

  const unreadByFolder = useMemo(() => {
    const counts: Record<string, number> = {};
    for (const f of folders) {
      counts[f.id] = messages.filter((m) => m.unread && inFolder(m, f)).length;
    }
    return counts;
  }, [messages, folders]);

  const visible = useMemo(() => {
    const q = query.trim().toLowerCase();
    return messages
      .filter((m) => (activeFolder ? inFolder(m, activeFolder) : m.folder === folder))
      .filter(
        (m) =>
          !q ||
          m.subject.toLowerCase().includes(q) ||
          m.from.name.toLowerCase().includes(q) ||
          m.preview.toLowerCase().includes(q),
      )
      .sort((a, b) => (a.date < b.date ? 1 : a.date > b.date ? -1 : 0));
  }, [messages, folder, query, activeFolder]);

  const selected = visible.find((m) => m.id === selectedId) ?? null;

  // Undo bar auto-dismisses; a new action restarts the timer via its key.
  useEffect(() => {
    if (!undo) return;
    const timer = window.setTimeout(() => setUndo(null), undoTimeout);
    return () => window.clearTimeout(timer);
  }, [undo, undoTimeout]);

  const patch = useCallback(
    (ids: string[], change: Partial<InboxMessage>) => {
      const set = new Set(ids);
      setMessages(messages.map((m) => (set.has(m.id) ? { ...m, ...change } : m)));
    },
    [messages, setMessages],
  );

  const open = (id: string) => {
    setSelectedId(id);
    setReading(true);
    const target = messages.find((m) => m.id === id);
    if (target?.unread) patch([id], { unread: false });
  };

  const run = (action: InboxAction, ids: string[]) => {
    if (ids.length === 0) return;
    const set = new Set(ids);
    const destination = action === "archive" ? archiveFolder : trashFolder;
    const permanent = action === "delete" && folder === trashFolder;
    const next = permanent
      ? messages.filter((m) => !set.has(m.id))
      : messages.map((m) => (set.has(m.id) ? { ...m, folder: destination } : m));
    // Archive slides right, delete slides left — matching the swipe directions.
    setExitDir(action === "archive" ? 1 : -1);
    setMessages(next);
    setChecked((prev) => {
      const copy = new Set(prev);
      for (const id of ids) copy.delete(id);
      return copy;
    });
    if (selectedId && set.has(selectedId)) {
      // Move the reader to the next message left in the list, if any.
      const order = visible.map((m) => m.id);
      const at = order.indexOf(selectedId);
      const remaining = order.filter((id) => !set.has(id));
      setSelectedId(remaining[Math.min(at, remaining.length - 1)] ?? null);
      if (remaining.length === 0) setReading(false);
    }
    undoKey.current += 1;
    setUndo({ key: undoKey.current, action, ids, previous: messages });
    onAction?.(action, ids);
  };

  const restore = () => {
    if (!undo) return;
    setExitDir(undo.action === "archive" ? 1 : -1);
    setMessages(undo.previous);
    onUndo?.(undo.action, undo.ids);
    setUndo(null);
  };

  const checkedIds = visible.filter((m) => checked.has(m.id)).map((m) => m.id);
  const allChecked = visible.length > 0 && checkedIds.length === visible.length;

  const toggleChecked = (id: string) =>
    setChecked((prev) => {
      const copy = new Set(prev);
      if (copy.has(id)) copy.delete(id);
      else copy.add(id);
      return copy;
    });

  const switchFolder = (id: string) => {
    setFolder(id);
    setChecked(new Set());
    setSelectedId(null);
    setReading(false);
  };

  const fade = { duration: 0.2, ease: EASE_OUT };

  return (
    <div
      className={cn(
        "@container relative flex h-[26rem] w-full overflow-hidden rounded-2xl border border-border bg-card text-card-foreground shadow-sm",
        className,
      )}
    >
      {/* Folder rail */}
      <nav
        aria-label="Mail folders"
        className="hidden w-36 shrink-0 flex-col gap-0.5 border-r border-border bg-muted/40 p-2 @lg:flex"
      >
        <LayoutGroup id={`${baseId}-folders`}>
          {folders.map((f) => {
            const active = f.id === folder;
            const count = unreadByFolder[f.id] ?? 0;
            return (
              <button
                key={f.id}
                type="button"
                aria-current={active ? "page" : undefined}
                onClick={() => switchFolder(f.id)}
                className={cn(
                  "relative flex h-8 items-center gap-2 rounded-lg px-2 text-left text-xs font-medium outline-none transition-colors focus-visible:ring-2 focus-visible:ring-primary",
                  active ? "text-foreground" : "text-muted-foreground hover:text-foreground",
                )}
              >
                {active ? (
                  <motion.span
                    layoutId="folder-pill"
                    transition={reduce ? { duration: 0 } : SPRING_LAYOUT}
                    className="absolute inset-0 rounded-lg border border-border bg-background shadow-sm"
                  />
                ) : null}
                <span className="relative shrink-0 [&_svg]:size-3.5">
                  {f.icon ?? <Inbox aria-hidden />}
                </span>
                <span className="relative min-w-0 flex-1 truncate">{f.label}</span>
                {count > 0 ? (
                  <span className="relative tabular-nums text-[10px] text-muted-foreground">
                    {count}
                    <span className="sr-only"> unread</span>
                  </span>
                ) : null}
              </button>
            );
          })}
        </LayoutGroup>
      </nav>

      {/* Message list */}
      <section
        aria-label="Messages"
        className={cn(
          "flex min-w-0 flex-1 flex-col border-r border-border @xl:w-60 @xl:flex-none",
          reading ? "hidden @xl:flex" : "flex",
        )}
      >
        <div className="flex flex-col gap-2 border-b border-border p-2">
          {/* Narrow containers swap the folder rail for a select. */}
          <select
            aria-label="Folder"
            value={folder}
            onChange={(e) => switchFolder(e.target.value)}
            className="h-8 rounded-lg border border-border bg-background px-2 text-xs @lg:hidden"
          >
            {folders.map((f) => (
              <option key={f.id} value={f.id}>
                {f.label}
                {unreadByFolder[f.id] ? ` (${unreadByFolder[f.id]})` : ""}
              </option>
            ))}
          </select>
          <label className="flex h-8 items-center gap-2 rounded-lg border border-border bg-background px-2 text-xs focus-within:ring-2 focus-within:ring-primary">
            <Search aria-hidden className="size-3.5 shrink-0 text-muted-foreground" />
            <span className="sr-only">Search mail</span>
            <input
              type="search"
              value={query}
              onChange={(e) => setQuery(e.target.value)}
              placeholder="Search mail"
              className="min-w-0 flex-1 bg-transparent outline-none placeholder:text-muted-foreground [&::-webkit-search-cancel-button]:hidden"
            />
            {query ? (
              <button
                type="button"
                aria-label="Clear search"
                onClick={() => setQuery("")}
                className="rounded text-muted-foreground hover:text-foreground"
              >
                <X aria-hidden className="size-3.5" />
              </button>
            ) : null}
          </label>
          <div className="flex h-6 items-center gap-2 px-1">
            <Checkbox
              aria-label={allChecked ? "Deselect all" : "Select all"}
              checked={allChecked}
              indeterminate={checkedIds.length > 0 && !allChecked}
              onCheckedChange={() =>
                setChecked(allChecked ? new Set() : new Set(visible.map((m) => m.id)))
              }
              className="[&>button]:size-4"
            />
            <AnimatePresence initial={false} mode="popLayout">
              {checkedIds.length > 0 ? (
                <motion.div
                  key="bulk"
                  initial={{ opacity: 0, x: reduce ? 0 : -6 }}
                  animate={{ opacity: 1, x: 0 }}
                  exit={{ opacity: 0, x: reduce ? 0 : -6 }}
                  transition={fade}
                  className="flex flex-1 items-center gap-1 text-xs"
                >
                  <span className="mr-auto tabular-nums text-muted-foreground">
                    {checkedIds.length} selected
                  </span>
                  <IconButton label="Archive selected" onClick={() => run("archive", checkedIds)}>
                    <Archive aria-hidden />
                  </IconButton>
                  <IconButton label="Delete selected" onClick={() => run("delete", checkedIds)}>
                    <Trash2 aria-hidden />
                  </IconButton>
                </motion.div>
              ) : (
                <motion.span
                  key="count"
                  initial={{ opacity: 0 }}
                  animate={{ opacity: 1 }}
                  exit={{ opacity: 0 }}
                  transition={fade}
                  className="text-xs text-muted-foreground"
                >
                  {visible.length} {visible.length === 1 ? "conversation" : "conversations"}
                </motion.span>
              )}
            </AnimatePresence>
          </div>
        </div>

        <ul
          aria-label="Message list"
          className="relative flex-1 overflow-y-auto overflow-x-hidden p-1 [scrollbar-color:var(--border-strong)_transparent] [scrollbar-width:thin]"
        >
          <LayoutGroup id={`${baseId}-rows`}>
            <AnimatePresence initial={false} mode="popLayout" custom={exitDir}>
              {visible.map((m) => (
                <MessageRow
                  key={m.id}
                  message={m}
                  active={m.id === selected?.id}
                  checked={checked.has(m.id)}
                  date={dateFormat.format(new Date(m.date))}
                  reduce={Boolean(reduce)}
                  onOpen={() => open(m.id)}
                  onCheck={() => toggleChecked(m.id)}
                  onStar={() => patch([m.id], { starred: !m.starred })}
                  onSwipe={(action) => run(action, [m.id])}
                />
              ))}
            </AnimatePresence>
          </LayoutGroup>
          {visible.length === 0 ? (
            <li className="flex h-full flex-col items-center justify-center gap-1 px-4 py-10 text-center text-xs text-muted-foreground">
              <MailOpen aria-hidden className="size-5" />
              {query ? `No mail matches “${query}”` : "Nothing here"}
            </li>
          ) : null}
        </ul>
      </section>

      {/* Reading pane */}
      <section
        aria-label="Reading pane"
        className={cn(
          "relative min-w-0 flex-1 flex-col",
          reading ? "flex" : "hidden @xl:flex",
        )}
      >
        <AnimatePresence initial={false} mode="wait">
          {selected ? (
            <motion.article
              key={selected.id}
              initial={{ opacity: 0, y: reduce ? 0 : 8 }}
              animate={{ opacity: 1, y: 0 }}
              exit={{ opacity: 0, y: reduce ? 0 : -4, transition: { duration: 0.12 } }}
              transition={fade}
              className="flex min-h-0 flex-1 flex-col"
            >
              <div className="flex items-center gap-1 border-b border-border p-2">
                <IconButton
                  label="Back to list"
                  onClick={() => setReading(false)}
                  className="@xl:hidden"
                >
                  <ArrowLeft aria-hidden />
                </IconButton>
                <IconButton label="Archive" onClick={() => run("archive", [selected.id])}>
                  <Archive aria-hidden />
                </IconButton>
                <IconButton label="Delete" onClick={() => run("delete", [selected.id])}>
                  <Trash2 aria-hidden />
                </IconButton>
                <IconButton
                  label="Mark as unread"
                  onClick={() => {
                    patch([selected.id], { unread: true });
                    setSelectedId(null);
                    setReading(false);
                  }}
                >
                  <MailOpen aria-hidden />
                </IconButton>
                <IconButton
                  label={selected.starred ? "Unstar" : "Star"}
                  pressed={Boolean(selected.starred)}
                  onClick={() => patch([selected.id], { starred: !selected.starred })}
                  className="ml-auto"
                >
                  <Star aria-hidden className={cn(selected.starred && "fill-current text-chart-4")} />
                </IconButton>
              </div>
              <div className="min-h-0 flex-1 overflow-y-auto p-4 [scrollbar-color:var(--border-strong)_transparent] [scrollbar-width:thin]">
                <h2 className="text-base font-semibold leading-snug">{selected.subject}</h2>
                <div className="mt-3 flex items-center gap-2.5">
                  <Initials name={selected.from.name} />
                  <div className="min-w-0 flex-1 text-xs">
                    <p className="truncate font-medium">{selected.from.name}</p>
                    {selected.from.email ? (
                      <p className="truncate text-muted-foreground">{selected.from.email}</p>
                    ) : null}
                  </div>
                  <time dateTime={selected.date} className="shrink-0 text-[11px] text-muted-foreground">
                    {fullDateFormat.format(new Date(selected.date))}
                  </time>
                </div>
                <div className="mt-4 whitespace-pre-line text-sm leading-relaxed text-foreground/90">
                  {selected.body ?? selected.preview}
                </div>
              </div>
            </motion.article>
          ) : (
            <motion.div
              key="empty"
              initial={{ opacity: 0 }}
              animate={{ opacity: 1 }}
              exit={{ opacity: 0 }}
              transition={fade}
              className="flex flex-1 flex-col items-center justify-center gap-2 text-xs text-muted-foreground"
            >
              <span className="grid size-10 place-items-center rounded-full bg-muted">
                <MailOpen aria-hidden className="size-4" />
              </span>
              Select a message to read
            </motion.div>
          )}
        </AnimatePresence>
      </section>

      {/* Undo bar */}
      <div aria-live="polite" className="pointer-events-none absolute inset-x-0 bottom-3 flex justify-center">
        <AnimatePresence>
          {undo ? (
            <motion.div
              key={undo.key}
              initial={{ opacity: 0, y: reduce ? 0 : 16, scale: reduce ? 1 : 0.96 }}
              animate={{ opacity: 1, y: 0, scale: 1 }}
              exit={{ opacity: 0, y: reduce ? 0 : 8, transition: { duration: 0.15 } }}
              transition={SPRING_LAYOUT}
              className="pointer-events-auto flex items-center gap-3 rounded-full bg-foreground py-1.5 pl-4 pr-1.5 text-xs text-background shadow-lg"
            >
              <span>
                {undo.ids.length === 1 ? "Conversation" : `${undo.ids.length} conversations`}{" "}
                {undo.action === "archive" ? "archived" : "deleted"}
              </span>
              <button
                type="button"
                onClick={restore}
                className="inline-flex h-7 items-center gap-1 rounded-full bg-background/15 px-2.5 font-medium outline-none hover:bg-background/25 focus-visible:ring-2 focus-visible:ring-background"
              >
                <Undo2 aria-hidden className="size-3.5" />
                Undo
              </button>
            </motion.div>
          ) : null}
        </AnimatePresence>
      </div>
    </div>
  );
}

function MessageRow({
  message,
  active,
  checked,
  date,
  reduce,
  onOpen,
  onCheck,
  onStar,
  onSwipe,
}: {
  message: InboxMessage;
  active: boolean;
  checked: boolean;
  date: string;
  reduce: boolean;
  onOpen: () => void;
  onCheck: () => void;
  onStar: () => void;
  onSwipe: (action: InboxAction) => void;
}) {
  const x = useMotionValue(0);
  const archiveOpacity = useTransform(x, [0, SWIPE_COMMIT], [0, 1]);
  const deleteOpacity = useTransform(x, [-SWIPE_COMMIT, 0], [1, 0]);

  const onDragEnd = (_: unknown, info: PanInfo) => {
    if (info.offset.x > SWIPE_COMMIT) onSwipe("archive");
    else if (info.offset.x < -SWIPE_COMMIT) onSwipe("delete");
  };

  return (
    <motion.li
      layout={reduce ? false : "position"}
      variants={{
        exit: (dir: number) => ({
          opacity: 0,
          x: reduce ? 0 : `${dir * 100}%`,
          transition: { duration: 0.22, ease: EASE_OUT },
        }),
      }}
      initial={{ opacity: 0 }}
      animate={{ opacity: 1 }}
      exit="exit"
      transition={SPRING_LAYOUT}
      className="relative mb-0.5 overflow-hidden rounded-lg"
    >
      {/* Swipe hints behind the row */}
      <motion.span
        aria-hidden
        style={{ opacity: archiveOpacity }}
        className="absolute inset-0 flex items-center rounded-lg bg-chart-2/20 pl-3 text-foreground"
      >
        <Archive className="size-4" />
      </motion.span>
      <motion.span
        aria-hidden
        style={{ opacity: deleteOpacity }}
        className="absolute inset-0 flex items-center justify-end rounded-lg bg-destructive/20 pr-3 text-destructive"
      >
        <Trash2 className="size-4" />
      </motion.span>

      <motion.div
        drag="x"
        dragConstraints={{ left: 0, right: 0 }}
        dragElastic={0.5}
        dragSnapToOrigin
        onDragEnd={onDragEnd}
        style={{ x }}
        className="relative flex cursor-grab items-start gap-2 rounded-lg bg-card px-2 py-2 active:cursor-grabbing"
      >
        {active ? (
          <motion.span
            layoutId="row-highlight"
            transition={reduce ? { duration: 0 } : SPRING_LAYOUT}
            className="absolute inset-0 rounded-lg bg-primary/10 ring-1 ring-primary/30"
          />
        ) : checked ? (
          <span className="absolute inset-0 rounded-lg bg-muted" />
        ) : null}
        <div className="relative mt-0.5 flex flex-col items-center gap-1.5">
          <Checkbox
            aria-label={`Select ${message.subject}`}
            checked={checked}
            onCheckedChange={onCheck}
            className="[&>button]:size-4"
          />
          <button
            type="button"
            aria-label={message.starred ? "Unstar" : "Star"}
            aria-pressed={Boolean(message.starred)}
            onClick={onStar}
            className="rounded text-muted-foreground outline-none hover:text-foreground focus-visible:ring-2 focus-visible:ring-primary"
          >
            <motion.span
              key={message.starred ? "on" : "off"}
              initial={reduce ? false : { scale: 0.6 }}
              animate={{ scale: 1 }}
              transition={SPRING_LAYOUT}
              className="block"
            >
              <Star
                aria-hidden
                className={cn("size-3.5", message.starred && "fill-current text-chart-4")}
              />
            </motion.span>
          </button>
        </div>
        <button
          type="button"
          onClick={onOpen}
          aria-current={active ? "true" : undefined}
          className="relative min-w-0 flex-1 rounded text-left outline-none focus-visible:ring-2 focus-visible:ring-primary"
        >
          <span className="flex items-center gap-1.5">
            <AnimatePresence initial={false}>
              {message.unread ? (
                <motion.span
                  key="dot"
                  initial={{ scale: reduce ? 1 : 0, opacity: 0 }}
                  animate={{ scale: 1, opacity: 1 }}
                  exit={{ scale: reduce ? 1 : 0, opacity: 0 }}
                  transition={SPRING_LAYOUT}
                  className="size-1.5 shrink-0 rounded-full bg-primary"
                />
              ) : null}
            </AnimatePresence>
            {message.unread ? <span className="sr-only">Unread. </span> : null}
            <span
              className={cn(
                "min-w-0 flex-1 truncate text-xs",
                message.unread ? "font-semibold" : "font-medium text-foreground/80",
              )}
            >
              {message.from.name}
            </span>
            <time dateTime={message.date} className="shrink-0 text-[10px] text-muted-foreground">
              {date}
            </time>
          </span>
          <span
            className={cn(
              "mt-0.5 block truncate text-xs",
              message.unread ? "font-medium text-foreground" : "text-foreground/80",
            )}
          >
            {message.subject}
          </span>
          <span className="block truncate text-[11px] text-muted-foreground">
            {message.preview}
          </span>
        </button>
      </motion.div>
    </motion.li>
  );
}

function IconButton({
  label,
  onClick,
  children,
  pressed,
  className,
}: {
  label: string;
  onClick: () => void;
  children: ReactNode;
  pressed?: boolean;
  className?: string;
}) {
  return (
    <button
      type="button"
      aria-label={label}
      title={label}
      aria-pressed={pressed}
      onClick={onClick}
      className={cn(
        "grid size-7 place-items-center rounded-md text-muted-foreground outline-none transition-colors hover:bg-muted hover:text-foreground focus-visible:ring-2 focus-visible:ring-primary [&_svg]:size-3.5",
        className,
      )}
    >
      {children}
    </button>
  );
}

function Initials({ name }: { name: string }) {
  const letters = name
    .split(/\s+/)
    .filter(Boolean)
    .slice(0, 2)
    .map((part) => part[0]?.toUpperCase())
    .join("");
  return (
    <span
      aria-hidden
      className="grid size-8 shrink-0 place-items-center rounded-full bg-primary/15 text-[11px] font-semibold text-foreground"
    >
      {letters}
    </span>
  );
}

"use client";

import { AnimatePresence, motion, useReducedMotion } from "motion/react";
import { useId } from "react";
import { EASE_OUT, SPRING_PRESS } from "@/lib/ease";
import { TOUCH_TARGET_CLASS } from "@/lib/touch";
import { cn } from "@/lib/utils";

const CHECK_PATH = "M5 13l4 4L19 7";
const INDETERMINATE_PATH = "M6 12h12";

export interface CheckboxProps {
  checked: boolean;
  onCheckedChange: (checked: boolean) => void;
  disabled?: boolean;
  indeterminate?: boolean;
  label?: string;
  className?: string;
  id?: string;
  "aria-label"?: string;
  /** Associates an external message (e.g. a form error) with the control. */
  "aria-describedby"?: string;
}

export function Checkbox({
  checked,
  onCheckedChange,
  disabled,
  indeterminate,
  label,
  className,
  id: idProp,
  "aria-label": ariaLabel,
  "aria-describedby": ariaDescribedBy,
}: CheckboxProps) {
  const autoId = useId();
  const id = idProp ?? autoId;
  const reduce = useReducedMotion();
  const showMark = checked || indeterminate;
  const path = indeterminate ? INDETERMINATE_PATH : CHECK_PATH;

  return (
    <label
      htmlFor={id}
      className={cn(
        "inline-flex items-center gap-3",
        disabled ? "cursor-not-allowed" : "cursor-pointer",
        className,
      )}
    >
      <motion.button
        id={id}
        type="button"
        role="checkbox"
        aria-checked={indeterminate ? "mixed" : checked}
        aria-label={ariaLabel}
        aria-describedby={ariaDescribedBy}
        disabled={disabled}
        onClick={() => !disabled && onCheckedChange(!checked)}
        whileTap={reduce || disabled ? undefined : { scale: 0.92 }}
        transition={SPRING_PRESS}
        data-state={
          checked ? "checked" : indeterminate ? "indeterminate" : "unchecked"
        }
        className={cn(
          "relative inline-flex h-5 w-5 shrink-0 items-center justify-center rounded-md border-2 outline-none transition-colors duration-200",
          TOUCH_TARGET_CLASS,
          "focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background",
          "disabled:cursor-not-allowed disabled:opacity-60",
          showMark
            ? "border-primary bg-primary text-primary-foreground"
            : "border-muted-foreground/50 bg-background hover:border-muted-foreground",
        )}
      >
        <AnimatePresence initial={false}>
          {showMark ? (
            <motion.svg
              key={indeterminate ? "indeterminate" : "checked"}
              width="12"
              height="12"
              viewBox="0 0 24 24"
              fill="none"
              stroke="currentColor"
              strokeWidth={3}
              strokeLinecap="round"
              strokeLinejoin="round"
              initial={reduce ? { opacity: 1 } : { opacity: 0, scale: 0.5 }}
              animate={reduce ? { opacity: 1 } : { opacity: 1, scale: 1 }}
              exit={
                reduce
                  ? { opacity: 0 }
                  : { opacity: 0, scale: 0.5, filter: "blur(4px)" }
              }
              transition={
                reduce ? { duration: 0 } : { duration: 0.16, ease: EASE_OUT }
              }
              aria-hidden
            >
              <title>{indeterminate ? "Partially selected" : "Selected"}</title>
              <motion.path
                d={path}
                initial={reduce ? { pathLength: 1 } : { pathLength: 0 }}
                animate={{ pathLength: 1 }}
                transition={
                  reduce
                    ? { duration: 0 }
                    : {
                        duration: indeterminate ? 0.2 : 0.3,
                        ease: EASE_OUT,
                        delay: 0.04,
                      }
                }
              />
            </motion.svg>
          ) : null}
        </AnimatePresence>
      </motion.button>
      {label ? (
        <span className={cn("select-none text-sm text-foreground", disabled && "opacity-60")}>
          {label}
        </span>
      ) : null}
    </label>
  );
}