import { Effect, Layer, Option } from "effect";
import { HttpClient, HttpClientRequest } from "@effect/platform";

import {
  type ToolId,
  type ToolInvoker,
  ToolInvocationResult,
  ToolInvocationError,
  type ScopeId,
  type SecretId,
} from "@executor/sdk";

import { OpenApiInvocationError } from "./errors";
import type { OpenApiOperationStore } from "./operation-store";
import {
  type HeaderValue,
  type OperationBinding,
  InvocationConfig,
  InvocationResult,
  type OperationParameter,
} from "./types";

// ---------------------------------------------------------------------------
// Parameter reading
// ---------------------------------------------------------------------------

const CONTAINER_KEYS: Record<string, readonly string[]> = {
  path: ["path", "pathParams", "params"],
  query: ["query", "queryParams", "params"],
  header: ["headers", "header"],
  cookie: ["cookies", "cookie"],
};

const readParamValue = (args: Record<string, unknown>, param: OperationParameter): unknown => {
  const direct = args[param.name];
  if (direct !== undefined) return direct;

  for (const key of CONTAINER_KEYS[param.location] ?? []) {
    const container = args[key];
    if (typeof container === "object" && container !== null && !Array.isArray(container)) {
      const nested = (container as Record<string, unknown>)[param.name];
      if (nested !== undefined) return nested;
    }
  }

  return undefined;
};

// ---------------------------------------------------------------------------
// Path resolution
// ---------------------------------------------------------------------------

const resolvePath = Effect.fn("OpenApi.resolvePath")(function* (
  pathTemplate: string,
  args: Record<string, unknown>,
  parameters: readonly OperationParameter[],
) {
  let resolved = pathTemplate;

  // Resolve declared path parameters
  for (const param of parameters) {
    if (param.location !== "path") continue;
    const value = readParamValue(args, param);
    if (value === undefined || value === null) {
      if (param.required) {
        return yield* new OpenApiInvocationError({
          message: `Missing required path parameter: ${param.name}`,
          statusCode: Option.none(),
        });
      }
      continue;
    }
    resolved = resolved.replaceAll(`{${param.name}}`, encodeURIComponent(String(value)));
  }

  // Resolve remaining placeholders from raw args (handles specs that
  // don't explicitly list path parameters)
  const remaining = [...resolved.matchAll(/\{([^{}]+)\}/g)]
    .map((m) => m[1])
    .filter((v): v is string => typeof v === "string");

  for (const name of remaining) {
    const value = args[name];
    if (value !== undefined && value !== null) {
      resolved = resolved.replaceAll(`{${name}}`, encodeURIComponent(String(value)));
    }
  }

  const unresolved = [...resolved.matchAll(/\{([^{}]+)\}/g)]
    .map((m) => m[1])
    .filter((v): v is string => typeof v === "string");

  if (unresolved.length > 0) {
    return yield* new OpenApiInvocationError({
      message: `Unresolved path parameters: ${[...new Set(unresolved)].join(", ")}`,
      statusCode: Option.none(),
    });
  }

  return resolved;
});

// ---------------------------------------------------------------------------
// Header resolution — resolves secret refs at invocation time
// ---------------------------------------------------------------------------

const resolveHeaders = (
  headers: Record<string, HeaderValue>,
  secrets: {
    readonly resolve: (secretId: SecretId, scopeId: ScopeId) => Effect.Effect<string, unknown>;
  },
  scopeId: ScopeId,
): Effect.Effect<Record<string, string>, ToolInvocationError> =>
  Effect.gen(function* () {
    const resolved: Record<string, string> = {};
    for (const [name, value] of Object.entries(headers)) {
      if (typeof value === "string") {
        resolved[name] = value;
      } else {
        const secret = yield* secrets.resolve(value.secretId as SecretId, scopeId).pipe(
          Effect.mapError(
            () =>
              new ToolInvocationError({
                toolId: "" as ToolId,
                message: `Failed to resolve secret "${value.secretId}" for header "${name}"`,
                cause: undefined,
              }),
          ),
        );
        resolved[name] = value.prefix ? `${value.prefix}${secret}` : secret;
      }
    }
    return resolved;
  });

const applyHeaders = (
  request: HttpClientRequest.HttpClientRequest,
  headers: Record<string, string>,
): HttpClientRequest.HttpClientRequest => {
  let req = request;
  for (const [name, value] of Object.entries(headers)) {
    req = HttpClientRequest.setHeader(req, name, value);
  }
  return req;
};

// ---------------------------------------------------------------------------
// Response helpers
// ---------------------------------------------------------------------------

const isJsonContentType = (ct: string | null | undefined): boolean => {
  if (!ct) return false;
  const normalized = ct.split(";")[0]?.trim().toLowerCase() ?? "";
  return (
    normalized === "application/json" || normalized.includes("+json") || normalized.includes("json")
  );
};

// ---------------------------------------------------------------------------
// Public API
// ---------------------------------------------------------------------------

/** Invoke an OpenAPI operation binding. Requires HttpClient in the context. */
export const invoke = Effect.fn("OpenApi.invoke")(function* (
  operation: OperationBinding,
  args: Record<string, unknown>,
  config: InvocationConfig,
  /** Pre-resolved headers (secrets already resolved) */
  resolvedHeaders?: Record<string, string>,
) {
  const client = yield* HttpClient.HttpClient;

  const resolvedPath = yield* resolvePath(operation.pathTemplate, args, operation.parameters);

  const path = resolvedPath.startsWith("/") ? resolvedPath : `/${resolvedPath}`;

  // Build the base request — use just the path; baseUrl is applied to the client
  let request = HttpClientRequest.make(operation.method.toUpperCase() as "GET")(path);

  // Query parameters
  for (const param of operation.parameters) {
    if (param.location !== "query") continue;
    const value = readParamValue(args, param);
    if (value === undefined || value === null) continue;
    request = HttpClientRequest.setUrlParam(request, param.name, String(value));
  }

  // Header parameters
  for (const param of operation.parameters) {
    if (param.location !== "header") continue;
    const value = readParamValue(args, param);
    if (value === undefined || value === null) continue;
    request = HttpClientRequest.setHeader(request, param.name, String(value));
  }

  // Request body
  if (Option.isSome(operation.requestBody)) {
    const rb = operation.requestBody.value;
    const bodyValue = args.body ?? args.input;
    if (bodyValue !== undefined) {
      if (isJsonContentType(rb.contentType)) {
        request = HttpClientRequest.bodyUnsafeJson(request, bodyValue);
      } else {
        request = HttpClientRequest.bodyText(request, String(bodyValue), rb.contentType);
      }
    }
  }

  // Static headers (auth, custom headers, etc.) — use pre-resolved if available
  request = applyHeaders(request, resolvedHeaders ?? {});

  // Execute
  const response = yield* client.execute(request).pipe(
    Effect.mapError(
      (err) =>
        new OpenApiInvocationError({
          message: `HTTP request failed: ${err.message}`,
          statusCode: Option.none(),
          cause: err,
        }),
    ),
  );

  const status = response.status;
  const responseHeaders: Record<string, string> = { ...response.headers };

  // Decode body
  const contentType = response.headers["content-type"] ?? null;
  const responseBody: unknown =
    status === 204
      ? null
      : isJsonContentType(contentType)
        ? yield* response.json.pipe(Effect.catchAll(() => response.text))
        : yield* response.text;

  const ok = status >= 200 && status < 300;

  return new InvocationResult({
    status,
    headers: responseHeaders,
    data: ok ? responseBody : null,
    error: ok ? null : responseBody,
  });
});

// ---------------------------------------------------------------------------
// ToolInvoker — bridges operation store + HTTP client into SDK invoker
// ---------------------------------------------------------------------------

const SAFE_METHODS = new Set(["get", "head", "options"]);

/**
 * Derive tool annotations from the HTTP method and path.
 */
export const annotationsForOperation = (
  method: string,
  pathTemplate: string,
): {
  requiresApproval?: boolean;
  approvalDescription?: string;
} => {
  if (SAFE_METHODS.has(method.toLowerCase())) return {};
  return {
    requiresApproval: true,
    approvalDescription: `${method.toUpperCase()} ${pathTemplate}`,
  };
};

export const makeOpenApiInvoker = (opts: {
  readonly operationStore: OpenApiOperationStore;
  readonly httpClientLayer: Layer.Layer<HttpClient.HttpClient>;
  readonly secrets: {
    readonly resolve: (secretId: SecretId, scopeId: ScopeId) => Effect.Effect<string, unknown>;
  };
  readonly scopeId: ScopeId;
}): ToolInvoker => ({
  resolveAnnotations: (toolId: ToolId) =>
    Effect.gen(function* () {
      const entry = yield* opts.operationStore.get(toolId);
      if (!entry) return undefined;
      return annotationsForOperation(entry.binding.method, entry.binding.pathTemplate);
    }),

  invoke: (toolId: ToolId, args: unknown) =>
    Effect.gen(function* () {
      const entry = yield* opts.operationStore.get(toolId);
      if (!entry) {
        return yield* new ToolInvocationError({
          toolId,
          message: `No operation found for tool "${toolId}"`,
          cause: undefined,
        });
      }

      const { binding, config } = entry;
      const baseUrl = config.baseUrl;

      // Resolve secret-backed headers
      const resolvedHeaders = yield* resolveHeaders(config.headers, opts.secrets, opts.scopeId);

      const clientWithBaseUrl = baseUrl
        ? Layer.effect(
            HttpClient.HttpClient,
            Effect.map(
              HttpClient.HttpClient,
              HttpClient.mapRequest(HttpClientRequest.prependUrl(baseUrl)),
            ),
          ).pipe(Layer.provide(opts.httpClientLayer))
        : opts.httpClientLayer;

      const result = yield* invoke(
        binding,
        (args ?? {}) as Record<string, unknown>,
        config,
        resolvedHeaders,
      ).pipe(Effect.provide(clientWithBaseUrl));

      return new ToolInvocationResult({
        data: result.data,
        error: result.error,
        status: result.status,
      });
    }).pipe(
      Effect.catchAll((err) => {
        if (
          typeof err === "object" &&
          err !== null &&
          "_tag" in err &&
          (err as { _tag: string })._tag === "ToolInvocationError"
        ) {
          return Effect.fail(err as ToolInvocationError);
        }
        return Effect.fail(
          new ToolInvocationError({
            toolId,
            message: `OpenAPI invocation failed: ${err instanceof Error ? err.message : String(err)}`,
            cause: err,
          }),
        );
      }),
    ),
});