import { useCallback, useLayoutEffect, useMemo, useRef, useState } from "react";

import type { OrchestrationThreadActivity } from "@t3tools/contracts";

import { liveWindowOldestActivityId, oldestActivityByChronology } from "./threadReducer.ts";

const EMPTY_ACTIVITIES: ReadonlyArray<OrchestrationThreadActivity> = [];

/**
 * Pagination cursor for a thread's older activities. Sequenced rows page by
 * `beforeSequence`; legacy/unsequenced rows (the common case — `sequence` is
 * absent on most real rows) page by the `(createdAt, activityId)` keyset.
 */
export type OlderActivitiesCursor =
  | { readonly beforeSequence: number }
  | {
      readonly beforeCreatedAt: OrchestrationThreadActivity["createdAt"];
      readonly beforeActivityId: OrchestrationThreadActivity["id"];
    };

export interface OlderActivitiesPage {
  readonly activities: ReadonlyArray<OrchestrationThreadActivity>;
  readonly hasMore: boolean;
}

export interface UseOlderThreadActivitiesOptions {
  /**
   * Identity of the thread the live window belongs to (e.g.
   * `${environmentId}\0${threadId}`); null when no thread is selected.
   * Changing it resets the lazy-loaded pages.
   */
  readonly threadKey: string | null;
  /** The server-windowed live activity set from the thread detail. */
  readonly liveActivities: ReadonlyArray<OrchestrationThreadActivity>;
  /** The server's `hasMoreActivities` flag from the detail snapshot. */
  readonly hasMoreLiveActivities: boolean;
  /**
   * Fetch the page immediately older than the cursor. Resolve `null` to skip
   * the page silently (a failure the caller already surfaced, or an
   * interrupted command) — `hasMore` is left true so the user can retry.
   * MUST be referentially stable (useCallback) for the load callback to be.
   */
  readonly loadPage: (cursor: OlderActivitiesCursor) => Promise<OlderActivitiesPage | null>;
}

export interface UseOlderThreadActivitiesResult {
  /** Lazy-loaded older pages + the live window, oldest first. */
  readonly mergedActivities: ReadonlyArray<OrchestrationThreadActivity>;
  /** Whether older history exists beyond everything loaded. */
  readonly hasMoreOlder: boolean;
  readonly loadingOlder: boolean;
  /** Dispatch a load of the next older page (no-op while one is in flight). */
  readonly loadOlder: () => void;
}

// ── Pure decision kernel (exported for unit tests) ──────────────────────────

export interface LiveWindowShape {
  readonly key: string | null;
  /** Chronological-oldest activity id (an identity sentinel, not a lookup key). */
  readonly oldest: string | null;
  readonly count: number;
}

/**
 * Whether the live window was RESHAPED rather than purely appended-to: a
 * different thread, a re-snapshot (reconnect) that changes the window's
 * chronological-oldest row, or a checkpoint revert that shrinks it. A pure
 * append (same thread, same oldest, count not smaller) is NOT a reshape.
 */
export function didLiveWindowReshape(previous: LiveWindowShape, next: LiveWindowShape): boolean {
  return (
    next.key !== previous.key || next.oldest !== previous.oldest || next.count < previous.count
  );
}

/**
 * The cursor for the page immediately older than `oldest`: sequenced rows page
 * by `beforeSequence`; unsequenced rows (the common case) by the
 * `(createdAt, activityId)` keyset.
 */
export function olderActivitiesCursorFor(
  oldest: OrchestrationThreadActivity,
): OlderActivitiesCursor {
  return oldest.sequence !== undefined
    ? { beforeSequence: oldest.sequence }
    : { beforeCreatedAt: oldest.createdAt, beforeActivityId: oldest.id };
}

/**
 * The row the NEXT load should cursor from: the explicit cursor row already
 * paged past when one exists (so an all-overlap page keeps advancing), else
 * the chronologically-oldest loaded row — never index 0, which the reducer
 * can fill with a newer row (unsequenced rows sort to the end).
 */
export function nextOlderActivitiesCursorRow(
  pagedPast: OrchestrationThreadActivity | null,
  merged: ReadonlyArray<OrchestrationThreadActivity>,
): OrchestrationThreadActivity | null {
  return pagedPast ?? oldestActivityByChronology(merged);
}

/**
 * The page rows not already present in the loaded set (older pages + live
 * window) — boundary overlap and mid-flight appends must never produce
 * duplicate ids in the merged timeline.
 */
export function freshOlderActivities(
  page: OlderActivitiesPage,
  merged: ReadonlyArray<OrchestrationThreadActivity>,
): ReadonlyArray<OrchestrationThreadActivity> {
  const seen = new Set(merged.map((activity) => activity.id));
  return page.activities.filter((activity) => !seen.has(activity.id));
}

/**
 * The older-history lazy-load engine, shared by every client (web ChatView,
 * the mobile composer, the TUI ChatView). The thread-detail snapshot windows
 * activities to the most recent page; older pages are fetched on demand and
 * prepended.
 *
 * One implementation holds all the hardening the per-client copies kept
 * drifting on:
 * - reset on live-window RESHAPE, not just thread switch: a reconnect
 *   re-snapshot changes the window's chronological-oldest row and a checkpoint
 *   revert shrinks it, but a plain append does neither (the reducer re-sorts
 *   unsequenced rows, so index 0 is not a stable boundary — the sentinel is
 *   {@link liveWindowOldestActivityId});
 * - a generation guard so a load resolving after a reset can't repopulate the
 *   cleared state;
 * - a synchronous in-flight key so scroll-triggered duplicate dispatches
 *   coalesce before the loading state commits;
 * - an explicit advancing cursor (the oldest row paged PAST), so an
 *   all-overlap page keeps paging instead of dead-ending while the server
 *   still reports more — the server cursor is strict, so it strictly
 *   decreases and paging cannot loop;
 * - dedup against the LATEST merged set via a ref, so a live append or a
 *   prior prepend settling mid-flight can't produce duplicate ids;
 * - `hasMore` stays true on a failed/skipped page (the history still exists;
 *   scrolling back retries).
 */
export function useOlderThreadActivities(
  options: UseOlderThreadActivitiesOptions,
): UseOlderThreadActivitiesResult {
  const { threadKey, liveActivities, hasMoreLiveActivities, loadPage } = options;

  const [olderActivities, setOlderActivities] = useState<
    ReadonlyArray<OrchestrationThreadActivity>
  >([]);
  const [olderLoaded, setOlderLoaded] = useState(false);
  const [olderHasMore, setOlderHasMore] = useState(false);
  const [loadingOlder, setLoadingOlder] = useState(false);

  // Order-independent oldest boundary: `liveActivities[0]` shifts when the
  // reducer re-sorts unsequenced rows on the first live append, which would
  // otherwise make a plain append look like a window reshape.
  const liveOldestActivityId = useMemo(
    () => liveWindowOldestActivityId(liveActivities),
    [liveActivities],
  );
  const liveActivityCount = liveActivities.length;

  // Bumps on every reset so a late in-flight load can't repopulate the
  // freshly-cleared state (the thread key alone doesn't change on a
  // same-thread window reshape).
  const generationRef = useRef(0);
  // The thread key of an in-flight load — coalesces the duplicate dispatches a
  // fast scroll fires before the loading state updates.
  const inFlightKeyRef = useRef<string | null>(null);
  // The oldest row we've paged past; advances even when a page dedupes to
  // nothing. Reset on reshape.
  const cursorRef = useRef<OrchestrationThreadActivity | null>(null);
  const windowRef = useRef({
    key: threadKey,
    oldest: liveOldestActivityId,
    count: liveActivityCount,
  });

  // useLayoutEffect (not useEffect) so the cleared state commits before paint:
  // otherwise a thread switch renders one frame with the previous thread's
  // lazy-loaded pages still merged in, flashing stale rows.
  useLayoutEffect(() => {
    const previous = windowRef.current;
    windowRef.current = {
      key: threadKey,
      oldest: liveOldestActivityId,
      count: liveActivityCount,
    };
    if (!didLiveWindowReshape(previous, windowRef.current)) {
      return;
    }
    generationRef.current += 1;
    inFlightKeyRef.current = null;
    cursorRef.current = null;
    setOlderActivities([]);
    setOlderLoaded(false);
    setOlderHasMore(false);
    setLoadingOlder(false);
  }, [threadKey, liveOldestActivityId, liveActivityCount]);

  const mergedActivities = useMemo(
    () => (olderActivities.length > 0 ? [...olderActivities, ...liveActivities] : liveActivities),
    [olderActivities, liveActivities],
  );
  // Latest merged set, read inside the async load handler so dedup runs
  // against current state, not the snapshot captured at dispatch time.
  const mergedActivitiesRef = useRef(mergedActivities);
  useLayoutEffect(() => {
    mergedActivitiesRef.current = mergedActivities;
  }, [mergedActivities]);

  // Before any page is loaded the server flag is authoritative; afterwards
  // the latest page's `hasMore` is.
  const hasMoreOlder = olderLoaded ? olderHasMore : threadKey !== null && hasMoreLiveActivities;

  const loadOlder = useCallback(() => {
    if (threadKey === null || !hasMoreOlder) {
      return;
    }
    const oldest = nextOlderActivitiesCursorRow(cursorRef.current, mergedActivitiesRef.current);
    if (!oldest) {
      return;
    }
    if (inFlightKeyRef.current === threadKey) {
      return; // a load for this thread is already in flight
    }
    const cursor = olderActivitiesCursorFor(oldest);
    const generation = generationRef.current;
    inFlightKeyRef.current = threadKey;
    setLoadingOlder(true);
    void loadPage(cursor)
      .then((page) => {
        // The window/thread was reset while this was in flight — drop the page
        // so it can't repopulate state cleared by the reset.
        if (generationRef.current !== generation) {
          return;
        }
        if (page === null) {
          // Failed or interrupted (already surfaced by the caller). Keep
          // `hasMore` — the history still exists and retrying is valid.
          return;
        }
        // Advance the cursor even when every row dedupes away — the server
        // cursor is strict, so it strictly decreases and paging can't loop.
        const pageOldest = page.activities[0];
        if (pageOldest) {
          cursorRef.current = pageOldest;
        }
        const fresh = freshOlderActivities(page, mergedActivitiesRef.current);
        if (fresh.length > 0) {
          setOlderActivities((previous) => [...fresh, ...previous]);
        }
        setOlderLoaded(true);
        setOlderHasMore(page.hasMore);
      })
      .finally(() => {
        if (generationRef.current === generation) {
          inFlightKeyRef.current = null;
          setLoadingOlder(false);
        }
      });
  }, [threadKey, hasMoreOlder, loadPage]);

  return {
    mergedActivities: threadKey === null ? EMPTY_ACTIVITIES : mergedActivities,
    hasMoreOlder,
    loadingOlder,
    loadOlder,
  };
}