// ---------------------------------------------------------------------------
// Extract the HTTP status from an MCP SDK transport error. The SDK surfaces
// transport failures two ways: an `SdkHttpError` carrying a numeric `status`,
// and an `SseError` carrying a numeric `code`. The SSE transport also retains
// its historic POST-failure message for errors created below EventSource.
// Shared by the invoke path (classifies tool-call failures) and the connect
// path (so a 401/403 during the handshake reaches the liveness health check).
// ---------------------------------------------------------------------------

import { Option, Schema } from "effect";

import { insufficientScopeFromEmbeddedJson } from "@executor-js/sdk/core";
// The SDK error classes are reached through the lazy loader: any error of
// those classes was constructed by the loaded client module, so "not loaded"
// soundly classifies the cause as not-an-SDK-error (see client-module.ts).
import { mcpClientSdkIfLoaded } from "./client-module";

const SsePostErrorCause = Schema.Struct({ message: Schema.String });
const decodeSsePostErrorCause = Schema.decodeUnknownOption(SsePostErrorCause);
const NumericHttpCodeCause = Schema.Struct({ code: Schema.Number });
const decodeNumericHttpCodeCause = Schema.decodeUnknownOption(NumericHttpCodeCause);

// V2 still constructs this exact message in SSEClientTransport._send. A format
// drift just yields undefined (generic error, no crash).
const statusFromSsePostError = (cause: unknown): number | undefined =>
  Option.match(decodeSsePostErrorCause(cause), {
    onNone: () => undefined,
    onSome: ({ message }) => {
      const match = /^Error POSTing to endpoint \(HTTP ([1-5][0-9]{2})\):/.exec(message);
      if (!match) return undefined;
      return Number(match[1]);
    },
  });

const statusFromTypedTransportError = (cause: unknown): number | undefined => {
  const sdk = mcpClientSdkIfLoaded();
  if (sdk === undefined) return undefined;
  if (sdk.client.SdkHttpError.isInstance(cause)) return cause.status;
  if (sdk.client.SseError.isInstance(cause)) {
    const code = cause.code;
    return code !== undefined && code >= 100 && code <= 599 ? code : undefined;
  }
  return undefined;
};

const statusFromNumericHttpCode = (cause: unknown): number | undefined =>
  Option.match(decodeNumericHttpCodeCause(cause), {
    onNone: () => undefined,
    onSome: ({ code }) => (code >= 100 && code <= 599 ? code : undefined),
  });

export const httpStatusFromCause = (cause: unknown): number | undefined =>
  statusFromTypedTransportError(cause) ?? statusFromSsePostError(cause);

/** Connection handshakes may receive the SDK's SSE error, whose numeric code
 * is an HTTP status. Keep this connection-only: JSON-RPC invocation errors
 * also have numeric `code` fields which are not HTTP statuses. */
export const connectionHttpStatusFromCause = (cause: unknown): number | undefined =>
  httpStatusFromCause(cause) ?? statusFromNumericHttpCode(cause);

/** The SDK uses code -1 when Streamable HTTP reached the endpoint but its
 * response did not implement the protocol (for example an unexpected content
 * type). This is transport incompatibility, not a network outage. */
export const isStreamableHttpProtocolError = (cause: unknown): boolean => {
  const sdk = mcpClientSdkIfLoaded();
  return (
    sdk !== undefined &&
    sdk.client.SdkError.isInstance(cause) &&
    cause.code === sdk.client.SdkErrorCode.ClientHttpUnexpectedContent
  );
};

// The SDK embeds the upstream response text in the transport error message
// ("Error POSTing to endpoint: <body>"), which is the only place a 403's body
// survives for connections without an authProvider. For OAuth connections the
// StreamableHTTP transport consumes the insufficient_scope challenge itself.
// V2 throws `InsufficientScopeError` when configured not to reauthorize; after
// exhausting its step-up retries it throws `SdkHttpError` with the exact fixed
// message matched below (verified against the installed v2 transport source).
// Both paths mean the same thing: the grant does not cover the operation, and
// re-running the identical flow cannot help. Strict matching
// (exact serialized field forms via the shared core detector, or the SDK's
// exact step-up message) — a miss stays on the generic auth path.
const SDK_STEP_UP_EXHAUSTED_RE =
  /^Server returned 403 insufficient_scope after step-up re-authorization \(retry limit \d+ reached\)$/;

export const insufficientScopeFromCause = (cause: unknown): boolean =>
  (mcpClientSdkIfLoaded()?.client.InsufficientScopeError.isInstance(cause) ?? false) ||
  Option.match(decodeSsePostErrorCause(cause), {
    onNone: () => false,
    onSome: ({ message }) =>
      insufficientScopeFromEmbeddedJson(message) || SDK_STEP_UP_EXHAUSTED_RE.test(message),
  });