// Regression coverage for `createPluginAtomClient`. The change that
// triggered this test is dropping the explicit `pluginId` option in
// favour of reading `group.identifier`. The properties under test are:
//
//   1. The synthetic `AtomHttpApi.Service` Tag's `.key` is
//      `Plugin_<groupId>Client` — a non-empty Tag id is what makes
//      caching/invalidation work (atoms are deduped per Tag identity;
//      reactivity invalidations are routed by Tag).
//   2. Two clients built from groups with different identifiers get
//      distinct Tag keys — so plugins coexist in one React tree
//      without sharing atom state across plugin boundaries.
//   3. `.query` / `.mutation` return Atom-shaped descriptors —
//      confirms the wrapper still composes the per-plugin `HttpApi`
//      bundle correctly so AtomHttpApi can build the client.
//
// React Testing Library is intentionally not used here. The change
// affected the Tag-derivation path inside `createPluginAtomClient`,
// not the React side of `@effect/atom-react`. Verifying the Tag
// identity + atom shape is what catches a regression in the area we
// modified; mounting components would test `@effect/atom-react`,
// which we did not touch.

import { describe, expect, it } from "@effect/vitest";
import { Schema } from "effect";
import { HttpClientRequest } from "effect/unstable/http";
import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";

import { applyPluginAtomClientRequestTransform, createPluginAtomClient } from "./client";

const FooGroup = HttpApiGroup.make("foo").add(
  HttpApiEndpoint.get("ping", "/ping", { success: Schema.String }),
);

const BarGroup = HttpApiGroup.make("bar").add(
  HttpApiEndpoint.post("set", "/set", {
    payload: Schema.Struct({ value: Schema.String }),
    success: Schema.String,
  }),
);

describe("createPluginAtomClient", () => {
  it("derives the Service Tag id from group.identifier", () => {
    const FooClient = createPluginAtomClient(FooGroup);
    expect(FooClient.key).toBe("Plugin_fooClient");
  });

  it("produces non-colliding Tag ids for groups with different identifiers", () => {
    const A = createPluginAtomClient(FooGroup);
    const B = createPluginAtomClient(BarGroup);
    expect(A.key).not.toBe(B.key);
    expect(A.key).toBe("Plugin_fooClient");
    expect(B.key).toBe("Plugin_barClient");
  });

  it("returns Atom descriptors from `.query` and `.mutation`", () => {
    const FooClient = createPluginAtomClient(FooGroup);
    const BarClient = createPluginAtomClient(BarGroup);

    const ping = FooClient.query("foo", "ping", {});
    const set = BarClient.mutation("bar", "set");

    // Atoms are reachable values — the exact shape is internal to
    // `@effect-atom/atom`. A regression in pluginId derivation would
    // typically surface as a missing-Tag throw inside the runtime
    // before these factories returned anything.
    expect(ping).toBeTruthy();
    expect(set).toBeTruthy();
  });

  it("can apply dynamic server connection URL and auth to plugin requests", () => {
    const request = HttpClientRequest.get("/graphql/integrations");
    const transformed = applyPluginAtomClientRequestTransform(request, {
      baseUrl: () => "https://executor.example/api",
      authorizationHeader: () => "Bearer key_123",
    });

    expect(transformed.url).toBe("https://executor.example/api/graphql/integrations");
    expect(transformed.headers.authorization).toBe("Bearer key_123");
  });

  it("can apply host-supplied dynamic request headers to plugin requests", () => {
    const request = HttpClientRequest.get("/openapi/integrations/acme");
    const transformed = applyPluginAtomClientRequestTransform(request, {
      headers: () => ({
        "x-executor-organization": "newvale",
        "x-empty": null,
      }),
    });

    expect(transformed.headers["x-executor-organization"]).toBe("newvale");
    expect(transformed.headers["x-empty"]).toBeUndefined();
  });
});