/**
 * @fileoverview Base handler factory implementation for standardized handler creation
 * @packageDocumentation
 */

import {
  BaseHandlerDeps,
  HandlerFactory,
  HandlerFunction,
  HandlerError,
} from './handler.interface.js';
import { ApiResponse } from '../../models/common.js';
import { createLogger } from '../../utils/logging/logger.js';
import { DeepSourceClientFactory } from '../../client/factory.js';
import { getApiKey } from '../../config/index.js';

/**
 * Creates a base handler factory with common functionality
 * @template TParams - The handler parameters type
 * @template TResult - The handler result type
 * @param handlerName - The name of the handler for logging
 * @param handlerLogic - The actual handler implementation
 * @returns A handler factory function
 */
export function createBaseHandlerFactory<TParams = unknown, TResult = ApiResponse>(
  handlerName: string,

  handlerLogic: (deps: BaseHandlerDeps, params: TParams) => Promise<TResult>
): HandlerFactory<BaseHandlerDeps, TParams, TResult> {
  return (deps: BaseHandlerDeps): HandlerFunction<TParams, TResult> => {
    /**
     * The actual handler function that processes the request
     * @param params - The parameters passed to the handler
     * @returns Promise resolving to the handler result
     */
    const handler = async (params: TParams): Promise<TResult> => {
      const startTime = Date.now();

      try {
        // Log handler invocation
        deps.logger.info(`Handler ${handlerName} invoked`, {
          hasParams: params !== undefined && params !== null,
          ...(params && typeof params === 'object' ? { params } : {}),
        });

        // Execute the handler logic
        const result = await handlerLogic(deps, params);

        // Log successful completion
        const duration = Date.now() - startTime;
        deps.logger.info(`Handler ${handlerName} completed successfully`, {
          duration,
          ...(result && typeof result === 'object' && 'data' in result
            ? {
                resultCount: Array.isArray((result as Record<string, unknown>).data)
                  ? ((result as Record<string, unknown>).data as unknown[]).length
                  : 1,
              }
            : {}),
        });

        return result;
      } catch (error) {
        // Log error details
        const duration = Date.now() - startTime;
        deps.logger.error(`Handler ${handlerName} failed`, {
          duration,
          errorType: error instanceof Error ? error.constructor.name : typeof error,
          errorMessage: error instanceof Error ? error.message : String(error),
          errorStack: error instanceof Error ? error.stack : undefined,
        });

        // Re-throw the error for upstream handling
        throw error;
      }
    };
    return handler as HandlerFunction<TParams, TResult>;
  };
}

/**
 * Creates default handler dependencies
 * @param overrides - Optional overrides for specific dependencies
 * @returns The complete handler dependencies
 */
export function createDefaultHandlerDeps(overrides?: Partial<BaseHandlerDeps>): BaseHandlerDeps {
  const apiKey = getApiKey();

  return {
    clientFactory: new DeepSourceClientFactory(apiKey),
    logger: createLogger('Handler'),
    getApiKey,
    ...overrides,
  };
}

/**
 * Wraps a handler result in an ApiResponse format
 * @param data - The data to wrap
 * @returns An ApiResponse with the data as JSON text
 */
export function wrapInApiResponse<T>(data: T): ApiResponse {
  return {
    content: [
      {
        type: 'text' as const,
        text: JSON.stringify(data, null, 2),
      },
    ],
  };
}

/**
 * Creates an error ApiResponse
 * @param error - The error to convert
 * @param defaultMessage - Default message if error parsing fails
 * @returns An ApiResponse with error information
 */
export function createErrorResponse(
  error: unknown,
  defaultMessage = 'An unexpected error occurred'
): ApiResponse {
  let errorData: HandlerError;

  if (error instanceof Error) {
    // Check if it's a structured error with code
    if ('code' in error && typeof error.code === 'string') {
      errorData = {
        code: error.code,
        message: error.message,
      };
      if ('details' in error && error.details) {
        errorData.details = error.details as Record<string, unknown>;
      }
      if ('suggestions' in error && error.suggestions) {
        errorData.suggestions = error.suggestions as string[];
      }
    } else {
      // Generic error
      errorData = {
        code: 'HANDLER_ERROR',
        message: error.message || defaultMessage,
      };
    }
  } else {
    // Unknown error type
    errorData = {
      code: 'UNKNOWN_ERROR',
      message: String(error) || defaultMessage,
    };
  }

  return {
    isError: true,
    content: [
      {
        type: 'text' as const,
        text: JSON.stringify(errorData),
      },
    ],
  };
}

/**
 * Type guard to check if a value is an ApiResponse
 * @param value - The value to check
 * @returns True if the value is an ApiResponse
 */
export function isApiResponse(value: unknown): value is ApiResponse {
  return (
    value !== null &&
    typeof value === 'object' &&
    'content' in value &&
    Array.isArray((value as Record<string, unknown>).content)
  );
}