import { EnvironmentId } from "@t3tools/contracts";
import { RelayEnvironmentStatusScope } from "@t3tools/contracts/relay";
import { describe, expect, it } from "@effect/vitest";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as TestClock from "effect/testing/TestClock";

import {
  MANAGED_RELAY_REQUEST_TIMEOUT_MS,
  ManagedRelayClient,
  ManagedRelayDpopSigner,
  managedRelayClientLayer,
  type ManagedRelayDpopProofInput,
} from "./managedRelay.ts";
import { remoteHttpClientLayer } from "./remote.ts";

function managedRelayTestLayer(
  fetchFn: typeof globalThis.fetch,
  relayUrl = "https://relay.example.test",
) {
  const httpClientLayer = remoteHttpClientLayer(fetchFn);
  const signerLayer = Layer.succeed(
    ManagedRelayDpopSigner,
    ManagedRelayDpopSigner.of({
      thumbprint: Effect.succeed("client-thumbprint"),
      createProof: (input: ManagedRelayDpopProofInput) => Effect.succeed(`proof:${input.url}`),
    }),
  );
  return managedRelayClientLayer({
    relayUrl,
    clientId: "t3-mobile",
  }).pipe(Layer.provide(signerLayer), Layer.provide(httpClientLayer));
}

describe("ManagedRelayClient", () => {
  it.effect("rejects unsafe relay URLs before sending credentials", () => {
    let requestCount = 0;
    const fetchFn = (() => {
      requestCount += 1;
      return Promise.resolve(Response.json({}));
    }) satisfies typeof globalThis.fetch;

    return Effect.gen(function* () {
      const relayClient = yield* ManagedRelayClient;
      const error = yield* relayClient
        .listEnvironments({ clerkToken: "clerk-token" })
        .pipe(Effect.flip);

      expect(error).toMatchObject({
        _tag: "ManagedRelayClientError",
        message: "Relay URL must be a secure absolute HTTPS origin.",
      });
      expect(requestCount).toBe(0);
    }).pipe(Effect.provide(managedRelayTestLayer(fetchFn, "http://relay.example.test")));
  });

  it.effect("reuses usable DPoP tokens and refreshes cleared or expiring cache entries", () => {
    let tokenExchangeCount = 0;
    const fetchFn = ((input) => {
      const url = String(input);
      if (url.endsWith("/v1/client/dpop-token")) {
        tokenExchangeCount += 1;
        return Promise.resolve(
          Response.json({
            access_token: `relay-token-${tokenExchangeCount}`,
            issued_token_type: "urn:ietf:params:oauth:token-type:access_token",
            token_type: "DPoP",
            expires_in: 10,
            scope: RelayEnvironmentStatusScope,
          }),
        );
      }
      return Promise.resolve(
        Response.json({
          environmentId: "env-1",
          endpoint: {
            httpBaseUrl: "https://desktop.example.test/",
            wsBaseUrl: "wss://desktop.example.test/ws",
            providerKind: "cloudflare_tunnel",
          },
          status: "online",
          checkedAt: "2026-05-25T00:01:00.000Z",
          descriptor: {
            environmentId: "env-1",
            label: "Desktop",
            platform: { os: "darwin", arch: "arm64" },
            serverVersion: "0.0.0-test",
            capabilities: { repositoryIdentity: true },
          },
        }),
      );
    }) satisfies typeof globalThis.fetch;

    return Effect.gen(function* () {
      const relayClient = yield* ManagedRelayClient;
      const statusInput = {
        clerkToken: "clerk-token",
        scopes: [RelayEnvironmentStatusScope],
        environmentId: EnvironmentId.make("env-1"),
      } as const;

      yield* relayClient.getEnvironmentStatus(statusInput);
      yield* relayClient.getEnvironmentStatus(statusInput);
      expect(tokenExchangeCount).toBe(1);

      yield* TestClock.adjust(Duration.seconds(6));
      yield* relayClient.getEnvironmentStatus(statusInput);
      expect(tokenExchangeCount).toBe(2);

      yield* relayClient.resetTokenCache;
      yield* relayClient.getEnvironmentStatus(statusInput);
      expect(tokenExchangeCount).toBe(3);
    }).pipe(Effect.provide(managedRelayTestLayer(fetchFn)));
  });

  it.effect("times out stalled relay environment listing requests", () => {
    const fetchFn = (() =>
      new Promise<Response>(() => undefined)) satisfies typeof globalThis.fetch;

    return Effect.gen(function* () {
      const relayClient = yield* ManagedRelayClient;
      const errorFiber = yield* relayClient
        .listEnvironments({ clerkToken: "clerk-token" })
        .pipe(Effect.flip, Effect.forkScoped);

      yield* Effect.yieldNow;
      yield* TestClock.adjust(Duration.millis(MANAGED_RELAY_REQUEST_TIMEOUT_MS));
      const error = yield* Fiber.join(errorFiber);

      expect(error).toMatchObject({
        _tag: "ManagedRelayClientError",
        message: "Relay environment listing timed out.",
      });
    }).pipe(Effect.provide(Layer.merge(TestClock.layer(), managedRelayTestLayer(fetchFn))));
  });

  it.effect("lists account devices through the Clerk bearer client endpoint", () => {
    const fetchFn = ((input, init) => {
      expect(String(input)).toBe("https://relay.example.test/v1/client/devices");
      expect(init?.headers).toMatchObject({
        authorization: "Bearer clerk-token",
      });
      return Promise.resolve(
        Response.json({
          devices: [
            {
              deviceId: "device-1",
              label: "Julius's iPhone",
              platform: "ios",
              iosMajorVersion: 18,
              appVersion: "1.0.0",
              notifications: {
                enabled: false,
                notifyOnApproval: true,
                notifyOnInput: true,
                notifyOnCompletion: true,
                notifyOnFailure: true,
              },
              liveActivities: {
                enabled: true,
              },
              updatedAt: "2026-06-01T00:00:00.000Z",
            },
          ],
        }),
      );
    }) satisfies typeof globalThis.fetch;

    return Effect.gen(function* () {
      const relayClient = yield* ManagedRelayClient;
      const devices = yield* relayClient.listDevices({ clerkToken: "clerk-token" });
      expect(devices).toMatchObject([
        {
          deviceId: "device-1",
          label: "Julius's iPhone",
          notifications: {
            enabled: false,
          },
        },
      ]);
    }).pipe(Effect.provide(managedRelayTestLayer(fetchFn)));
  });
});