import { Data, Effect } from "effect";
import type { InvokeOptions } from "@executor-js/sdk";

import type { AppToolBridge } from "../executor/app-tool-executor";
import type { IntegrationDecl } from "../pipeline/descriptor";

export class BindingError extends Data.TaggedError("BindingError")<{
  readonly message: string;
  readonly role: string;
  readonly integration: string;
  readonly requestedConnection?: string;
}> {}

export class AppInnerToolError extends Data.TaggedError("AppInnerToolError")<{
  readonly address: string;
  readonly innerMessage: string;
  readonly code?: string;
}> {}

export const appInnerToolFailureMessage = (error: AppInnerToolError): string =>
  `Inner tool ${error.address} failed: "${error.innerMessage}"`;

export interface ConnectionCandidate {
  readonly address: string;
  readonly integration: string;
}

export interface ClientResolver {
  readonly listConnections: (input: {
    readonly integration: string;
  }) => Effect.Effect<readonly ConnectionCandidate[], BindingError>;
  readonly resolveConnection: (input: {
    readonly connection: string;
  }) => Effect.Effect<ConnectionCandidate | null, BindingError>;
  readonly call: (input: {
    readonly integration: string;
    readonly connection: string;
    readonly path: readonly string[];
    readonly args: unknown;
    readonly invokeOptions?: InvokeOptions;
  }) => Effect.Effect<unknown, BindingError | AppInnerToolError>;
}

export interface ResolvedBindings {
  readonly input: Record<string, unknown>;
  readonly bindings: Readonly<Record<string, string | readonly string[]>>;
}

const isRecord = (value: unknown): value is Record<string, unknown> =>
  value !== null && typeof value === "object" && !Array.isArray(value);

const resolveRequested = (
  field: string,
  decl: IntegrationDecl,
  requested: string,
  resolver: ClientResolver,
): Effect.Effect<string, BindingError> =>
  Effect.gen(function* () {
    const connection = yield* resolver.resolveConnection({ connection: requested });
    if (!connection) {
      const candidates = yield* resolver.listConnections({ integration: decl.slug });
      return yield* new BindingError({
        role: field,
        integration: decl.slug,
        requestedConnection: requested,
        message: `unknown connection "${requested}" for integration field "${field}" (${decl.slug})${candidates.length > 0 ? `; choose one of ${candidates.map((candidate) => candidate.address).join(", ")}` : ""}`,
      });
    }
    if (connection.integration !== decl.slug) {
      return yield* new BindingError({
        role: field,
        integration: decl.slug,
        requestedConnection: requested,
        message: `connection "${requested}" belongs to integration "${connection.integration}", not "${decl.slug}"`,
      });
    }
    return connection.address;
  });

const resolveManyRequested = (
  field: string,
  decl: IntegrationDecl,
  requested: readonly unknown[],
  resolver: ClientResolver,
): Effect.Effect<readonly string[], BindingError> =>
  Effect.forEach(requested, (item) => {
    if (typeof item !== "string" || item.length === 0) {
      return Effect.fail(
        new BindingError({
          role: field,
          integration: decl.slug,
          message: `connection set for integration field "${field}" (${decl.slug}) must contain non-empty strings`,
        }),
      );
    }
    return resolveRequested(field, decl, item, resolver);
  });

export const resolveIntegrationBindings = (
  declared: Readonly<Record<string, IntegrationDecl>>,
  args: unknown,
  resolver: ClientResolver,
): Effect.Effect<ResolvedBindings, BindingError> =>
  Effect.gen(function* () {
    const payload = isRecord(args) ? args : {};
    const input: Record<string, unknown> = { ...payload };
    const bindings: Record<string, string | readonly string[]> = {};
    for (const [field, decl] of Object.entries(declared)) {
      const raw = payload[field];
      if (decl.mode === "many") {
        if (!Array.isArray(raw)) {
          return yield* new BindingError({
            role: field,
            integration: decl.slug,
            message: `connection set for integration field "${field}" (${decl.slug}) must be an array`,
          });
        }
        bindings[field] = yield* resolveManyRequested(field, decl, raw, resolver);
        delete input[field];
        continue;
      }
      if (typeof raw !== "string" || raw.length === 0) {
        return yield* new BindingError({
          role: field,
          integration: decl.slug,
          message: `connection for integration field "${field}" (${decl.slug}) must be a non-empty string`,
          ...(typeof raw === "string" ? { requestedConnection: raw } : {}),
        });
      }
      bindings[field] = yield* resolveRequested(field, decl, raw, resolver);
      delete input[field];
    }
    return { input, bindings };
  });

export const buildBridge = (input: {
  readonly declared: Readonly<Record<string, IntegrationDecl>>;
  readonly bindings: Readonly<Record<string, string | readonly string[]>>;
  readonly resolver: ClientResolver;
  readonly invokeOptions?: InvokeOptions;
}): AppToolBridge => ({
  call: (toolPath, args) => {
    const [root, ...path] = toolPath.split(".");
    const [field, rawIndex] = (root ?? "").split("#");
    const decl = input.declared[field ?? ""];
    const binding = input.bindings[field ?? ""];
    const connection =
      rawIndex === undefined
        ? typeof binding === "string"
          ? binding
          : undefined
        : Array.isArray(binding)
          ? binding[Number(rawIndex)]
          : undefined;
    if (!field || !decl || !connection || path.length === 0) {
      return Effect.runPromise(
        Effect.fail(
          new BindingError({
            role: field ?? "",
            integration: decl?.slug ?? "",
            message: `undeclared integration call: ${toolPath}`,
          }),
        ),
      );
    }
    return Effect.runPromise(
      input.resolver.call({
        integration: decl.slug,
        connection,
        path,
        args,
        invokeOptions: input.invokeOptions,
      }),
    );
  },
});