/**
 * ProviderEventLoggers — single observability service that owns the shared
 * provider event log store and exposes its two runtime views:
 *
 *   - `native`    — provider-protocol events as the SDK emits them, written
 *                   from inside each `<X>Adapter` factory.
 *   - `canonical` — runtime events after `ProviderService` has normalized
 *                   them onto `ProviderRuntimeEvent`.
 *
 * Why a service tag and not constructor options?
 *
 *   - Adapters are now constructed *inside* drivers (`<X>Driver.create()`),
 *     not at the boot Layer. There is no longer a single `make<X>AdapterLive(options)`
 *     call site where we can hand an `EventNdjsonLogger` in by hand.
 *   - Multiple driver instances per kind (`codex_personal`, `codex_work`)
 *     must share one underlying log store — opening N writers against the
 *     same rotating file would race the rotation logic. Owning the loggers on
 *     a single tag keeps that invariant intact.
 *   - Tests can swap one (or both) loggers with in-memory recorders by
 *     `Layer.succeed(ProviderEventLoggers, { native, canonical })` instead of
 *     juggling per-Layer option threading.
 *
 * Both fields are optional because observability must not prevent startup.
 *
 * @module provider/Layers/ProviderEventLoggers
 */
import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";

import { ServerConfig } from "../../config.ts";
import * as ResourceAttribution from "../../resourceTelemetry/ResourceAttribution.ts";
import * as EventNdjsonLogger from "./EventNdjsonLogger.ts";

/**
 * Shared logger pair for native + canonical provider event streams.
 *
 * Service value is intentionally a struct of two optional loggers rather
 * than two parallel tags. Construction site is one place
 * (`layer`); consumers (drivers, `ProviderService`) read one tag and pluck the
 * field they need.
 */
export class ProviderEventLoggers extends Context.Service<
  ProviderEventLoggers,
  {
    readonly native: EventNdjsonLogger.EventNdjsonLogger | undefined;
    readonly canonical: EventNdjsonLogger.EventNdjsonLogger | undefined;
  }
>()("t3/provider/Layers/ProviderEventLoggers") {}

/**
 * Constant value used by tests / boot layers that want to opt out of native
 * + canonical logging entirely. Keeps the tag non-optional in the type
 * system while letting the runtime treat absence as a no-op.
 */
export const NoOpProviderEventLoggers: ProviderEventLoggers["Service"] = {
  native: undefined,
  canonical: undefined,
};

/**
 * Builds both stream views over one shared store. Setup failures are logged
 * and downgraded to the no-op service so diagnostics never block startup.
 *
 * @public Service construction is part of the canonical Effect module API.
 */
export const make = Effect.gen(function* () {
  const { providerEventLogPath } = yield* ServerConfig;
  const attribution = yield* ResourceAttribution.ResourceAttribution;
  const store = yield* EventNdjsonLogger.makeEventNdjsonLogStore(providerEventLogPath, {
    attribution,
  }).pipe(
    Effect.catch((error) =>
      Effect.logWarning(error.message, { error }).pipe(
        Effect.annotateLogs({ scope: "provider-observability" }),
        Effect.as<EventNdjsonLogger.EventNdjsonLogStore | undefined>(undefined),
      ),
    ),
  );

  if (!store) {
    return ProviderEventLoggers.of(NoOpProviderEventLoggers);
  }

  yield* Effect.addFinalizer(() => store.close());
  return ProviderEventLoggers.of({
    native: store.logger("native"),
    canonical: store.logger("canonical"),
  });
});

export const layer = Layer.effect(ProviderEventLoggers, make);