export type ConnectionHook = (params: {
  agentId: AgentId;
  agentName: string;
  /** Owner user ID resolved at agent/network/connect time. */
  ownerUserId: UserId;
  connId: ConnectionId;
}) => PromiseLike<undefined> | undefined;

export interface ConnectionHooks {
  readonly connectionHooks: readonly ConnectionHook[];
  readonly disconnectionHooks: readonly DisconnectionHook[];
}

export class ConnectionHooksTag extends Context.Tag("moltzap/ConnectionHooks")<
  ConnectionHooksTag,
  ConnectionHooks
>() {}

export interface CoreApp {
  readonly port: number;
  onConnection: (hook: ConnectionHook) => void;

  /**
   * Fires when a WebSocket closes, after auth was established. Use for
   * per-user cleanup (e.g., `last_seen_at` updates). Does not fire for
   * connections that never authenticated.
   */
  onDisconnection: (hook: DisconnectionHook) => void;

  /**
   * Outbound-routing primitive. Apps emit events out-of-band via
   * `networkSendService.send(to, payload)` (directed) or
   * `networkSendService.broadcast(agentIds, payload, opts?)` (fan-out
   * across participants). Stable identity across the server lifetime.
   *
   * The backing `AgentEndpointResolver` is intentionally not exposed —
   * its mutable add/remove surface is server-internal lifecycle, not a
   * CoreApp consumer concern. Tests assert resolver state indirectly
   * via `networkSendService.send` outcomes.
   */
  readonly networkSendService: NetworkSendService;

  /**
   * Live ConnectionManager instance. Apps can query `getByParticipant` to
   * check whether an agent has any live connections (for liveness-gated
   * push decisions, etc.). Stable identity.
   */
  readonly connections: ConnectionManager;
  close: () => PromiseLike<undefined>;
}

export function createCoreApp(config: CoreConfig): CoreApp

export type DisconnectionHook = (params: {
  agentId: AgentId;
  ownerUserId: UserId;
  connId: ConnectionId;
}) => PromiseLike<undefined> | undefined;

export function makeTracingLayer(input: TracingLayerInput): Layer.Layer<never>

export const readDefaultSpanProcessor: Effect.Effect<SpanProcessor | null> =
  Effect.all({
    tracesEndpoint: Config.option(
      Config.string("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT"),
    ),
    baseEndpoint: Config.option(Config.string("OTEL_EXPORTER_OTLP_ENDPOINT")),
  }).pipe(
    Effect.map(({ tracesEndpoint, baseEndpoint }) => {
      const url = resolveTracesEndpoint(
        Option.getOrUndefined(tracesEndpoint),
        Option.getOrUndefined(baseEndpoint),
      );
      return url === null
        ? null
        : new BatchSpanProcessor(new OTLPTraceExporter({ url }));
    }),
    Effect.orElseSucceed(() => null),
  )

export interface ResolvedServices {
  readonly db: Db;
  readonly connections: ConnectionManager;
  readonly agentEndpointResolver: AgentEndpointResolver;
  readonly networkSendService: NetworkSendService;
  readonly authService: AuthService;
  readonly conversationService: ConversationService;
  readonly messageService: MessageService;
}

export const resolveServices = Effect.all({
  db: DbTag,
  connections: ConnectionManagerTag,
  agentEndpointResolver: AgentEndpointResolverTag,
  networkSendService: NetworkSendServiceTag,
  authService: AuthServiceTag,
  conversationService: ConversationServiceTag,
  messageService: MessageServiceTag,
}) satisfies Effect.Effect<ResolvedServices, never, unknown>

export function resolveTracesEndpoint(
  tracesEndpoint?: string,
  baseEndpoint?: string,
): string | null

export class ServerBootFailedError extends Data.TaggedError(
  "ServerBootFailedError",
)<{
  readonly phase: "http-listen";
  readonly cause: unknown;
}> {}

export const servicesLive = Layer.provideMerge(
  messageServiceLive,
  conversationWithNetworkLive,
)