import {
  computed,
  nextTick,
  ref,
  shallowRef,
  type App,
  type CSSProperties,
} from "vue";
import {
  isNavigationFailure,
  loadRouteLocation,
  START_LOCATION,
  type NavigationFailure,
  type RouteLocationNormalizedLoaded,
  type RouteLocationRaw,
  type RouteLocationResolved,
} from "vue-router";
import type {
  NativeDirection,
  NativeDiagnosticEvent,
  NativeDiagnosticEventType,
  NativeEvictionReason,
  NativeGestureKind,
  NativeNavigationOptions,
  NativePlatformAdapter,
  NativePresentationDefinition,
  NativePresentationName,
  NativeRouterOptions,
  NativeRouterRuntime,
  NativeTransaction,
  NativeViewEntry,
} from "./types";

export const nativeRouterKey = Symbol("native-vue-router");

let entrySequence = 0;

function now() {
  return typeof performance === "undefined" ? Date.now() : performance.now();
}

function diagnosticRoute(
  route: RouteLocationNormalizedLoaded | RouteLocationResolved,
) {
  return route.name != null
    ? String(route.name)
    : (route.matched.at(-1)?.path ?? route.path);
}

function entryFor(
  route: RouteLocationNormalizedLoaded,
  status: NativeViewEntry["status"],
  synthetic = false,
): NativeViewEntry {
  return {
    key: `${route.fullPath}::${++entrySequence}`,
    route,
    status,
    mounted: true,
    synthetic,
    committed: status !== "preview",
    lastUsed: now(),
    scrollX: 0,
    scrollY: 0,
  };
}

export function shouldCommitGesture(
  progress: number,
  velocity: number,
  threshold = 0.36,
) {
  return progress >= threshold || (progress >= 0.08 && velocity >= 1.1);
}

/**
 * Converts release velocity (normalized route progress per second) into the
 * rate at which the spring is simulated. A deliberate flick can settle up to
 * three times faster while a stationary release keeps the baseline spring.
 */
export function springTimeScaleForVelocity(velocity: number) {
  return 1 + Math.min(2, Math.abs(velocity) * 0.3);
}

export function definePresentation(definition: NativePresentationDefinition) {
  return definition;
}

const builtinPresentations: NativePresentationDefinition[] = [
  { name: "push", axis: "x" },
  { name: "reveal", axis: "x" },
  { name: "slide", axis: "x" },
  { name: "fade", axis: "x" },
  { name: "modal", axis: "y" },
  { name: "sheet", axis: "y" },
  { name: "none", axis: "x" },
];

class NativeRouterRuntimeImpl implements NativeRouterRuntime {
  readonly router;
  readonly entries;
  readonly activeKey;
  readonly transaction;
  readonly canGoBack;
  readonly cacheStats;

  private readonly mutableEntries = shallowRef<NativeViewEntry[]>([]);
  private readonly mutableActiveKey = ref("");
  private readonly mutableTransaction = shallowRef<NativeTransaction | null>(
    null,
  );
  private readonly mutableHistoryKeys = shallowRef<string[]>([]);
  private readonly maxInactive: number;
  private readonly platform?: NativePlatformAdapter;
  private readonly presentations = new Map<
    NativePresentationName,
    NativePresentationDefinition
  >();
  private transactionSequence = 0;
  private beginAttemptSequence = 0;
  private readonly pendingNavigations = new Map<
    number,
    Promise<NavigationFailure | void | true>
  >();
  private removeAfterEach?: () => void;
  private platformCleanup?: () => void;
  private pendingPop?: (failure?: NavigationFailure | void) => void;
  private totalEvictions = 0;
  private lastEviction?: {
    key: string;
    route: string;
    reason: NativeEvictionReason;
  };
  private memoryPressureCleanup?: () => void;
  private readonly diagnosticListeners = new Set<
    (event: NativeDiagnosticEvent) => void
  >();

  constructor(options: NativeRouterOptions) {
    this.router = options.router;
    this.maxInactive = Math.max(0, options.cache?.maxInactive ?? 4);
    this.platform = options.platform;
    this.entries = computed(() => this.mutableEntries.value);
    this.activeKey = computed(() => this.mutableActiveKey.value);
    this.transaction = computed(() => this.mutableTransaction.value);
    this.cacheStats = computed(() => {
      const entries = this.mutableEntries.value;
      const mounted = entries.filter((entry) => entry.mounted);
      const inactive = mounted.filter(
        (entry) => entry.key !== this.mutableActiveKey.value,
      );
      return {
        maxInactive: this.maxInactive,
        descriptors: entries.length,
        mounted: mounted.length,
        inactive: inactive.length,
        pinned: inactive.filter(
          (entry) => entry.route.meta.native?.cache === "pin",
        ).length,
        evicted: entries.filter((entry) => !entry.mounted).length,
        totalEvictions: this.totalEvictions,
        lastEviction: this.lastEviction,
      };
    });
    this.canGoBack = computed(() => {
      const transaction = this.mutableTransaction.value;
      const committingForwardEntry =
        transaction &&
        transaction.phase !== "interactive" &&
        transaction.kind !== "pop" &&
        transaction.kind !== "dismiss" &&
        !transaction.replace;
      return (
        Boolean(committingForwardEntry) ||
        this.mutableHistoryKeys.value.length > 1 ||
        Boolean(this.activeEntry()?.route.meta.native?.parent)
      );
    });

    for (const definition of builtinPresentations)
      this.registerPresentation(definition);
    for (const definition of options.presentations ?? [])
      this.registerPresentation(definition);

    this.removeAfterEach = this.router.afterEach((to, from, failure) => {
      if (!failure) this.acceptRoute(to, from);
      this.pendingPop?.(failure);
      this.pendingPop = undefined;
    });
  }

  install(app: App) {
    app.provide(nativeRouterKey, this);
    app.config.globalProperties.$nativeRouter = this;
    void this.router.isReady().then(() => {
      if (
        this.mutableEntries.value.length === 0 &&
        this.router.currentRoute.value !== START_LOCATION
      ) {
        const initial = entryFor(this.router.currentRoute.value, "active");
        this.mutableEntries.value = [initial];
        this.mutableActiveKey.value = initial.key;
        this.mutableHistoryKeys.value = [initial.key];
      }
    });
    if (this.platform?.install) {
      void Promise.resolve(this.platform.install(this)).then((cleanup) => {
        if (cleanup) this.platformCleanup = cleanup;
      });
    }
    if (typeof window !== "undefined") {
      const trimForPressure = () =>
        this.trimCache({ reason: "memory-pressure" });
      window.addEventListener("memorypressure", trimForPressure);
      this.memoryPressureCleanup = () =>
        window.removeEventListener("memorypressure", trimForPressure);
    }
  }

  async preload(to: RouteLocationRaw) {
    const resolved = this.router.resolve(to);
    return await this.loadResolvedRoute(resolved);
  }

  async push(to: RouteLocationRaw, options: NativeNavigationOptions = {}) {
    const id = await this.beginInteractive("push", to, options);
    if (id === null) return false;
    return await this.finishInteractive(true);
  }

  async replace(to: RouteLocationRaw, options: NativeNavigationOptions = {}) {
    const id = await this.beginInteractive("push", to, {
      ...options,
      replace: true,
    });
    if (id === null) return false;
    return await this.finishInteractive(true);
  }

  async sibling(to: RouteLocationRaw, options: NativeNavigationOptions = {}) {
    const id = await this.beginInteractive("sibling", to, options);
    if (id === null) return false;
    return await this.finishInteractive(true);
  }

  async pop() {
    const id = await this.beginInteractive("pop");
    if (id === null) return false;
    return await this.finishInteractive(true);
  }

  async present(
    to: RouteLocationRaw,
    presentation: NativePresentationName = "modal",
  ) {
    const id = await this.beginInteractive("present", to, { presentation });
    if (id === null) return false;
    return await this.finishInteractive(true);
  }

  async dismiss() {
    const id = await this.beginInteractive("dismiss");
    if (id === null) return false;
    return await this.finishInteractive(true);
  }

  async beginInteractive(
    kind: NativeGestureKind,
    to?: RouteLocationRaw,
    options: NativeNavigationOptions = {},
  ) {
    const attempt = ++this.beginAttemptSequence;
    const live = this.mutableTransaction.value;
    if (live) {
      if (live.phase === "interactive") return null;
      await this.interruptSettling(live);
      if (
        attempt !== this.beginAttemptSequence ||
        this.mutableTransaction.value
      )
        return null;
    }
    const from = this.activeEntry();
    if (!from) return null;

    let target: NativeViewEntry | undefined;
    let synthetic = false;
    let needsMount = false;
    const isBack = kind === "pop" || kind === "dismiss";

    if (isBack) {
      const history = this.mutableHistoryKeys.value;
      target =
        history.length > 1
          ? this.entryByKey(history[history.length - 2])
          : undefined;
      if (!target) {
        const parent = from.route.meta.native?.parent;
        if (!parent) return null;
        const parentLocation =
          typeof parent === "function" ? parent(from.route) : parent;
        const route = await this.loadResolvedRoute(
          this.router.resolve(parentLocation),
          attempt,
        );
        if (
          attempt !== this.beginAttemptSequence ||
          this.mutableTransaction.value
        )
          return null;
        target = entryFor(route, "preview", true);
        synthetic = true;
        needsMount = true;
        this.mutableEntries.value = [...this.mutableEntries.value, target];
      } else if (!target.mounted) {
        const route = await this.loadResolvedRoute(
          this.router.resolve(target.route.fullPath),
          attempt,
        );
        if (
          attempt !== this.beginAttemptSequence ||
          this.mutableTransaction.value
        )
          return null;
        target.route = route;
        target.mounted = true;
        target.status = "inactive";
        target.evictionReason = undefined;
        needsMount = true;
        this.touchEntries();
      }
    } else {
      if (!to) return null;
      const resolved = this.router.resolve(to);
      if (resolved.fullPath === from.route.fullPath) return null;
      const route = await this.loadResolvedRoute(resolved, attempt);
      if (
        attempt !== this.beginAttemptSequence ||
        this.mutableTransaction.value
      )
        return null;
      const replace =
        options.replace ?? route.meta.native?.siblingHistory === "replace";
      target = replace ? this.findHistoryEntry(route.fullPath) : undefined;
      target ??= this.findReusable(route.fullPath);
      if (target) {
        needsMount = !target.mounted;
        target.route = route;
        target.mounted = true;
        target.status = "preview";
        target.synthetic = false;
        target.lastUsed = now();
        target.evictionReason = undefined;
        this.touchEntries();
      } else {
        target = entryFor(route, "preview");
        needsMount = true;
        this.mutableEntries.value = [...this.mutableEntries.value, target];
      }
    }

    const presentationRoute = isBack ? from.route : target.route;
    const presentation =
      options.presentation ??
      presentationRoute.meta.native?.presentation ??
      presentationRoute.meta.native?.transition ??
      (kind === "present" || kind === "dismiss"
        ? "modal"
        : kind === "sibling"
          ? "slide"
          : "push");
    const direction: NativeDirection =
      options.direction ??
      (kind === "pop" || kind === "dismiss"
        ? "back"
        : kind === "present"
          ? "up"
          : kind === "sibling"
            ? this.siblingDirection(from.route, target.route)
            : "forward");

    const transaction: NativeTransaction = {
      id: ++this.transactionSequence,
      kind,
      direction,
      presentation,
      fromKey: from.key,
      toKey: target.key,
      progress: 0,
      velocity: 0,
      phase: "interactive",
      replace:
        options.replace ??
        target.route.meta.native?.siblingHistory === "replace",
      sourceRect: options.sourceRect,
    };
    if (attempt !== this.beginAttemptSequence || this.mutableTransaction.value)
      return null;
    this.mutableTransaction.value = transaction;
    this.emitDiagnostic("transaction-start", {
      attempt,
      transactionId: transaction.id,
      route: diagnosticRoute(target.route),
      details: {
        kind: transaction.kind,
        direction: transaction.direction,
        presentation: transaction.presentation,
        cold: needsMount,
      },
    });
    if (synthetic) target.synthetic = true;
    if (needsMount) {
      const prepareStarted = now();
      this.emitDiagnostic("view-prepare-start", {
        attempt,
        transactionId: transaction.id,
        route: diagnosticRoute(target.route),
      });
      await this.prepareMountedView();
      this.emitDiagnostic("view-prepare-end", {
        attempt,
        transactionId: transaction.id,
        route: diagnosticRoute(target.route),
        duration: now() - prepareStarted,
      });
      if (!this.isCurrent(transaction.id)) return null;
    }
    return transaction.id;
  }

  updateInteractive(progress: number, velocity = 0) {
    const current = this.mutableTransaction.value;
    if (!current || current.phase !== "interactive") return;
    this.mutableTransaction.value = {
      ...current,
      progress: Math.max(0, Math.min(1, progress)),
      velocity,
    };
  }

  async finishInteractive(forceCommit?: boolean) {
    const current = this.mutableTransaction.value;
    if (!current) return false;
    const commit =
      forceCommit ?? shouldCommitGesture(current.progress, current.velocity);
    if (!commit) {
      await this.cancelInteractive();
      return false;
    }

    this.mutableTransaction.value = { ...current, phase: "committing" };
    this.emitDiagnostic("commit-start", {
      transactionId: current.id,
      route: this.entryByKey(current.toKey)
        ? diagnosticRoute(this.entryByKey(current.toKey)!.route)
        : undefined,
    });
    void this.platform?.haptic?.("commit");
    const navigation = this.commitRoute(current);
    this.pendingNavigations.set(current.id, navigation);
    const result = navigation.then(
      (failure) => ({ failed: Boolean(failure) }),
      () => ({ failed: true }),
    );
    await this.animateProgress(1, current.velocity);
    const { failed } = await result;
    this.pendingNavigations.delete(current.id);
    if (!this.isCurrent(current.id)) return !failed;
    if (failed) {
      await this.animateProgress(0, 0);
      if (this.isCurrent(current.id)) this.finalizeCancelled(current, true);
      return false;
    }
    this.finalizeCommitted(current);
    return true;
  }

  async cancelInteractive() {
    const current = this.mutableTransaction.value;
    if (!current || current.phase !== "interactive") return;
    this.mutableTransaction.value = { ...current, phase: "cancelled" };
    await this.animateProgress(0, 0);
    if (!this.isCurrent(current.id)) return;
    void this.platform?.haptic?.("cancel");
    this.finalizeCancelled(current);
  }

  unload(to: RouteLocationRaw) {
    const fullPath = this.router.resolve(to).fullPath;
    const transaction = this.mutableTransaction.value;
    let unloaded = 0;
    for (const entry of this.mutableEntries.value) {
      if (entry.route.fullPath !== fullPath || !entry.mounted) continue;
      if (entry.key === this.mutableActiveKey.value) continue;
      if (
        entry.key === transaction?.fromKey ||
        entry.key === transaction?.toKey
      )
        continue;
      this.evictEntry(entry, "manual");
      unloaded += 1;
    }
    if (unloaded) this.touchEntries();
    return unloaded;
  }

  trimCache(
    options: { includePinned?: boolean; reason?: NativeEvictionReason } = {},
  ) {
    const reason = options.reason ?? "trimmed";
    for (const entry of this.mutableEntries.value) {
      if (
        entry.key === this.mutableActiveKey.value ||
        !entry.mounted ||
        entry.status !== "inactive"
      )
        continue;
      if (!options.includePinned && entry.route.meta.native?.cache === "pin")
        continue;
      this.evictEntry(entry, reason);
    }
    this.touchEntries();
  }

  onDiagnostic(listener: (event: NativeDiagnosticEvent) => void) {
    this.diagnosticListeners.add(listener);
    return () => this.diagnosticListeners.delete(listener);
  }

  registerPresentation(definition: NativePresentationDefinition) {
    this.presentations.set(definition.name, definition);
  }

  presentationFor(name: NativePresentationName) {
    return this.presentations.get(name);
  }

  layerStyle(entry: NativeViewEntry): CSSProperties | undefined {
    const transaction = this.mutableTransaction.value;
    if (!transaction) return undefined;
    const role =
      entry.key === transaction.fromKey
        ? "from"
        : entry.key === transaction.toKey
          ? "to"
          : undefined;
    if (!role) return undefined;
    return this.presentationFor(transaction.presentation)?.layerStyle?.({
      progress: transaction.progress,
      role,
      direction: transaction.direction,
      sourceRect: transaction.sourceRect,
    });
  }

  dispose() {
    this.removeAfterEach?.();
    this.platformCleanup?.();
    this.memoryPressureCleanup?.();
  }

  private activeEntry() {
    return this.entryByKey(this.mutableActiveKey.value);
  }

  private activeIndex() {
    return this.mutableEntries.value.findIndex(
      (entry) => entry.key === this.mutableActiveKey.value,
    );
  }

  private entryByKey(key: string) {
    return this.mutableEntries.value.find((entry) => entry.key === key);
  }

  private findReusable(fullPath: string) {
    return [...this.mutableEntries.value]
      .reverse()
      .find(
        (entry) =>
          entry.route.fullPath === fullPath &&
          entry.key !== this.mutableActiveKey.value &&
          !this.mutableHistoryKeys.value.includes(entry.key),
      );
  }

  private findHistoryEntry(fullPath: string) {
    for (const key of [...this.mutableHistoryKeys.value].reverse()) {
      const entry = this.entryByKey(key);
      if (entry?.route.fullPath === fullPath) return entry;
    }
    return undefined;
  }

  private siblingDirection(
    from: RouteLocationNormalizedLoaded,
    to: RouteLocationNormalizedLoaded,
  ): NativeDirection {
    const fromOrder = from.meta.native?.siblingOrder;
    const toOrder = to.meta.native?.siblingOrder;
    return typeof fromOrder === "number" &&
      typeof toOrder === "number" &&
      toOrder < fromOrder
      ? "back"
      : "forward";
  }

  private touchEntries() {
    this.mutableEntries.value = [...this.mutableEntries.value];
  }

  private clearTransaction() {
    this.mutableTransaction.value = null;
  }

  private isCurrent(id: number) {
    return this.mutableTransaction.value?.id === id;
  }

  private async interruptSettling(transaction: NativeTransaction) {
    if (!this.isCurrent(transaction.id) || transaction.phase === "interactive")
      return;
    const navigation = this.pendingNavigations.get(transaction.id);
    if (!navigation) {
      this.finalizeCancelled(transaction);
      return;
    }
    const failed = await navigation.then(
      (failure) => Boolean(failure),
      () => true,
    );
    this.pendingNavigations.delete(transaction.id);
    if (!this.isCurrent(transaction.id)) return;
    this.mutableTransaction.value = {
      ...this.mutableTransaction.value!,
      progress: failed ? 0 : 1,
      velocity: 0,
      phase: "settling",
    };
    if (failed) this.finalizeCancelled(transaction, true);
    else this.finalizeCommitted(transaction);
  }

  private finalizeCancelled(
    transaction: NativeTransaction,
    evictTarget = false,
  ) {
    if (!this.isCurrent(transaction.id)) return;
    const target = this.entryByKey(transaction.toKey);
    this.emitDiagnostic("transaction-end", {
      transactionId: transaction.id,
      route: target ? diagnosticRoute(target.route) : undefined,
      details: { outcome: evictTarget ? "rejected" : "cancelled" },
    });
    this.clearTransaction();
    if (evictTarget)
      this.discardTarget(transaction.toKey, "navigation-rejected");
    else this.removePreview(transaction.toKey);
    this.markStatuses();
    this.enforceCache();
  }

  private finalizeCommitted(transaction: NativeTransaction) {
    if (!this.isCurrent(transaction.id)) return;
    const target = this.entryByKey(transaction.toKey);
    if (
      target &&
      this.router.currentRoute.value.fullPath !== target.route.fullPath
    ) {
      // A redirect is already authoritative; discard only the stale preview.
      this.emitDiagnostic("transaction-end", {
        transactionId: transaction.id,
        route: diagnosticRoute(target.route),
        details: { outcome: "redirected" },
      });
      this.clearTransaction();
      this.discardTarget(transaction.toKey, "navigation-rejected");
      this.markStatuses();
      this.enforceCache();
      return;
    }
    if (target) {
      target.status = "active";
      target.synthetic = false;
      target.committed = true;
      target.lastUsed = now();
      this.mutableActiveKey.value = target.key;
    }
    this.emitDiagnostic("transaction-end", {
      transactionId: transaction.id,
      route: target ? diagnosticRoute(target.route) : undefined,
      details: { outcome: "committed" },
    });
    this.clearTransaction();
    this.markStatuses();
    this.enforceCache();
  }

  private async commitRoute(transaction: NativeTransaction) {
    const target = this.entryByKey(transaction.toKey);
    if (!target) return true;
    if (transaction.kind === "pop" || transaction.kind === "dismiss") {
      if (target.synthetic)
        return await this.router.replace(target.route.fullPath);
      return await this.navigateHistory(-1);
    }
    if (transaction.replace) {
      const history = this.mutableHistoryKeys.value;
      const targetIndex = history.lastIndexOf(target.key);
      if (targetIndex >= 0 && targetIndex < history.length - 1) {
        return await this.navigateHistory(targetIndex - (history.length - 1));
      }
    }
    return transaction.replace
      ? await this.router.replace(target.route.fullPath)
      : await this.router.push(target.route.fullPath);
  }

  private async navigateHistory(delta: number) {
    return await new Promise<NavigationFailure | void>((resolve) => {
      this.pendingPop = resolve;
      this.router.go(delta);
      window.setTimeout(() => {
        if (this.pendingPop === resolve) {
          this.pendingPop = undefined;
          resolve();
        }
      }, 1200);
    });
  }

  private acceptRoute(
    to: RouteLocationNormalizedLoaded,
    _from: RouteLocationNormalizedLoaded,
  ) {
    const transaction = this.mutableTransaction.value;
    let target = transaction ? this.entryByKey(transaction.toKey) : undefined;
    if (target && target.route.fullPath !== to.fullPath) target = undefined;
    if (!transaction) target ??= this.findHistoryEntry(to.fullPath);
    target ??= this.findReusable(to.fullPath);
    if (!target && this.activeEntry()?.route.fullPath === to.fullPath)
      target = this.activeEntry();
    if (!target) {
      target = entryFor(to, "active");
      const activeIndex = this.activeIndex();
      const head =
        activeIndex >= 0
          ? this.mutableEntries.value.slice(0, activeIndex + 1)
          : this.mutableEntries.value;
      this.mutableEntries.value = [...head, target];
    } else {
      target.route = to;
      target.mounted = true;
      target.status = "active";
      target.committed = true;
      target.lastUsed = now();
      target.evictionReason = undefined;
      this.touchEntries();
    }
    this.mutableActiveKey.value = target.key;
    this.acceptHistory(target, transaction);
    this.markStatuses();
    if (!transaction) this.enforceCache();
  }

  private acceptHistory(
    target: NativeViewEntry,
    transaction: NativeTransaction | null,
  ) {
    const history = this.mutableHistoryKeys.value;
    if (!history.length) {
      this.mutableHistoryKeys.value = [target.key];
      return;
    }
    if (transaction?.kind === "pop" || transaction?.kind === "dismiss") {
      const targetIndex = history.lastIndexOf(target.key);
      this.mutableHistoryKeys.value =
        targetIndex >= 0
          ? history.slice(0, targetIndex + 1)
          : [...history.slice(0, -1), target.key];
      return;
    }
    if (transaction?.replace) {
      const targetIndex = history.lastIndexOf(target.key);
      this.mutableHistoryKeys.value =
        targetIndex >= 0
          ? history.slice(0, targetIndex + 1)
          : [...history.slice(0, -1), target.key];
      return;
    }
    const existingIndex = history.lastIndexOf(target.key);
    this.mutableHistoryKeys.value = transaction
      ? [...history, target.key]
      : existingIndex >= 0
        ? history.slice(0, existingIndex + 1)
        : [...history, target.key];
  }

  private markStatuses() {
    const transaction = this.mutableTransaction.value;
    for (const entry of this.mutableEntries.value) {
      if (entry.key === this.mutableActiveKey.value) entry.status = "active";
      else if (transaction?.toKey === entry.key && entry.status === "preview")
        entry.status = "preview";
      else if (entry.mounted) entry.status = "inactive";
      else entry.status = "evicted";
    }
    this.touchEntries();
  }

  private removePreview(key: string) {
    const entry = this.entryByKey(key);
    if (!entry || entry.key === this.mutableActiveKey.value) return;
    if (entry.status === "preview" || entry.synthetic) {
      if (entry.synthetic || !entry.committed) {
        this.mutableEntries.value = this.mutableEntries.value.filter(
          (candidate) => candidate.key !== key,
        );
      } else {
        entry.status = "inactive";
        this.touchEntries();
      }
    }
  }

  private discardTarget(key: string, reason: NativeEvictionReason) {
    const entry = this.entryByKey(key);
    if (!entry || entry.key === this.mutableActiveKey.value) return;
    if (!entry.committed || entry.synthetic) {
      this.mutableEntries.value = this.mutableEntries.value.filter(
        (candidate) => candidate.key !== key,
      );
      return;
    }
    this.evictEntry(entry, reason);
  }

  private evictEntry(entry: NativeViewEntry, reason: NativeEvictionReason) {
    if (!entry.mounted || entry.key === this.mutableActiveKey.value) return;
    entry.mounted = false;
    entry.status = "evicted";
    entry.evictionReason = reason;
    this.totalEvictions += 1;
    this.lastEviction = { key: entry.key, route: entry.route.fullPath, reason };
    this.emitDiagnostic("view-evicted", {
      route: diagnosticRoute(entry.route),
      details: { reason },
    });
  }

  private shouldRetainInactive(entry: NativeViewEntry) {
    const policy = entry.route.meta.native?.cache;
    if (policy === false) return false;
    if (policy === "pin") return true;
    if (this.mutableHistoryKeys.value.includes(entry.key)) return true;
    return entry.route.meta.native?.siblingHistory === "replace";
  }

  private enforceCache() {
    const inactive = this.mutableEntries.value
      .filter(
        (entry) =>
          entry.key !== this.mutableActiveKey.value &&
          entry.mounted &&
          entry.status === "inactive",
      )
      .sort((a, b) => b.lastUsed - a.lastUsed);
    for (const entry of inactive) {
      if (!this.shouldRetainInactive(entry)) {
        const reason: NativeEvictionReason =
          entry.route.meta.native?.cache === false
            ? "cache-disabled"
            : "popped";
        this.evictEntry(entry, reason);
      }
    }
    const retained = inactive.filter(
      (entry) => entry.mounted && entry.route.meta.native?.cache !== "pin",
    );
    for (const entry of retained.slice(this.maxInactive)) {
      this.evictEntry(entry, "cache-limit");
    }
    this.touchEntries();
  }

  private async prepareMountedView() {
    await nextTick();
    if (typeof window === "undefined") return;
    if (window.matchMedia("(prefers-reduced-motion: reduce)").matches) return;
    await new Promise<void>((resolve) =>
      window.requestAnimationFrame(() => resolve()),
    );
  }

  private async loadResolvedRoute(
    route: RouteLocationResolved,
    attempt?: number,
  ) {
    const started = now();
    const label = diagnosticRoute(route);
    this.emitDiagnostic("route-load-start", { attempt, route: label });
    try {
      return await loadRouteLocation(route);
    } finally {
      this.emitDiagnostic("route-load-end", {
        attempt,
        route: label,
        duration: now() - started,
      });
    }
  }

  private emitDiagnostic(
    type: NativeDiagnosticEventType,
    event: Omit<NativeDiagnosticEvent, "type" | "timestamp"> = {},
  ) {
    if (!this.diagnosticListeners.size) return;
    const diagnostic = { type, timestamp: now(), ...event };
    for (const listener of this.diagnosticListeners) listener(diagnostic);
  }

  private animateProgress(target: number, initialVelocity: number) {
    const transaction = this.mutableTransaction.value;
    if (!transaction) return Promise.resolve();
    if (
      typeof window === "undefined" ||
      window.matchMedia("(prefers-reduced-motion: reduce)").matches
    ) {
      this.mutableTransaction.value = {
        ...transaction,
        progress: target,
        velocity: 0,
        phase: "settling",
      };
      return Promise.resolve();
    }
    return new Promise<void>((resolve) => {
      let position = transaction.progress;
      let velocity = Math.max(-12, Math.min(12, initialVelocity));
      const timeScale = springTimeScaleForVelocity(initialVelocity);
      let previous = now();
      const step = (time: number) => {
        const live = this.mutableTransaction.value;
        if (!live || live.id !== transaction.id) return resolve();
        const elapsed =
          Math.min(0.032, Math.max(0.001, (time - previous) / 1000)) *
          timeScale;
        previous = time;
        // Substeps keep the spring stable when a high-velocity flick advances
        // several frames of simulated time in one display frame.
        const iterations = Math.max(1, Math.ceil(elapsed / (1 / 120)));
        const dt = elapsed / iterations;
        for (let iteration = 0; iteration < iterations; iteration += 1) {
          const displacement = target - position;
          const acceleration = displacement * 280 - velocity * 30;
          velocity += acceleration * dt;
          position += velocity * dt;
        }
        const done =
          Math.abs(target - position) < 0.002 && Math.abs(velocity) < 0.02;
        this.mutableTransaction.value = {
          ...live,
          progress: done ? target : Math.max(0, Math.min(1, position)),
          velocity,
          phase: "settling",
        };
        if (done) resolve();
        else requestAnimationFrame(step);
      };
      requestAnimationFrame(step);
    });
  }
}

export function createNativeRouter(
  options: NativeRouterOptions,
): NativeRouterRuntime {
  return new NativeRouterRuntimeImpl(options);
}

export function isFailedNavigation(value: unknown) {
  return Boolean(value && isNavigationFailure(value));
}