export type OrchestrationRecoveryReason =
  | "bootstrap"
  | "sequence-gap"
  | "resubscribe"
  | "replay-failed";

export interface OrchestrationRecoveryPhase {
  kind: "snapshot" | "replay";
  reason: OrchestrationRecoveryReason;
}

export interface OrchestrationRecoveryState {
  latestSequence: number;
  highestObservedSequence: number;
  bootstrapped: boolean;
  pendingReplay: boolean;
  inFlight: OrchestrationRecoveryPhase | null;
}

export interface ReplayRecoveryCompletion {
  replayMadeProgress: boolean;
  shouldReplay: boolean;
}

export interface ReplayRetryTracker {
  attempts: number;
  latestSequence: number;
  highestObservedSequence: number;
}

export interface ReplayRetryDecision {
  shouldRetry: boolean;
  delayMs: number;
  tracker: ReplayRetryTracker | null;
}

type SequencedEvent = Readonly<{ sequence: number }>;

export function deriveReplayRetryDecision(input: {
  previousTracker: ReplayRetryTracker | null;
  completion: ReplayRecoveryCompletion;
  recoveryState: Pick<OrchestrationRecoveryState, "latestSequence" | "highestObservedSequence">;
  baseDelayMs: number;
  maxNoProgressRetries: number;
}): ReplayRetryDecision {
  if (!input.completion.shouldReplay) {
    return {
      shouldRetry: false,
      delayMs: 0,
      tracker: null,
    };
  }

  if (input.completion.replayMadeProgress) {
    return {
      shouldRetry: true,
      delayMs: 0,
      tracker: null,
    };
  }

  const previousTracker = input.previousTracker;
  const sameFrontier =
    previousTracker !== null &&
    previousTracker.latestSequence === input.recoveryState.latestSequence &&
    previousTracker.highestObservedSequence === input.recoveryState.highestObservedSequence;

  const attempts = sameFrontier && previousTracker !== null ? previousTracker.attempts + 1 : 1;
  if (attempts > input.maxNoProgressRetries) {
    return {
      shouldRetry: false,
      delayMs: 0,
      tracker: null,
    };
  }

  return {
    shouldRetry: true,
    delayMs: input.baseDelayMs * 2 ** (attempts - 1),
    tracker: {
      attempts,
      latestSequence: input.recoveryState.latestSequence,
      highestObservedSequence: input.recoveryState.highestObservedSequence,
    },
  };
}

export function createOrchestrationRecoveryCoordinator() {
  let state: OrchestrationRecoveryState = {
    latestSequence: 0,
    highestObservedSequence: 0,
    bootstrapped: false,
    pendingReplay: false,
    inFlight: null,
  };
  let replayStartSequence: number | null = null;

  const snapshotState = (): OrchestrationRecoveryState => ({
    ...state,
    ...(state.inFlight ? { inFlight: { ...state.inFlight } } : {}),
  });

  const observeSequence = (sequence: number) => {
    state.highestObservedSequence = Math.max(state.highestObservedSequence, sequence);
  };

  const resolveReplayNeedAfterRecovery = () => {
    const pendingReplayBeforeReset = state.pendingReplay;
    const observedAhead = state.highestObservedSequence > state.latestSequence;
    const shouldReplay = pendingReplayBeforeReset || observedAhead;
    state.pendingReplay = false;
    return {
      shouldReplay,
      pendingReplayBeforeReset,
      observedAhead,
    };
  };

  return {
    getState(): OrchestrationRecoveryState {
      return snapshotState();
    },

    classifyDomainEvent(sequence: number): "ignore" | "defer" | "recover" | "apply" {
      observeSequence(sequence);
      if (sequence <= state.latestSequence) {
        return "ignore";
      }
      if (!state.bootstrapped || state.inFlight) {
        state.pendingReplay = true;
        return "defer";
      }
      if (sequence !== state.latestSequence + 1) {
        state.pendingReplay = true;
        return "recover";
      }
      return "apply";
    },

    markEventBatchApplied<T extends SequencedEvent>(events: ReadonlyArray<T>): ReadonlyArray<T> {
      const nextEvents = events
        .filter((event) => event.sequence > state.latestSequence)
        .toSorted((left, right) => left.sequence - right.sequence);
      if (nextEvents.length === 0) {
        return [];
      }

      state.latestSequence = nextEvents.at(-1)?.sequence ?? state.latestSequence;
      state.highestObservedSequence = Math.max(state.highestObservedSequence, state.latestSequence);
      return nextEvents;
    },

    beginSnapshotRecovery(reason: OrchestrationRecoveryReason): boolean {
      if (state.inFlight?.kind === "snapshot") {
        state.pendingReplay = true;
        return false;
      }
      if (state.inFlight?.kind === "replay") {
        state.pendingReplay = true;
        return false;
      }
      state.inFlight = { kind: "snapshot", reason };
      return true;
    },

    completeSnapshotRecovery(snapshotSequence: number): boolean {
      state.latestSequence = Math.max(state.latestSequence, snapshotSequence);
      state.highestObservedSequence = Math.max(state.highestObservedSequence, state.latestSequence);
      state.bootstrapped = true;
      state.inFlight = null;
      return resolveReplayNeedAfterRecovery().shouldReplay;
    },

    failSnapshotRecovery(): void {
      state.inFlight = null;
    },

    beginReplayRecovery(reason: OrchestrationRecoveryReason): boolean {
      if (!state.bootstrapped || state.inFlight?.kind === "snapshot") {
        state.pendingReplay = true;
        return false;
      }
      if (state.inFlight?.kind === "replay") {
        state.pendingReplay = true;
        return false;
      }
      state.pendingReplay = false;
      replayStartSequence = state.latestSequence;
      state.inFlight = { kind: "replay", reason };
      return true;
    },

    completeReplayRecovery(): ReplayRecoveryCompletion {
      const replayMadeProgress =
        replayStartSequence !== null && state.latestSequence > replayStartSequence;
      replayStartSequence = null;
      state.inFlight = null;
      const replayResolution = resolveReplayNeedAfterRecovery();
      return {
        replayMadeProgress,
        shouldReplay: replayResolution.shouldReplay,
      };
    },

    failReplayRecovery(): void {
      replayStartSequence = null;
      state.bootstrapped = false;
      state.inFlight = null;
    },
  };
}