// ---------------------------------------------------------------------------
// @executor-js/sdk/promise — thin Promise façade over the Effect SDK.
//
// Consumer goal: use executors + plugins without touching Effect. The
// façade wraps `createExecutor` so it returns a Promise, and proxies
// every method on the returned executor to unwrap its Effect into a
// Promise. Plugin factories are Effect-native but consumers never see
// that — the proxy flattens plugin extension methods too.
//
// Not a goal: authoring plugins in Promise style. The plugin model
// (storage, schema, staticIntegrations, Effect ctx) is Effect-only. Bring
// your own `@executor-js/plugin-*` from the Effect side.
// ---------------------------------------------------------------------------

import { Brand, Effect } from "effect";

import {
  collectTables,
  createExecutor as createEffectExecutor,
  type Executor as EffectExecutor,
  type InvokeOptions as EffectInvokeOptions,
  type OnElicitation,
} from "./executor";
import type { ElicitationContext, ElicitationResponse } from "./elicitation";
import type { FumaDb, FumaTables } from "./fuma-runtime";
import { Subject, Tenant } from "./ids";
import type { AnyPlugin } from "./plugin";
import type { CredentialProvider } from "./provider";

// ---------------------------------------------------------------------------
// Types
//
// Promise consumers shouldn't need to construct Effect `Brand`s to call into
// the executor — branded ids (`SecretId`, `ScopeId`, `ToolId`, `PolicyId`,
// `ConnectionId`) are typed as `string & Brand<...>` on the Effect side, but
// at runtime they're plain strings. `Unbrand` strips brand tags from
// parameter types (recursively, so it walks into object fields like
// `secrets.set({ id, scope })`) so consumers can pass plain strings. Return
// types are passed through unchanged — caller code that reads `.id` etc.
// off a returned ref still gets the branded type for use as an opaque token.
// ---------------------------------------------------------------------------

type Unbrand<T> =
  T extends Brand.Brand<string>
    ? string
    : T extends readonly (infer U)[]
      ? readonly Unbrand<U>[]
      : T extends ReadonlyMap<infer K, infer V>
        ? ReadonlyMap<Unbrand<K>, Unbrand<V>>
        : T extends ReadonlySet<infer U>
          ? ReadonlySet<Unbrand<U>>
          : T extends Date
            ? T
            : T extends (...args: infer A) => infer R
              ? (...args: { [I in keyof A]: Unbrand<A[I]> }) => Unbrand<R>
              : T extends object
                ? { readonly [K in keyof T]: Unbrand<T[K]> }
                : T;

export type PromiseOnElicitation =
  | "accept-all"
  | ((ctx: Unbrand<ElicitationContext>) => ElicitationResponse | Promise<ElicitationResponse>);

export interface PromiseInvokeOptions {
  readonly onElicitation?: PromiseOnElicitation;
}

type PromisifiedArg<T> = T extends EffectInvokeOptions | undefined
  ? PromiseInvokeOptions | undefined
  : Unbrand<T>;

type PromisifiedArgs<TArgs extends readonly unknown[]> = {
  [I in keyof TArgs]: PromisifiedArg<TArgs[I]>;
};

export type Promisified<T> = T extends (...args: infer A) => Effect.Effect<infer R, infer _E>
  ? (...args: PromisifiedArgs<A>) => Promise<R>
  : T extends readonly unknown[]
    ? T
    : T extends object
      ? { readonly [K in keyof T]: Promisified<T[K]> }
      : T;

export type Executor<TPlugins extends readonly AnyPlugin[] = readonly []> = Promisified<
  EffectExecutor<TPlugins>
>;

export interface ExecutorConfig<TPlugins extends readonly AnyPlugin[] = readonly []> {
  /** The org / workspace this executor binds to. Optional — defaults to
   *  `"default-tenant"`. `owner: "org"` rows file here. */
  readonly tenant?: string;
  /** The acting member. Omit for a pure-org executor (no `owner:"user"`). */
  readonly subject?: string;
  readonly plugins?: TPlugins;
  /**
   * Config-level credential providers, merged with every
   * `plugin.credentialProviders`. Config providers register first, so the
   * default (first writable) store is selected from them when present. A
   * writable provider is required before `connections.create({ value })` can
   * store an inline credential. Providers are Effect-native objects (their
   * `get`/`set` return `Effect`s) — bring them from `@executor-js/sdk/core`.
   */
  readonly providers?: readonly CredentialProvider[];
  /**
   * FumaDB ORM handle, or a factory that receives the executor-owned table
   * map. Public consumers usually want the factory form so `collectTables()`
   * stays inside `createExecutor`.
   */
  readonly db?:
    | FumaDb
    | { readonly db: FumaDb; readonly close?: () => Promise<void> | void }
    | ((config: { readonly tables: FumaTables }) =>
        | FumaDb
        | { readonly db: FumaDb; readonly close?: () => Promise<void> | void }
        | Promise<
            | FumaDb
            | {
                readonly db: FumaDb;
                readonly close?: () => Promise<void> | void;
              }
          >);
  /**
   * How to respond when a tool requests user input mid-invocation. Pass
   * `"accept-all"` for tests / non-interactive hosts, or a handler
   * `(ctx) => Promise<ElicitationResponse>` for interactive ones.
   * Required at construction so per-invoke calls don't have to thread
   * an options arg.
   */
  readonly onElicitation: PromiseOnElicitation;
}

// ---------------------------------------------------------------------------
// Promisify proxy — walks nested objects, converts Effect-returning methods
// into Promise-returning methods. Non-Effect return values pass through.
// ---------------------------------------------------------------------------

const isPlainObject = (v: unknown): v is Record<string | symbol, unknown> =>
  v !== null &&
  typeof v === "object" &&
  !Array.isArray(v) &&
  !(v instanceof Date) &&
  !(v instanceof Promise);

const isPromiseOnElicitation = (value: unknown): value is PromiseOnElicitation =>
  value === "accept-all" || typeof value === "function";

const toEffectOnElicitation = (handler: PromiseOnElicitation): OnElicitation =>
  handler === "accept-all"
    ? "accept-all"
    : (ctx) => Effect.promise(() => Promise.resolve(handler(ctx)));

const adaptPromiseInvokeOptions = (value: unknown): unknown => {
  if (!isPlainObject(value) || !Object.hasOwn(value, "onElicitation")) return value;
  const onElicitation = value.onElicitation;
  if (onElicitation === undefined || !isPromiseOnElicitation(onElicitation)) return value;
  return {
    ...value,
    onElicitation: toEffectOnElicitation(onElicitation),
  };
};

const adaptPromiseArgs = (args: readonly unknown[]): unknown[] =>
  args.map((arg) => adaptPromiseInvokeOptions(arg));

const promisifyDeep = <T>(value: T): Promisified<T> => {
  if (typeof value === "function") {
    return ((...args: unknown[]) => {
      const result = (value as (...a: unknown[]) => unknown).apply(
        undefined,
        adaptPromiseArgs(args),
      );
      if (Effect.isEffect(result)) {
        return Effect.runPromise(result as Effect.Effect<unknown, unknown>);
      }
      return result;
    }) as Promisified<T>;
  }

  if (!isPlainObject(value)) return value as Promisified<T>;

  return new Proxy(value, {
    get(target, prop, receiver) {
      const v = Reflect.get(target, prop, receiver);
      if (typeof v === "function") {
        return (...args: unknown[]) => {
          const result = (v as (...a: unknown[]) => unknown).apply(target, adaptPromiseArgs(args));
          if (Effect.isEffect(result)) {
            return Effect.runPromise(result as Effect.Effect<unknown, unknown>);
          }
          return result;
        };
      }
      if (isPlainObject(v)) return promisifyDeep(v);
      return v;
    },
  }) as Promisified<T>;
};

// ---------------------------------------------------------------------------
// createExecutor — Promise wrapper over the Effect createExecutor.
// ---------------------------------------------------------------------------

export const createExecutor = async <const TPlugins extends readonly AnyPlugin[] = readonly []>(
  config: ExecutorConfig<TPlugins>,
): Promise<Executor<TPlugins>> => {
  const plugins = (config?.plugins ?? []) as TPlugins;
  const db =
    typeof config.db === "function" ? await config.db({ tables: collectTables() }) : config.db;

  const effectConfig = {
    tenant: Tenant.make(config.tenant ?? "default-tenant"),
    ...(config.subject !== undefined ? { subject: Subject.make(config.subject) } : {}),
    plugins,
    ...(config.providers ? { providers: config.providers } : {}),
    onElicitation: toEffectOnElicitation(config.onElicitation),
    ...(db ? { db } : {}),
  };

  // The SDK has no observability requirement; storage failures surface
  // as raw `StorageError` / `UniqueViolationError` in the typed channel.
  // `Effect.runPromise` turns them into Promise rejections — consumers
  // get the tagged error as the rejected value. See
  // notes/promise-sdk-typed-errors.md for the planned `runPromiseExit`
  // rewrite that exposes the full error union to consumers.
  const effectExecutor = await Effect.runPromise(createEffectExecutor(effectConfig));

  const executor = promisifyDeep(effectExecutor) as Executor<TPlugins>;
  return {
    ...executor,
    close: async () => {
      await Effect.runPromise(effectExecutor.close());
    },
  } as Executor<TPlugins>;
};