import { describe, expect, it } from "@effect/vitest";
import { Effect, Layer } from "effect";
import { SignJWT, createLocalJWKSet, exportJWK, generateKeyPair } from "jose";

import { MemberDirectory } from "@executor-js/api/server";

import { ApiKeyService } from "../auth/api-keys";
import { UserStoreService } from "../auth/context";
import type { JwtBearerConfig } from "../auth/workos-auth-provider";
import { WorkOSClient, type WorkOSClientService } from "../auth/workos";
import { WorkOsMirror, type WorkOsMirrorShape } from "../auth/workos-mirror";
import { resolveProtectedPrincipal } from "./protected";

const createdAt = new Date("2026-01-01T00:00:00.000Z");

// The mirror's account row as `ensureAccount` mints it: id only, profile
// columns unfilled until a WorkOS user payload arrives.
const bareAccount = (id: string) => ({
  id,
  email: null,
  firstName: null,
  lastName: null,
  avatarUrl: null,
  workosUpdatedAt: null,
  lastSignInAt: null,
  createdAt,
});
const issuer = "https://test-authkit.example.com";
const audience = "client_test_audience";

// A WorkOS access-token JWT verifier backed by a local RS256 key pair (no
// network), plus a signer that mints tokens for it. Mirrors
// `mcp/mcp-auth.node.test.ts`.
const makeJwt = async () => {
  const { publicKey, privateKey } = await generateKeyPair("RS256");
  const jwk = await exportJWK(publicKey);
  const jwks = createLocalJWKSet({ keys: [{ ...jwk, kid: "test-key" }] });
  // Device-login tokens are verified by signature alone (client-scoped SSO
  // JWKS); issuer/audience are not pinned.
  const config: JwtBearerConfig = { jwks };
  const sign = (claims: Record<string, unknown>, expiration: string | number = "5m") =>
    new SignJWT(claims)
      .setProtectedHeader({ alg: "RS256", kid: "test-key" })
      .setIssuer(issuer)
      .setAudience(audience)
      .setSubject("user_123")
      .setIssuedAt()
      .setExpirationTime(expiration)
      .sign(privateKey);
  return { config, sign };
};

// The api-key path must never run for a JWT bearer, die loudly if it does.
const stubApiKeys = Layer.succeed(ApiKeyService)({
  validate: () => Effect.die("JWT bearer must not hit ApiKeyService.validate"),
  listUserKeys: () => Effect.succeed([]),
  createUserKey: () => Effect.die("JWT auth test does not create API keys"),
  revokeUserKey: () => Effect.void,
  listOrgKeys: () => Effect.die("auth resolution test does not list org API keys"),
  createOrgKey: () => Effect.die("auth resolution test does not create org API keys"),
  revokeOrgKey: () => Effect.die("auth resolution test does not revoke org API keys"),
});

const stubWorkOS = Layer.succeed(
  WorkOSClient,
  new Proxy({} as WorkOSClientService, {
    get: (_target, prop) => {
      return () => Effect.die(`unexpected WorkOSClient.${String(prop)} call`);
    },
  }),
);

// The mirror as the directory reads it: user_123 holds an active membership in
// org_123 and nothing else. Membership is always read from the mirror, never
// from WorkOS.
const stubDirectory = Layer.succeed(MemberDirectory)({
  membership: (accountId, organizationId) =>
    Effect.succeed(
      accountId === "user_123" && organizationId === "org_123"
        ? {
            accountId,
            membershipId: `om_${accountId}_${organizationId}`,
            organizationId,
            email: null,
            name: null,
            avatarUrl: null,
            role: "member",
            status: "active" as const,
            lastActiveAt: null,
          }
        : null,
    ),
  membershipById: () => Effect.die("bearer resolution does not look up by membership id"),
  membershipsOf: () => Effect.die("bearer resolution reads one membership, not the list"),
  members: () => Effect.die("bearer resolution does not list members"),
  membersById: () => Effect.die("bearer resolution does not batch members"),
  findByEmail: () => Effect.die("bearer resolution does not resolve emails"),
});

const stubUsers = Layer.succeed(UserStoreService)({
  use: (_op, fn) =>
    Effect.promise(() =>
      fn({
        ensureAccount: async (id: string) => bareAccount(id),
        getAccount: async (id: string) => bareAccount(id),
        upsertOrganization: async (org: { id: string; name: string }) => ({
          ...org,
          slug: `org-slug-${org.id}`,
          backfilledAt: createdAt,
          deletedAt: null,
          workosUpdatedAt: null,
          createdAt,
        }),
        getOrganization: async (id: string) => ({
          id,
          name: `Org ${id}`,
          slug: `org-slug-${id}`,
          backfilledAt: createdAt,
          deletedAt: null,
          workosUpdatedAt: null,
          createdAt,
        }),
        getOrganizationBySlug: async (slug: string) => ({
          id: "org_by_slug",
          name: `Org ${slug}`,
          slug,
          backfilledAt: createdAt,
          deletedAt: null,
          workosUpdatedAt: null,
          createdAt,
        }),
        markOrganizationDeleted: async () => null,
        deleteOrganizationCascade: async () => {},
      }),
    ),
});

// Authorization scans an organization the backfill never covered before it
// reads the mirror (`auth/organization.ts`); every org row above is marked
// backfilled, so the scan is never reached and the mirror is never written.
const stubMirror = Layer.succeed(
  WorkOsMirror,
  new Proxy({} as WorkOsMirrorShape, {
    get: (_target, prop) => () => Effect.die(`unexpected WorkOsMirror.${String(prop)} call`),
  }),
);

const run = (request: Request, jwt: JwtBearerConfig) =>
  resolveProtectedPrincipal(request, jwt).pipe(
    Effect.provide(Layer.mergeAll(stubApiKeys, stubWorkOS, stubUsers, stubDirectory, stubMirror)),
  );

const request = (token: string) =>
  new Request("https://executor.test/api/tools", {
    headers: { authorization: `Bearer ${token}` },
  });

describe("protected JWT (device-login) auth", () => {
  it.effect("resolves a valid WorkOS access token into protected identity", () =>
    Effect.gen(function* () {
      const { config, sign } = yield* Effect.promise(() => makeJwt());
      const token = yield* Effect.promise(() => sign({ org_id: "org_123" }));

      const identity = yield* run(request(token), config);

      expect(identity).toEqual({
        kind: "member",
        accountId: "user_123",
        organizationId: "org_123",
        organizationName: "Org org_123",
        organizationSlug: "org-slug-org_123",
        email: "",
        name: null,
        avatarUrl: null,
        roles: [],
        // The stub membership carries no role slug — normalization FAILS
        // CLOSED to plain member, so the executor binds workspace writes off.
        orgRoleModel: "organization",
        orgRole: "member",
      });
    }),
  );

  it.effect("rejects an expired access token as Unauthorized", () =>
    Effect.gen(function* () {
      const { config, sign } = yield* Effect.promise(() => makeJwt());
      // Expired one hour ago.
      const token = yield* Effect.promise(() =>
        sign({ org_id: "org_123" }, Math.floor(Date.now() / 1000) - 3600),
      );

      const error = yield* Effect.flip(run(request(token), config));

      expect(error).toMatchObject({
        _tag: "Unauthorized",
        code: "invalid_access_token",
      });
    }),
  );

  it.effect("rejects a token signed by a different key as Unauthorized", () =>
    Effect.gen(function* () {
      const { config } = yield* Effect.promise(() => makeJwt());
      const other = yield* Effect.promise(() => makeJwt());
      const token = yield* Effect.promise(() => other.sign({ org_id: "org_123" }));

      const error = yield* Effect.flip(run(request(token), config));

      expect(error).toMatchObject({
        _tag: "Unauthorized",
        code: "invalid_access_token",
      });
    }),
  );

  it.effect("rejects a token with no org_id as NoOrganization", () =>
    Effect.gen(function* () {
      const { config, sign } = yield* Effect.promise(() => makeJwt());
      const token = yield* Effect.promise(() => sign({}));

      const error = yield* Effect.flip(run(request(token), config));

      expect(error).toMatchObject({
        _tag: "NoOrganization",
        code: "no_organization",
      });
    }),
  );

  it.effect("rejects a valid token whose org membership is not active", () =>
    Effect.gen(function* () {
      const { config, sign } = yield* Effect.promise(() => makeJwt());
      // org_999 is not in the membership stub -> not authorized.
      const token = yield* Effect.promise(() => sign({ org_id: "org_999" }));

      const error = yield* Effect.flip(run(request(token), config));

      expect(error).toMatchObject({
        _tag: "NoOrganization",
        code: "no_organization",
      });
    }),
  );
});