import { EnvironmentId } from "@t3tools/contracts";
import type {
  RelayClientDeviceRecord,
  RelayClientEnvironmentRecord,
  RelayEnvironmentStatusResponse,
} from "@t3tools/contracts/relay";
import { assert, describe, expect, it } from "@effect/vitest";
import * as Deferred from "effect/Deferred";
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 Option from "effect/Option";
import * as Stream from "effect/Stream";
import * as TestClock from "effect/testing/TestClock";
import { Atom, AtomRegistry } from "effect/unstable/reactivity";
import { afterEach, vi } from "vite-plus/test";

import * as ManagedRelay from "./managedRelay.ts";
import {
  createManagedRelayQueryManager,
  createManagedRelaySession,
  managedRelayAccountChanges,
  type ManagedRelayQueryEvent,
  managedRelaySessionAtom,
  readManagedRelaySnapshotState,
  setManagedRelaySession,
  waitForManagedRelayClerkToken,
} from "./managedRelayState.ts";

let registry = AtomRegistry.make();

const environment = {
  environmentId: EnvironmentId.make("environment-1"),
  label: "Main environment",
  endpoint: {
    httpBaseUrl: "https://environment.example.test",
    wsBaseUrl: "wss://environment.example.test",
    providerKind: "cloudflare_tunnel",
  },
  linkedAt: "2026-06-01T00:00:00.000Z",
} satisfies RelayClientEnvironmentRecord;

const device = {
  deviceId: "device-1",
  label: "Julius iPhone",
  platform: "ios",
  iosMajorVersion: 18,
  appVersion: null,
  notifications: {
    enabled: true,
    notifyOnApproval: true,
    notifyOnInput: true,
    notifyOnCompletion: true,
    notifyOnFailure: true,
  },
  liveActivities: {
    enabled: true,
  },
  updatedAt: "2026-06-01T00:00:00.000Z",
} satisfies RelayClientDeviceRecord;

function resetRegistry() {
  registry.dispose();
  registry = AtomRegistry.make();
}

function createManager(
  overrides?: Partial<ManagedRelay.ManagedRelayClient["Service"]>,
  onQueryEvent?: (event: ManagedRelayQueryEvent) => void,
) {
  const client = ManagedRelay.ManagedRelayClient.of({
    relayUrl: "https://relay.example.test",
    listEnvironments: () => Effect.succeed([environment]),
    listDevices: () => Effect.succeed([device]),
    createEnvironmentLinkChallenge: () => Effect.die("unused"),
    linkEnvironment: () => Effect.die("unused"),
    unlinkEnvironment: () => Effect.die("unused"),
    getEnvironmentStatus: () =>
      Effect.succeed({
        environmentId: environment.environmentId,
        endpoint: environment.endpoint,
        status: "online",
        checkedAt: "2026-06-01T00:00:00.000Z",
      }),
    connectEnvironment: () => Effect.die("unused"),
    registerDevice: () => Effect.die("unused"),
    unregisterDevice: () => Effect.die("unused"),
    registerLiveActivity: () => Effect.die("unused"),
    resetTokenCache: Effect.void,
    ...overrides,
  });
  const runtime = Atom.runtime(Layer.succeed(ManagedRelay.ManagedRelayClient, client));
  return createManagedRelayQueryManager(runtime, {
    staleTimeMs: 60_000,
    ...(onQueryEvent ? { onQueryEvent } : {}),
  });
}

function setSession() {
  setManagedRelaySession(registry, {
    accountId: "account-1",
    readClerkToken: () => Effect.succeed(Option.some("clerk-token")),
  });
}

function clerkToken(expiresAtSeconds: number): string {
  const encode = (value: unknown) =>
    btoa(JSON.stringify(value)).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "");
  return `${encode({ alg: "none" })}.${encode({ exp: expiresAtSeconds })}.signature`;
}

describe("createManagedRelayQueryManager", () => {
  afterEach(resetRegistry);

  it.effect("waits for the current cloud session before reading its token", () =>
    Effect.gen(function* () {
      const tokenFiber = yield* waitForManagedRelayClerkToken(registry).pipe(Effect.forkChild);

      setSession();

      assert.equal(yield* Fiber.join(tokenFiber), "clerk-token");
      assert.equal(registry.getNodes().get(managedRelaySessionAtom)?.listeners.size, 0);
    }),
  );

  it.effect("deduplicates concurrent Clerk token reads and reuses the token until JWT expiry", () =>
    Effect.gen(function* () {
      const token = clerkToken(4_102_444_800);
      const tokenDeferred = yield* Deferred.make<string>();
      const readClerkToken = vi.fn(() =>
        Deferred.await(tokenDeferred).pipe(Effect.map(Option.some)),
      );
      const session = createManagedRelaySession({
        accountId: "account-1",
        readClerkToken,
      });

      const readsFiber = yield* Effect.all([session.readClerkToken(), session.readClerkToken()], {
        concurrency: "unbounded",
      }).pipe(Effect.forkChild);
      yield* Effect.yieldNow;
      assert.equal(readClerkToken.mock.calls.length, 1);

      yield* Deferred.succeed(tokenDeferred, token);
      assert.deepEqual(yield* Fiber.join(readsFiber), [Option.some(token), Option.some(token)]);
      assert.equal(Option.getOrThrow(yield* session.readClerkToken()), token);
      assert.equal(readClerkToken.mock.calls.length, 1);
    }),
  );

  it.effect("refreshes the cached Clerk token after JWT expiry using TestClock", () =>
    Effect.gen(function* () {
      const firstToken = clerkToken(10);
      const secondToken = clerkToken(30);
      const tokens = [firstToken, secondToken];
      const readClerkToken = vi.fn(() =>
        Effect.sync(() => Option.some(tokens.shift() ?? "unexpected-token")),
      );
      const session = createManagedRelaySession({
        accountId: "account-1",
        readClerkToken,
      });

      assert.equal(Option.getOrThrow(yield* session.readClerkToken()), firstToken);
      assert.equal(Option.getOrThrow(yield* session.readClerkToken()), firstToken);
      assert.equal(readClerkToken.mock.calls.length, 1);

      yield* TestClock.adjust(Duration.seconds(6));

      assert.equal(Option.getOrThrow(yield* session.readClerkToken()), secondToken);
      assert.equal(readClerkToken.mock.calls.length, 2);
    }).pipe(Effect.provide(TestClock.layer())),
  );

  it.effect("updates the token provider without replacing a same-account session", () =>
    Effect.gen(function* () {
      const firstRead = vi.fn(() => Effect.succeed(Option.none<string>()));
      setManagedRelaySession(registry, {
        accountId: "account-1",
        readClerkToken: firstRead,
      });
      const firstSession = registry.get(managedRelaySessionAtom);
      expect(firstSession).not.toBeNull();
      assert.isTrue(Option.isNone(yield* firstSession!.readClerkToken()));

      const secondRead = vi.fn(() => Effect.succeed(Option.some("refreshed-token")));
      setManagedRelaySession(registry, {
        accountId: "account-1",
        readClerkToken: secondRead,
      });

      expect(registry.get(managedRelaySessionAtom)).toBe(firstSession);
      assert.equal(Option.getOrThrow(yield* firstSession!.readClerkToken()), "refreshed-token");
      assert.equal(firstRead.mock.calls.length, 1);
      assert.equal(secondRead.mock.calls.length, 1);
    }),
  );

  it.effect("does not pin a refreshed session to an older pending token read", () =>
    Effect.gen(function* () {
      const firstTokenDeferred = yield* Deferred.make<string>();
      setManagedRelaySession(registry, {
        accountId: "account-1",
        readClerkToken: () => Deferred.await(firstTokenDeferred).pipe(Effect.map(Option.some)),
      });
      const session = registry.get(managedRelaySessionAtom);
      const firstRead = yield* session!.readClerkToken().pipe(Effect.forkChild);
      yield* Effect.yieldNow;

      setManagedRelaySession(registry, {
        accountId: "account-1",
        readClerkToken: () => Effect.succeed(Option.some("refreshed-token")),
      });

      assert.equal(Option.getOrThrow(yield* session!.readClerkToken()), "refreshed-token");
      yield* Deferred.succeed(firstTokenDeferred, "older-token");
      assert.equal(Option.getOrThrow(yield* Fiber.join(firstRead)), "older-token");
    }),
  );

  it("emits credential changes only when the managed relay account changes", async () => {
    setManagedRelaySession(registry, {
      accountId: "account-1",
      readClerkToken: () => Effect.succeed(Option.some("first-token")),
    });
    const changes = Effect.runPromise(
      managedRelayAccountChanges(registry).pipe(Stream.take(2), Stream.runCollect),
    );
    await vi.waitFor(() => {
      expect(registry.getNodes().get(managedRelaySessionAtom)?.listeners.size).toBeGreaterThan(0);
    });

    setManagedRelaySession(registry, {
      accountId: "account-1",
      readClerkToken: () => Effect.succeed(Option.some("refreshed-token")),
    });
    setManagedRelaySession(registry, {
      accountId: "account-2",
      readClerkToken: () => Effect.succeed(Option.some("second-token")),
    });
    setManagedRelaySession(registry, null);

    expect(Array.from(await changes)).toEqual(["account-2", null]);
  });

  it("shares one Clerk token read across concurrent relay list and status queries", async () => {
    const secondEnvironment = {
      ...environment,
      environmentId: EnvironmentId.make("environment-2"),
      label: "Second environment",
      endpoint: {
        ...environment.endpoint,
        httpBaseUrl: "https://environment-2.example.test",
        wsBaseUrl: "wss://environment-2.example.test",
      },
    } satisfies RelayClientEnvironmentRecord;
    const token = clerkToken(4_102_444_800);
    const readClerkToken = vi.fn(() => Effect.succeed(Option.some(token)));
    const manager = createManager({
      listEnvironments: () => Effect.succeed([environment, secondEnvironment]),
      getEnvironmentStatus: ({ environmentId }) => {
        const current =
          environmentId === environment.environmentId ? environment : secondEnvironment;
        return Effect.succeed({
          environmentId: current.environmentId,
          endpoint: current.endpoint,
          status: "online" as const,
          checkedAt: "2026-06-01T00:00:00.000Z",
        });
      },
    });
    setManagedRelaySession(registry, {
      accountId: "account-1",
      readClerkToken,
    });

    const environmentsAtom = manager.environmentsAtom("account-1");
    const firstStatusAtom = manager.environmentStatusAtom({
      accountId: "account-1",
      environment,
    });
    const secondStatusAtom = manager.environmentStatusAtom({
      accountId: "account-1",
      environment: secondEnvironment,
    });
    registry.get(environmentsAtom);
    registry.get(firstStatusAtom);
    registry.get(secondStatusAtom);

    await vi.waitFor(() => {
      expect(readManagedRelaySnapshotState(registry.get(firstStatusAtom)).data?.status).toBe(
        "online",
      );
      expect(readManagedRelaySnapshotState(registry.get(secondStatusAtom)).data?.status).toBe(
        "online",
      );
    });
    expect(readClerkToken).toHaveBeenCalledTimes(1);
  });

  it("keeps environment snapshots cached and refreshes them explicitly", async () => {
    const listEnvironments = vi.fn(() => Effect.succeed([environment]));
    const manager = createManager({ listEnvironments });
    setSession();
    const atom = manager.environmentsAtom("account-1");

    registry.get(atom);
    await vi.waitFor(() => expect(listEnvironments).toHaveBeenCalledTimes(1));

    registry.get(manager.environmentsAtom("account-1"));
    expect(listEnvironments).toHaveBeenCalledTimes(1);

    manager.refreshEnvironments(registry, "account-1");
    await vi.waitFor(() => expect(listEnvironments).toHaveBeenCalledTimes(2));
  });

  it("loads device snapshots through the current account session", async () => {
    const listDevices = vi.fn(() => Effect.succeed([device]));
    const manager = createManager({ listDevices });
    setSession();
    const atom = manager.devicesAtom("account-1");

    registry.get(atom);
    await vi.waitFor(() => {
      expect(readManagedRelaySnapshotState(registry.get(atom)).data).toEqual([device]);
    });
  });

  it("reports token and relay request phases for environment status queries", async () => {
    const onQueryEvent = vi.fn();
    const manager = createManager(undefined, onQueryEvent);
    setSession();
    const atom = manager.environmentStatusAtom({ accountId: "account-1", environment });

    registry.get(atom);
    await vi.waitFor(() => {
      expect(readManagedRelaySnapshotState(registry.get(atom)).data?.status).toBe("online");
    });

    expect(onQueryEvent).toHaveBeenCalledWith({
      operation: "environment-status",
      stage: "clerk-token",
      phase: "start",
      accountId: "account-1",
      environmentId: environment.environmentId,
    });
    expect(onQueryEvent).toHaveBeenCalledWith(
      expect.objectContaining({
        operation: "environment-status",
        stage: "relay-request",
        phase: "success",
        accountId: "account-1",
        environmentId: environment.environmentId,
      }),
    );
  });

  it("rejects status responses for a different environment", async () => {
    const mismatchedStatus = {
      environmentId: EnvironmentId.make("environment-2"),
      endpoint: environment.endpoint,
      status: "online",
      checkedAt: "2026-06-01T00:00:00.000Z",
    } satisfies RelayEnvironmentStatusResponse;
    const manager = createManager({
      getEnvironmentStatus: () => Effect.succeed(mismatchedStatus),
    });
    setSession();
    const atom = manager.environmentStatusAtom({ accountId: "account-1", environment });

    registry.get(atom);
    await vi.waitFor(() => {
      expect(readManagedRelaySnapshotState(registry.get(atom)).error).toBe(
        "Relay returned status for a different environment.",
      );
    });
  });

  it("exposes relay trace IDs alongside snapshot errors", async () => {
    const manager = createManager({
      getEnvironmentStatus: () =>
        Effect.fail(
          new ManagedRelay.ManagedRelayRequestFailedError({
            action: "get relay environment status",
            cause: new Error("Relay request failed."),
            traceId: "trace-status",
          }),
        ),
    });
    setSession();
    const atom = manager.environmentStatusAtom({ accountId: "account-1", environment });

    registry.get(atom);
    await vi.waitFor(() => {
      expect(readManagedRelaySnapshotState(registry.get(atom))).toMatchObject({
        error: "Could not get relay environment status.",
        errorTraceId: "trace-status",
      });
    });
  });
});