import { expect, test } from "@effect/vitest";
import { FetchHttpClient } from "effect/unstable/http";
import { Effect, Layer } from "effect";

import { makeTelemetryLive } from "./telemetry";

// The layer is opaque, so these assert the observable consequence rather than
// its shape: what the exporter puts on the wire, and — for the default — that
// nothing goes on the wire at all.
test("sends nothing when no OTLP endpoint is configured", async () => {
  expect(await captureExports({}, { log: true })).toEqual([]);
});

test("exports spans when the base endpoint is set", async () => {
  const requests = await captureExports({ OTEL_EXPORTER_OTLP_ENDPOINT: "http://collector.test" });
  expect(requests).toHaveLength(1);
  expect(requests[0]?.method).toBe("POST");
});

// The signal endpoint is already a full URL; appending /v1/traces to it would
// POST to /v1/traces/v1/traces, which a collector answers with a 404 the
// operator never sees. Asserted on the request the exporter actually makes.
test("does not append a second signal path to an explicit traces endpoint", async () => {
  const urls = await captureExportUrls({
    OTEL_EXPORTER_OTLP_TRACES_ENDPOINT: "http://collector.test/v1/traces",
  });
  expect(urls).toEqual(["http://collector.test/v1/traces"]);
});

test("appends the signal path to a base endpoint, trailing slash or not", async () => {
  expect(await captureExportUrls({ OTEL_EXPORTER_OTLP_ENDPOINT: "http://collector.test" })).toEqual(
    ["http://collector.test/v1/traces"],
  );
  expect(
    await captureExportUrls({ OTEL_EXPORTER_OTLP_ENDPOINT: "http://collector.test///" }),
  ).toEqual(["http://collector.test/v1/traces"]);
});

test("sends configured headers so a hosted collector can authenticate", async () => {
  const headers = await captureExportHeaders({
    OTEL_EXPORTER_OTLP_ENDPOINT: "http://collector.test",
    OTEL_EXPORTER_OTLP_HEADERS: "authorization=Bearer tok, x-dataset=executor",
  });
  expect(headers?.authorization).toBe("Bearer tok");
  expect(headers?.["x-dataset"]).toBe("executor");
});

// A collector that is down, unreachable through the tunnel, or answering 500
// must never take the request that produced the span with it — the operator
// enabled tracing to diagnose a problem, not to acquire a new one.
test("a failing collector does not fail the traced effect", async () => {
  const result = await Effect.runPromise(
    Effect.succeed("served").pipe(
      Effect.withSpan("probe"),
      Effect.provide(
        makeTelemetryLive({ OTEL_EXPORTER_OTLP_ENDPOINT: "http://collector.test" }).pipe(
          Layer.provide(stubFetch(() => new Response("boom", { status: 500 }))),
        ),
      ),
      Effect.scoped,
    ),
  );
  expect(result).toBe("served");
});

test("log export stays off unless separately opted in", async () => {
  const base = { OTEL_EXPORTER_OTLP_ENDPOINT: "http://collector.test" };
  expect(await captureExportUrls(base, { log: true })).toEqual(["http://collector.test/v1/traces"]);
  expect(
    await captureExportUrls({ ...base, EXECUTOR_OTEL_EXPORT_LOGS: "true" }, { log: true }),
  ).toEqual(
    expect.arrayContaining(["http://collector.test/v1/traces", "http://collector.test/v1/logs"]),
  );
});

// With only a traces endpoint there is no base to derive a logs URL from.
// Guessing one would POST logs to a path the operator never named.
test("log export needs its own endpoint when only traces is configured", async () => {
  const urls = await captureExportUrls(
    {
      OTEL_EXPORTER_OTLP_TRACES_ENDPOINT: "http://collector.test/v1/traces",
      EXECUTOR_OTEL_EXPORT_LOGS: "true",
    },
    { log: true },
  );
  expect(urls).toEqual(["http://collector.test/v1/traces"]);
});

// --- helpers ---------------------------------------------------------------

// `Fetch` is a Context.Reference with `globalThis.fetch` as its default, so
// setting it discharges no requirement — the layer is `Layer<never>` and works
// by overriding the default in whatever context it is provided to.
const stubFetch = (respond: (request: Request) => Response): Layer.Layer<never> =>
  Layer.succeed(FetchHttpClient.Fetch)(((input: RequestInfo | URL, init?: RequestInit) =>
    Promise.resolve(
      respond(input instanceof Request ? input : new Request(String(input), init)),
    )) as typeof globalThis.fetch);

/**
 * Runs a traced effect against a recording fetch and returns the URLs the
 * exporter posted to. The layer's shutdown flush is what forces the export, so
 * the effect is scoped and the scope closed before reading.
 */
const captureExportUrls = async (
  env: Record<string, string | undefined>,
  options?: { readonly log?: boolean },
): Promise<Array<string>> => (await captureExports(env, options)).map((request) => request.url);

const captureExportHeaders = async (
  env: Record<string, string | undefined>,
): Promise<Record<string, string> | undefined> => {
  const requests = await captureExports(env);
  const headers = requests[0]?.headers;
  return headers ? Object.fromEntries(headers.entries()) : undefined;
};

const captureExports = async (
  env: Record<string, string | undefined>,
  options?: { readonly log?: boolean },
): Promise<Array<Request>> => {
  const seen: Array<Request> = [];
  await Effect.runPromise(
    Effect.gen(function* () {
      if (options?.log) yield* Effect.logInfo("probe log");
    }).pipe(
      Effect.withSpan("probe"),
      Effect.provide(
        makeTelemetryLive(env).pipe(
          Layer.provide(
            stubFetch((request) => {
              seen.push(request);
              return new Response(null, { status: 200 });
            }),
          ),
        ),
      ),
      Effect.scoped,
    ),
  );
  return seen;
};