// ---------------------------------------------------------------------------
// Per-request layer provisioning for `HttpRouter.toWebHandler`
// ---------------------------------------------------------------------------
//
// `HttpRouter.toWebHandler` builds the application layer once into a
// boot-scoped `Context` and reuses it for every request, so any
// `Effect.acquireRelease` inside that layer fires once at worker boot.
// On Cloudflare Workers a postgres.js socket (a `Writable` I/O object)
// opened during request 1 cannot be touched from request 2 — the
// runtime throws "Cannot perform I/O on behalf of a different request".
//
// `Layer.provideMerge` and (despite the name) `HttpRouter.provideRequest`
// both build the inner layer at construction time. The only primitive
// that actually rebuilds per request is a router middleware whose
// per-request handler builds the layer with a *fresh* `MemoMap` and a
// per-request scope, so `acquireRelease` fires per request. Background work
// retains that scope until its database writes finish; the response need not
// wait, but the platform keep-alive must include resource cleanup too.
//
// The fresh `MemoMap` matters: `Layer.build` would otherwise inherit
// `CurrentMemoMap` from the boot context (`HttpRouter.toWebHandler`
// installs one when it builds the app layer). Cloudflare Workers serves
// concurrent requests from the same isolate, and the boot MemoMap is
// shared across those request fibers — so two in-flight requests would
// both reuse the first one's memoized layer build (one postgres socket
// shared across two request handlers, which the runtime forbids). A
// per-request MemoMap scopes memoization to a single request fiber.
//
// See `apps/cloud/src/api.request-scope.node.test.ts` for the regression
// coverage that pins this rule down (sequential AND concurrent cases).
// ---------------------------------------------------------------------------

import { Context, Effect, Layer, Scope } from "effect";
import { HttpRouter } from "effect/unstable/http";

/**
 * Retain this request's resources for already-started background work. The
 * caller owns task error reporting; the returned promise settles only after
 * all retained tasks AND resource finalizers finish, for the host's waitUntil.
 */
export class RequestBackgroundTasks extends Context.Service<
  RequestBackgroundTasks,
  { readonly retain: (task: Promise<unknown>) => Promise<void> }
>()("@executor-js/api/RequestBackgroundTasks") {}

/**
 * Build an `HttpRouter.middleware` that provides `layer`'s services to
 * each request. The layer is rebuilt per HTTP request so
 * `Effect.acquireRelease` fires per request. Resources close after the handler
 * and its registered background work settle, without delaying the response.
 *
 * The returned value is a `Middleware`. Use `.layer` to apply it as a
 * standalone layer; use `.combine(other)` to fold it into another
 * middleware whose per-request body needs services this layer provides
 * (e.g. `ExecutionStackMiddleware`'s auth logic that yields
 * `DbService` + `UserStoreService` — combining drops those from the
 * outer middleware's `requires`).
 */
export const requestScopedMiddleware = <A>(layer: Layer.Layer<A>) =>
  HttpRouter.middleware<{ provides: A | RequestBackgroundTasks }>()((httpEffect) =>
    Effect.uninterruptibleMask((restore) =>
      Effect.gen(function* () {
        const scope = yield* Scope.make();
        const pending = new Set<Promise<void>>();
        const released = Promise.withResolvers<void>();
        const background = RequestBackgroundTasks.of({
          retain: (task) => {
            // SDK tasks report their own failures. Both outcomes release the
            // resource lease; a rejected task must not leak its database.
            const settled = task.then(
              () => {
                pending.delete(settled);
              },
              () => {
                pending.delete(settled);
              },
            );
            pending.add(settled);
            return released.promise;
          },
        });
        return yield* restore(
          Effect.gen(function* () {
            // Never inherit the boot MemoMap: concurrent requests each own
            // their socket, including after either response has been sent.
            const memoMap = yield* Layer.makeMemoMap;
            const services = yield* Layer.buildWithMemoMap(layer, memoMap, scope);
            return yield* Effect.provideContext(httpEffect, services);
          }).pipe(
            Effect.provideService(Scope.Scope, scope),
            Effect.provideService(RequestBackgroundTasks, background),
          ),
        ).pipe(
          Effect.onExit((exit) => {
            const release = Effect.gen(function* () {
              // A retained task may start another task before it settles.
              while (pending.size > 0) {
                yield* Effect.promise(() => Promise.all(pending));
              }
            }).pipe(
              Effect.ensuring(Scope.close(scope, exit)),
              Effect.ensuring(Effect.sync(() => released.resolve())),
            );
            // With no background work, preserve synchronous teardown. Otherwise
            // the resource owner, including cleanup, is kept alive by the host.
            return pending.size === 0 ? release : release.pipe(Effect.forkDetach, Effect.asVoid);
          }),
        );
      }),
    ),
  );