import {
  answerEventInstance,
  createEventInstance,
  getPendingEventInstances,
  resolveEventInstance,
} from '../../database/index.js';
import { eventCatalog } from './catalog/index.js';
import { EventEngine } from './engine/EventEngine.js';
import { EventResponder, type EventResponseInput } from './engine/respond.js';
import { createEventRegistry } from './registry.js';
import type {
  EventErrorEnvelope,
  EventPlayerContext,
  EventPromptEnvelope,
  EventResolvedEnvelope,
} from './types.js';

export interface EventRuntime {
  promptNext(
    player: EventPlayerContext
  ): Promise<EventPromptEnvelope | EventResolvedEnvelope | null>;
  respond(
    player: EventPlayerContext,
    input: EventResponseInput
  ): Promise<EventResolvedEnvelope | EventErrorEnvelope>;
}

const registry = createEventRegistry(eventCatalog);
const store = {
  createEventInstance,
  getPendingEventInstances,
  answerEventInstance,
  resolveEventInstance,
};
const engine = new EventEngine(registry, store);
const responder = new EventResponder(registry, store);

const defaultRuntime: EventRuntime = {
  promptNext: (player) => engine.promptNext(player),
  respond: (player, input) => responder.respond(player, input),
};

let runtimeOverride: EventRuntime | null = null;

export function getEventRuntime(): EventRuntime {
  return runtimeOverride ?? defaultRuntime;
}

export function setEventRuntimeForTesting(runtime: EventRuntime | null): void {
  runtimeOverride = runtime;
}