#TypeScript Types

import type {
  Dialogue,
  DialogueConfig,
  DialogueContext,
  AuthData,
  JwtClaims,
  RoomConfig,
  EventDefinition,
  EventHistoryConfig,
  EventMessage,
  ConnectedClient,
  Room,
  HooksConfig,
  Runtime,
  RuntimeAdapter,
  RuntimeStartOptions,
} from "./dialogue";

interface EventDefinition<T = unknown> {
  readonly name: string;
  readonly description?: string;
  readonly schema?: z.ZodType<T>;
  readonly history?: EventHistoryConfig;
}

interface EventHistoryConfig {
  /** Whether to store this event type in history */
  enabled: boolean;
  /** Maximum number of events to keep in memory per room */
  limit: number;
}

interface EventMessage<T = unknown> {
  event: string;
  roomId: string;
  data: T;
  from: string;
  timestamp: number;
}

interface DialogueContext {
  io: Server;                              // Socket.IO server instance
  clients: Record<string, ConnectedClient>; // All connected clients
  rooms: Record<string, Room>;             // All active rooms
}

interface AuthData {
  jwt: JwtClaims;
  // Additional authentication fields can be added
}

interface JwtClaims {
  sub: string;      // Subject (user ID)
  exp: number;      // Expiration timestamp
  iat: number;      // Issued at timestamp
  [key: string]: unknown;  // Additional custom claims
}

type Runtime = "bun" | "node";

interface RuntimeAdapter {
  /** The runtime this adapter targets */
  readonly runtime: Runtime;

  /** Bind the Socket.IO server to the runtime-specific engine */
  bind(io: Server): void;

  /** Start the HTTP server on the given port */
  start(options: RuntimeStartOptions): Promise<void>;

  /** Stop the HTTP server and clean up resources */
  stop(): Promise<void>;
}

interface RuntimeStartOptions {
  port: number;
  app: Hono;
  io: Server;
  corsConfig: CorsConfig | boolean | undefined;
  logger: Logger;
}