import type {
  Options as MutativeOptions,
  Patches,
  Draft,
  Immutable,
  PatchesOptions,
} from 'mutative';

export type TravelPatches<P extends PatchesOption = {}> = {
  patches: Patches<P>[];
  inversePatches: Patches<P>[];
};

export type TravelMetadata = {
  label?: string;
  timestamp?: number;
  source?: string;
  [key: string]: unknown;
};

export type TravelHistoryEntry<P extends PatchesOption = {}> = {
  patches: Patches<P>;
  inversePatches: Patches<P>;
  metadata?: TravelMetadata;
};

export type PatchesOption = Exclude<PatchesOptions, boolean>;

export type JsonPrimitive = string | number | boolean | null;
export type JsonObject = { [key: string]: JsonValue };
export type JsonArray = JsonValue[];
export type JsonValue = JsonPrimitive | JsonObject | JsonArray;

export type PatchableState =
  | JsonValue
  | Map<unknown, unknown>
  | Set<unknown>;

export type TravelsHistory<P extends PatchesOption = {}> = {
  patches: TravelPatches<P>;
  position: number;
  metadata?: Array<TravelMetadata | undefined>;
};

export type TravelsSerializedHistory<
  S,
  P extends PatchesOption = {},
> = TravelsHistory<P> & {
  version: 1;
  state: S;
};

export type TravelsPersistenceErrorCode =
  | 'PARSE_ERROR'
  | 'INVALID_SCHEMA'
  | 'UNSUPPORTED_VERSION'
  | 'INVALID_PATCHES'
  | 'MIGRATION_FAILED';

export type TravelsMigration<
  S,
  P extends PatchesOption = {},
> = (snapshot: unknown) => TravelsSerializedHistory<S, P> | unknown;

export type TravelsDeserializeOptions<
  S,
  P extends PatchesOption = {},
> = {
  /**
   * Migrate old persisted snapshots into the current schema before validation.
   */
  migrate?: TravelsMigration<S, P>;
  /**
   * Fallback snapshot used when parsing, migration, or validation fails.
   */
  fallback?:
    | TravelsSerializedHistory<S, P>
    | (() => TravelsSerializedHistory<S, P>);
  /**
   * Receive typed persistence errors before a fallback is returned or the error is thrown.
   */
  onError?: (error: Error) => void;
};

export type TravelsBranchDiscardEvent<P extends PatchesOption = {}> = {
  position: number;
  discarded: TravelHistoryEntry<P>[];
};

export type TravelsDevtoolsEvent<
  S,
  P extends PatchesOption = {},
> = {
  type:
    | 'setState'
    | 'archive'
    | 'transaction'
    | 'go'
    | 'reset'
    | 'rebase'
    | 'replaceStateWithoutHistory';
  state: S;
  position: number;
  patches: TravelPatches<P>;
  metadata?: TravelMetadata;
};

export type TravelsErrorCode = 'TRANSACTION_FAILED';

export type TravelsOptions<
  F extends boolean,
  A extends boolean,
  P extends PatchesOption = {},
> = {
  /**
   * The maximum number of history to keep, by default `10`
   */
  maxHistory?: number;
  /**
   * The initial position in the history, by default `0`
   */
  initialPosition?: number;
  /**
   * The initial patches of the history
   */
  initialPatches?: TravelPatches<P>;
  /**
   * Restore validated serialized history. This is equivalent to passing
   * initialPatches and initialPosition directly, but preserves the first-class
   * persistence API shape returned by `Travels.deserialize(...)`.
   */
  history?: TravelsHistory<P>;
  /**
   * Whether to throw when `initialPatches` is invalid.
   * When false (default), invalid patches are discarded and history starts empty.
   */
  strictInitialPatches?: boolean;
  /**
   * Whether to automatically archive the current state, by default `true`
   */
  autoArchive?: A;
  /**
   * Whether to mutate the state in place (for observable state like MobX, Vue, Pinia)
   * When true, apply patches directly to the existing state object
   * When false (default), create new immutable state objects
   * @default false
   */
  mutable?: boolean;
  /**
   * Whether to warn in development when state contains values with weak patch or
   * JSON persistence semantics, by default `true` in development.
   */
  warnOnUnsupportedState?: boolean;
  /**
   * Called when Travels wraps a thrown core operation error.
   */
  onError?: (error: Error) => void;
  /**
   * Called when undoing and then making a new edit discards redo history.
   */
  onBranchDiscard?: (event: TravelsBranchDiscardEvent<P>) => void;
  /**
   * Optional hook for external devtools or debugging timelines.
   */
  devtools?: (event: TravelsDevtoolsEvent<any, P>) => void;
} & Omit<MutativeOptions<true, F>, 'enablePatches'> & {
    patchesOptions?: P;
  };

export type InitialValue<I extends unknown> = I extends (
  ...args: unknown[]
) => infer R
  ? R
  : I;
type DraftFunction<S> = (draft: Draft<S>) => void;
export type Updater<S> = S | (() => S) | DraftFunction<S>;
export type Value<S, F extends boolean> = F extends true
  ? Immutable<InitialValue<S>>
  : InitialValue<S>;

export interface TravelsControls<
  S,
  F extends boolean,
  P extends PatchesOption = {},
> {
  /**
   * The current position in the history
   */
  position: number;
  /**
   * Get the history of the state
   */
  getHistory: () => Value<S, F>[];
  /**
   * The patches of the history
   */
  patches: TravelPatches<P>;
  /**
   * Go back in the history
   */
  back: (amount?: number) => void;
  /**
   * Go forward in the history
   */
  forward: (amount?: number) => void;
  /**
   * Reset the history
   */
  reset: () => void;
  /**
   * Go to a specific position in the history
   */
  go: (position: number) => void;
  /**
   * Check if it's possible to go back
   */
  canBack: () => boolean;
  /**
   * Check if it's possible to go forward
   */
  canForward: () => boolean;
}

export type RebasableTravelsControls<
  S,
  F extends boolean,
  P extends PatchesOption = {},
> = TravelsControls<S, F, P> & {
  /**
   * Remove all history and make the current state as the new initial state.
   *
   * @remarks
   * **IMPORTANT**: This is a destructive operation. All previous and future history entries are discarded,
   * and the current state (including any unarchived temp patches) becomes the new baseline (position 0). Any subsequent `reset()`
   * calls will return to this new baseline, not the original initial state.
   */
  rebase: () => void;
};

export interface ManualTravelsControls<
  S,
  F extends boolean,
  P extends PatchesOption = {},
> extends TravelsControls<S, F, P> {
  /**
   * Archive the current state
   */
  archive: (metadata?: TravelMetadata) => void;
  /**
   * Check if it's possible to archive the current state
   */
  canArchive: () => boolean;
}

export type RebasableManualTravelsControls<
  S,
  F extends boolean,
  P extends PatchesOption = {},
> = ManualTravelsControls<S, F, P> & {
  /**
   * Remove all history and make the current state as the new initial state.
   *
   * @remarks
   * **IMPORTANT**: This is a destructive operation. All previous and future history entries are discarded,
   * and the current state (including any unarchived temp patches) becomes the new baseline (position 0). Any subsequent `reset()`
   * calls will return to this new baseline, not the original initial state.
   */
  rebase: () => void;
};