// ---------------------------------------------------------------------------
// @executor-js/plugin-toolkits/server
//
// The server half of the toolkits plugin. A toolkit is a named slice of the
// caller's connections, persisted as owner-scoped plugin storage:
//   - workspace toolkit  -> owner "org"  (visible to every org member)
//   - personal toolkit   -> owner "user" (visible only to its creator)
// The pluginStorage facade is already request-bound to (tenant, subject), so
// the org/user owner literal is the entire workspace-vs-personal visibility
// story. Slice 1 ships data + CRUD only — no MCP narrowing yet.
//
// React and other browser-only deps live in `./client` — never here.
// ---------------------------------------------------------------------------

import { Schema } from "effect";
import { Context, definePlugin, Effect, HttpApiBuilder } from "@executor-js/sdk/core";
import {
  definePluginStorageCollection,
  Owner,
  type PluginCtx,
  type RequestScope,
  type StorageFailure,
} from "@executor-js/sdk";
import { addGroup, capture } from "@executor-js/api";

import {
  ToolkitForbidden,
  ToolkitNotFound,
  ToolkitsApi,
  type CreateToolkitPayload,
  type ToolkitAccess,
  type ToolkitPolicyAction,
  type ToolkitScope,
  type ToolkitView,
  type UpdateToolkitPayload,
} from "./shared";
import {
  EMPTY_TOOLKIT_SCOPE,
  toolkitScopeToRequestScope,
  type ResolvedToolkitScope,
} from "./toolkit-scope";

const ORG = Owner.make("org");
const USER = Owner.make("user");

// ---------------------------------------------------------------------------
// Storage rows (internal — not the HTTP contract). Keyed by uuid, never by a
// user-supplied value (long keyed values hit a fumadb keyed-lookup bug).
// ---------------------------------------------------------------------------

const ToolkitRow = Schema.Struct({
  slug: Schema.String,
  name: Schema.String,
  inheritOrgPolicies: Schema.Boolean,
  briefing: Schema.NullOr(Schema.String),
});

const ConnectionRow = Schema.Struct({
  toolkitId: Schema.String,
  integration: Schema.String,
  connection: Schema.String,
  access: Schema.String,
  note: Schema.NullOr(Schema.String),
});

const PolicyRow = Schema.Struct({
  toolkitId: Schema.String,
  pattern: Schema.String,
  action: Schema.String,
});

const TOOLKITS = definePluginStorageCollection("toolkits", ToolkitRow, {
  indexes: ["slug"],
});
const CONNECTIONS = definePluginStorageCollection("connections", ConnectionRow, {
  indexes: ["toolkitId"],
});
const POLICIES = definePluginStorageCollection("policies", PolicyRow, {
  indexes: ["toolkitId"],
});

const newId = Effect.sync(() => crypto.randomUUID());
const scopeOfOwner = (owner: Owner): ToolkitScope => (owner === ORG ? "workspace" : "personal");

// ---------------------------------------------------------------------------
// Extension — the canonical implementation. Handlers (and later the MCP
// contribution) all hit this same code path.
// ---------------------------------------------------------------------------

type ToolkitRowEntry = {
  readonly key: string;
  readonly owner: Owner;
  readonly data: typeof ToolkitRow.Type;
};

const makeToolkitsExtension = (ctx: PluginCtx) => {
  const toolkits = ctx.pluginStorage.collection(TOOLKITS);
  const connections = ctx.pluginStorage.collection(CONNECTIONS);
  const policies = ctx.pluginStorage.collection(POLICIES);

  const viewFromRow = (row: ToolkitRowEntry) =>
    Effect.gen(function* () {
      const conns = yield* connections.query({ where: { toolkitId: row.key } });
      const pols = yield* policies.query({ where: { toolkitId: row.key } });
      return {
        id: row.key,
        slug: row.data.slug,
        name: row.data.name,
        scope: scopeOfOwner(row.owner),
        inheritOrgPolicies: row.data.inheritOrgPolicies,
        briefing: row.data.briefing,
        connections: conns.map((c) => ({
          integration: c.data.integration as ToolkitConnectionIntegration,
          connection: c.data.connection,
          access: c.data.access as ToolkitAccess,
          ...(c.data.note == null ? {} : { note: c.data.note }),
        })),
        policies: pols.map((p) => ({
          pattern: p.data.pattern,
          action: p.data.action as ToolkitPolicyAction,
        })),
      } satisfies ToolkitView;
    });

  // candidate connections honoring scope: a workspace toolkit may use only
  // org connections; a personal toolkit may use org + the caller's own.
  const candidateConnections = (scope: ToolkitScope) =>
    scope === "workspace" ? ctx.connections.list({ owner: ORG }) : ctx.connections.list();

  const validate = (scope: ToolkitScope, entries: ReadonlyArray<ToolkitConnectionEntryInput>) =>
    Effect.gen(function* () {
      const allowed = yield* candidateConnections(scope);
      const pairs = new Set(allowed.map((c) => `${c.integration}/${c.name}`));
      const integrations = new Set(allowed.map((c) => c.integration));
      for (const e of entries) {
        const ok =
          e.connection === "*"
            ? integrations.has(e.integration)
            : pairs.has(`${e.integration}/${e.connection}`);
        if (!ok) {
          return yield* new ToolkitForbidden({
            reason: `connection ${e.integration}/${e.connection} is not available to a ${scope} toolkit`,
          });
        }
      }
    });

  const putConnections = (
    toolkitId: string,
    owner: Owner,
    entries: ReadonlyArray<ToolkitConnectionEntryInput>,
  ) =>
    Effect.forEach(entries, (e) =>
      newId.pipe(
        Effect.flatMap((cid) =>
          connections.put({
            key: cid,
            owner,
            data: {
              toolkitId,
              integration: e.integration,
              connection: e.connection,
              access: e.access,
              note: e.note ?? null,
            },
          }),
        ),
      ),
    );

  const putPolicies = (
    toolkitId: string,
    owner: Owner,
    rules: ReadonlyArray<{ readonly pattern: string; readonly action: string }>,
  ) =>
    Effect.forEach(rules, (r) =>
      newId.pipe(
        Effect.flatMap((pid) =>
          policies.put({
            key: pid,
            owner,
            data: { toolkitId, pattern: r.pattern, action: r.action },
          }),
        ),
      ),
    );

  const create = (input: CreateToolkitPayload) =>
    Effect.gen(function* () {
      if (input.scope === "personal" && ctx.owner.subject == null) {
        return yield* new ToolkitForbidden({
          reason: "personal toolkits require a signed-in user",
        });
      }
      const owner = input.scope === "workspace" ? ORG : USER;
      const entries = input.connections ?? [];
      yield* validate(input.scope, entries);
      const id = yield* newId;
      const data = {
        slug: input.slug,
        name: input.name,
        inheritOrgPolicies: input.inheritOrgPolicies ?? true,
        briefing: input.briefing ?? null,
      };
      yield* toolkits.put({ key: id, owner, data });
      yield* putConnections(id, owner, entries);
      yield* putPolicies(id, owner, input.policies ?? []);
      return yield* viewFromRow({ key: id, owner, data });
    });

  const get = (id: string) =>
    Effect.gen(function* () {
      const row = yield* toolkits.get({ key: id });
      if (row == null) return yield* new ToolkitNotFound({ id });
      return yield* viewFromRow(row);
    });

  const list = () =>
    toolkits.list().pipe(Effect.flatMap((rows) => Effect.forEach(rows, viewFromRow)));

  const update = (id: string, patch: UpdateToolkitPayload) =>
    Effect.gen(function* () {
      const row = yield* toolkits.get({ key: id });
      if (row == null) return yield* new ToolkitNotFound({ id });
      const data = {
        slug: row.data.slug,
        name: patch.name ?? row.data.name,
        inheritOrgPolicies: patch.inheritOrgPolicies ?? row.data.inheritOrgPolicies,
        briefing: patch.briefing === undefined ? row.data.briefing : patch.briefing,
      };
      yield* toolkits.put({ key: id, owner: row.owner, data });
      if (patch.connections !== undefined) {
        yield* validate(scopeOfOwner(row.owner), patch.connections);
        const existing = yield* connections.query({ where: { toolkitId: id } });
        yield* Effect.forEach(existing, (c) =>
          connections.remove({ key: c.key, owner: row.owner }),
        );
        yield* putConnections(id, row.owner, patch.connections);
      }
      if (patch.policies !== undefined) {
        const existing = yield* policies.query({ where: { toolkitId: id } });
        yield* Effect.forEach(existing, (p) => policies.remove({ key: p.key, owner: row.owner }));
        yield* putPolicies(id, row.owner, patch.policies);
      }
      return yield* viewFromRow({ key: id, owner: row.owner, data });
    });

  const remove = (id: string) =>
    Effect.gen(function* () {
      const row = yield* toolkits.get({ key: id });
      if (row == null) return yield* new ToolkitNotFound({ id });
      const conns = yield* connections.query({ where: { toolkitId: id } });
      yield* Effect.forEach(conns, (c) => connections.remove({ key: c.key, owner: row.owner }));
      const pols = yield* policies.query({ where: { toolkitId: id } });
      yield* Effect.forEach(pols, (p) => policies.remove({ key: p.key, owner: row.owner }));
      yield* toolkits.remove({ key: id, owner: row.owner });
      return { removed: true };
    });

  // Resolve a selector (slug, then id) to the scope the MCP narrowing seam
  // applies. Request-scoped, so it only finds toolkits visible to the caller —
  // a cross-tenant/personal-of-another-user selector returns null (the seam
  // then fails closed to an empty slice).
  const resolveScope = (
    selector: string,
  ): Effect.Effect<ResolvedToolkitScope | null, StorageFailure> =>
    Effect.gen(function* () {
      const bySlug = yield* toolkits.query({
        where: { slug: selector },
        limit: 1,
      });
      const row = bySlug[0] ?? (yield* toolkits.get({ key: selector }));
      if (row == null) return null;
      const conns = yield* connections.query({ where: { toolkitId: row.key } });
      const pols = yield* policies.query({ where: { toolkitId: row.key } });
      return {
        entries: conns.map((c) => ({
          integration: c.data.integration,
          connection: c.data.connection,
          access: c.data.access as ToolkitAccess,
        })),
        policies: pols.map((p) => ({
          pattern: p.data.pattern,
          action: p.data.action as ToolkitPolicyAction,
        })),
        inheritOrgPolicies: row.data.inheritOrgPolicies,
      };
    });

  return { create, get, list, update, remove, resolveScope };
};

// Local aliases so the storage/extension layer stays decoupled from the wire
// schema's branded types without re-importing them everywhere.
type ToolkitConnectionIntegration = ToolkitView["connections"][number]["integration"];
type ToolkitConnectionEntryInput = {
  readonly integration: ToolkitConnectionIntegration;
  readonly connection: string;
  readonly access: ToolkitAccess;
  readonly note?: string | undefined;
};

type ToolkitsExtension = ReturnType<typeof makeToolkitsExtension>;

export class ToolkitsExtensionService extends Context.Service<
  ToolkitsExtensionService,
  ToolkitsExtension
>()("ToolkitsExtensionService") {}

// Build handlers against the core executor API with the toolkits group added,
// so the handler layer satisfies `ApiGroup<"executor", "toolkits">` (the marker
// the host's composed API requires) — not a standalone single-group bundle.
const ExecutorApiWithToolkits = addGroup(ToolkitsApi);

const ToolkitsHandlers = HttpApiBuilder.group(ExecutorApiWithToolkits, "toolkits", (h) =>
  h
    .handle("list", () =>
      capture(
        Effect.gen(function* () {
          const ext = yield* ToolkitsExtensionService;
          return yield* ext.list();
        }),
      ),
    )
    .handle("create", ({ payload }) =>
      capture(
        Effect.gen(function* () {
          const ext = yield* ToolkitsExtensionService;
          return yield* ext.create(payload);
        }),
      ),
    )
    .handle("get", ({ params }) =>
      capture(
        Effect.gen(function* () {
          const ext = yield* ToolkitsExtensionService;
          return yield* ext.get(params.id);
        }),
      ),
    )
    .handle("update", ({ params, payload }) =>
      capture(
        Effect.gen(function* () {
          const ext = yield* ToolkitsExtensionService;
          return yield* ext.update(params.id, payload);
        }),
      ),
    )
    .handle("remove", ({ params }) =>
      capture(
        Effect.gen(function* () {
          const ext = yield* ToolkitsExtensionService;
          return yield* ext.remove(params.id);
        }),
      ),
    ),
);

const resolveToolkitRequestScope = (
  ctx: PluginCtx,
  selector: string,
): Effect.Effect<RequestScope, StorageFailure> =>
  makeToolkitsExtension(ctx)
    .resolveScope(selector)
    .pipe(Effect.map((scope) => toolkitScopeToRequestScope(scope ?? EMPTY_TOOLKIT_SCOPE)));

export const toolkitsPlugin = definePlugin(() => ({
  id: "toolkits" as const,
  packageName: "@executor-js/plugin-toolkits",
  storage: () => ({}),
  pluginStorage: { toolkits: TOOLKITS, connections: CONNECTIONS },
  extension: makeToolkitsExtension,
  resolveRequestScope: resolveToolkitRequestScope,
  routes: () => ToolkitsApi,
  handlers: () => ToolkitsHandlers,
  extensionService: ToolkitsExtensionService,
}));

export default toolkitsPlugin;