import * as Effect from "effect/Effect";
import type { Output } from "./Output.ts";
import { type BaseRuntimeContext, RuntimeContext } from "./RuntimeContext.ts";

/**
 * Runtime context bridge that lets an {@link Action} read Resource Outputs.
 *
 * Actions are peculiar: their init Effect runs at plan/stack-eval time (before
 * any resource exists) while their body runs at apply time (after upstreams are
 * materialized). To make `yield* db.databaseId` work inside an Action we split
 * the {@link RuntimeContext} into two cooperating halves that share nothing but
 * a sanitized key:
 *
 *  - {@link makeCaptureContext} is provided while the init Effect runs. Its
 *    `set(key, output)` records the referenced {@link Output} (so the engine can
 *    add a dependency edge and later resolve it) and its `get(key)` hands back a
 *    *deferred* accessor — an Effect that re-reads whatever `RuntimeContext` is
 *    ambient when it actually runs.
 *  - {@link makeResolveContext} is provided around the Action body at apply
 *    time. Its `get(key)` returns the already-resolved value for that key.
 *
 * Because the accessor produced at init re-reads `RuntimeContext`, yielding it
 * inside the body resolves against the apply-time context — no shared mutable
 * state, no infinite recursion (the resolve context's `get` is terminal).
 */

const base = (id: string): Omit<BaseRuntimeContext, "get" | "set"> => ({
  Type: "Action",
  id,
  env: {},
});

/**
 * Capture context — provided while an Action's init Effect runs. Records every
 * Output referenced via `yield* output` into `captures`, keyed by the Output's
 * sanitized key, and returns deferred accessors.
 */
export const makeCaptureContext = (
  captures: Record<string, Output>,
): BaseRuntimeContext => ({
  ...base("capture"),
  set: (key, output) =>
    Effect.sync(() => {
      captures[key] = output as unknown as Output;
      return key;
    }),
  // Deferred: re-read the ambient RuntimeContext at run time. At apply this is
  // the resolve context below; its `get` returns the materialized value. The
  // `RuntimeContext` requirement is erased at the Action boundary (`Run` is
  // typed `Effect<Out, any, any>`) and satisfied by the resolve context, so
  // the accessor presents as `Effect<T | undefined>`.
  get: (<T>(key: string) =>
    Effect.flatMap(RuntimeContext, (ctx) =>
      ctx.get<T>(key),
    )) as BaseRuntimeContext["get"],
});

/**
 * Resolve context — provided around an Action body at apply time. `resolved`
 * maps each captured key to its value (already evaluated against the tracker).
 */
export const makeResolveContext = (
  resolved: Record<string, unknown>,
): BaseRuntimeContext => ({
  ...base("resolve"),
  set: (key) => Effect.succeed(key),
  get: <T>(key: string) => Effect.succeed(resolved[key] as T | undefined),
});