/**
 * Custom error types for MCP UI operations.
 * Provides structured errors with context and recovery hints.
 */

export interface McpUiErrorContext {
  server?: string;
  tool?: string;
  uri?: string;
  session?: string;
  [key: string]: unknown;
}

/**
 * Base error class for MCP UI errors.
 */
export class McpUiError extends Error {
  readonly code: string;
  readonly context: McpUiErrorContext;
  readonly recoveryHint?: string;
  readonly cause?: Error;

  constructor(
    message: string,
    options: {
      code: string;
      context?: McpUiErrorContext;
      recoveryHint?: string;
      cause?: Error;
    }
  ) {
    super(message);
    this.name = 'McpUiError';
    this.code = options.code;
    this.context = options.context ?? {};
    this.recoveryHint = options.recoveryHint;
    this.cause = options.cause;

    // Maintain proper stack trace
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, this.constructor);
    }
  }

  toJSON(): Record<string, unknown> {
    return {
      name: this.name,
      code: this.code,
      message: this.message,
      context: this.context,
      recoveryHint: this.recoveryHint,
      stack: this.stack,
    };
  }
}

/**
 * Error fetching a UI resource from the MCP server.
 */
export class ResourceFetchError extends McpUiError {
  constructor(uri: string, reason: string, options?: { server?: string; cause?: Error }) {
    super(`Failed to fetch UI resource "${uri}": ${reason}`, {
      code: 'RESOURCE_FETCH_ERROR',
      context: { uri, server: options?.server },
      recoveryHint: 'Check that the MCP server is connected and the resource URI is valid.',
      cause: options?.cause,
    });
    this.name = 'ResourceFetchError';
  }
}

/**
 * Error parsing or validating UI resource content.
 */
export class ResourceParseError extends McpUiError {
  constructor(uri: string, reason: string, options?: { server?: string; mimeType?: string }) {
    super(`Invalid UI resource "${uri}": ${reason}`, {
      code: 'RESOURCE_PARSE_ERROR',
      context: { uri, server: options?.server, mimeType: options?.mimeType },
      recoveryHint: 'Ensure the resource returns valid HTML with the correct MIME type.',
    });
    this.name = 'ResourceParseError';
  }
}

/**
 * Error connecting to the AppBridge.
 */
export class BridgeConnectionError extends McpUiError {
  constructor(reason: string, options?: { session?: string; cause?: Error }) {
    super(`AppBridge connection failed: ${reason}`, {
      code: 'BRIDGE_CONNECTION_ERROR',
      context: { session: options?.session },
      recoveryHint: 'Check browser console for detailed errors. The iframe may have failed to load.',
      cause: options?.cause,
    });
    this.name = 'BridgeConnectionError';
  }
}

/**
 * Error related to user consent for tool calls.
 */
export class ConsentError extends McpUiError {
  readonly denied: boolean;

  constructor(server: string, options: { denied?: boolean; requiresApproval?: boolean }) {
    const message = options.denied
      ? `Tool calls for "${server}" were denied for this session`
      : `Tool call approval required for "${server}"`;

    super(message, {
      code: options.denied ? 'CONSENT_DENIED' : 'CONSENT_REQUIRED',
      context: { server },
      recoveryHint: options.denied
        ? 'The user denied tool access. Start a new session to try again.'
        : 'Prompt the user for consent before calling tools.',
    });
    this.name = 'ConsentError';
    this.denied = options.denied ?? false;
  }
}

/**
 * Error with UI server session management.
 */
export class SessionError extends McpUiError {
  constructor(reason: string, options?: { session?: string; cause?: Error }) {
    super(`Session error: ${reason}`, {
      code: 'SESSION_ERROR',
      context: { session: options?.session },
      recoveryHint: 'The session may have expired or been closed. Try opening the UI again.',
      cause: options?.cause,
    });
    this.name = 'SessionError';
  }
}

/**
 * Error starting or operating the UI server.
 */
export class ServerError extends McpUiError {
  constructor(reason: string, options?: { port?: number; cause?: Error }) {
    super(`UI server error: ${reason}`, {
      code: 'SERVER_ERROR',
      context: { port: options?.port },
      recoveryHint: 'Check if the port is available. Another process may be using it.',
      cause: options?.cause,
    });
    this.name = 'ServerError';
  }
}

/**
 * Error communicating with the MCP server.
 */
export class McpServerError extends McpUiError {
  constructor(server: string, reason: string, options?: { tool?: string; cause?: Error }) {
    super(`MCP server "${server}" error: ${reason}`, {
      code: 'MCP_SERVER_ERROR',
      context: { server, tool: options?.tool },
      recoveryHint: 'Check that the MCP server is running and responsive.',
      cause: options?.cause,
    });
    this.name = 'McpServerError';
  }
}

/**
 * Wrap an unknown error into an McpUiError.
 */
export function wrapError(error: unknown, context?: McpUiErrorContext): McpUiError {
  if (error instanceof McpUiError) {
    // Merge contexts
    return new McpUiError(error.message, {
      code: error.code,
      context: { ...error.context, ...context },
      recoveryHint: error.recoveryHint,
      cause: error.cause,
    });
  }

  const cause = error instanceof Error ? error : undefined;
  const message = error instanceof Error ? error.message : String(error);

  return new McpUiError(message, {
    code: 'UNKNOWN_ERROR',
    context,
    cause,
  });
}

/**
 * Check if an error is a specific MCP UI error type.
 */
export function isErrorCode(error: unknown, code: string): boolean {
  return error instanceof McpUiError && error.code === code;
}