/**
 * @fileoverview MCP Server module for DeepSource integration
 *
 * This module provides a configurable MCP server that can be used
 * to integrate DeepSource functionality with Model Context Protocol.
 * It separates the server setup logic from the main entry point,
 * allowing for better testability and reusability.
 *
 * @packageDocumentation
 */

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { createLogger } from '../utils/logging/logger.js';
import { ToolRegistry } from './tool-registry.js';
import { BaseHandlerDeps } from '../handlers/base/handler.interface.js';
import { createDefaultHandlerDeps } from '../handlers/base/handler.factory.js';
import { registerDeepSourceTools } from './tool-registration.js';
import { VERSION } from '../version.js';

const logger = createLogger('MCPServer');

/**
 * Configuration options for the MCP server
 */
export interface MCPServerConfig {
  /** Server name */
  name?: string;
  /** Server version */
  version?: string;
  /** Custom handler dependencies */
  handlerDeps?: BaseHandlerDeps;
  /** Whether to auto-register DeepSource tools */
  autoRegisterTools?: boolean;
  /** Custom transport (defaults to StdioServerTransport) */
  transport?: StdioServerTransport;
  /** Whether to start the server immediately */
  autoStart?: boolean;
}

/**
 * Default configuration values
 */
const DEFAULT_CONFIG: Required<Omit<MCPServerConfig, 'handlerDeps' | 'transport'>> = {
  name: 'deepsource-mcp-server',
  version: VERSION,
  autoRegisterTools: true,
  autoStart: false,
};

/**
 * DeepSource MCP Server class
 *
 * This class encapsulates the MCP server setup and configuration,
 * providing a clean API for creating and managing the server.
 */
export class DeepSourceMCPServer {
  private mcpServer: McpServer;
  private toolRegistry: ToolRegistry;
  private transport?: StdioServerTransport;
  private config: Required<Omit<MCPServerConfig, 'handlerDeps' | 'transport'>> &
    Pick<MCPServerConfig, 'handlerDeps' | 'transport'>;
  private isConnected = false;

  constructor(config: MCPServerConfig = {}) {
    this.config = { ...DEFAULT_CONFIG, ...config };

    logger.info('Initializing DeepSource MCP Server', {
      name: this.config.name,
      version: this.config.version,
    });

    // Initialize MCP server
    this.mcpServer = new McpServer({
      name: this.config.name,
      version: this.config.version,
    });

    // Set transport FIRST (default to stdio if not provided)
    // This must be set before registering tools
    this.transport = this.config.transport || new StdioServerTransport();

    // Initialize tool registry
    const handlerDeps = this.config.handlerDeps || createDefaultHandlerDeps();
    this.toolRegistry = new ToolRegistry(this.mcpServer, handlerDeps);

    // Auto-register tools if configured (AFTER transport is set)
    if (this.config.autoRegisterTools) {
      this.registerDefaultTools();
    }
  }

  /**
   * Registers the default DeepSource tools
   */
  private registerDefaultTools(): void {
    try {
      logger.info('Starting registration of default DeepSource tools', {
        mcpServerType: typeof this.mcpServer,
        mcpServerExists: Boolean(this.mcpServer),
        toolRegistryExists: Boolean(this.toolRegistry),
      });

      registerDeepSourceTools(this.toolRegistry);

      const registeredTools = this.toolRegistry.getToolNames();
      logger.info('Successfully registered DeepSource tools', {
        registeredTools,
        toolCount: registeredTools.length,
      });

      // Verify tools are actually registered with the MCP server
      // The MCP server doesn't expose a direct way to query tools,
      // but we can log what we've registered
      logger.info('Tool registration verification', {
        toolRegistryCount: registeredTools.length,
        mcpServerConnected: this.isConnected,
        transportSet: Boolean(this.transport),
      });
    } catch (error) {
      logger.error('Failed to register DeepSource tools', {
        error,
        message: error instanceof Error ? error.message : String(error),
        stack: error instanceof Error ? error.stack : undefined,
      });
      throw error;
    }
  }

  /**
   * Gets the MCP server instance
   */
  getMcpServer(): McpServer {
    return this.mcpServer;
  }

  /**
   * Gets the tool registry
   */
  getToolRegistry(): ToolRegistry {
    return this.toolRegistry;
  }

  /**
   * Connects the server to the transport
   *
   * @param transport - Optional transport to use (overrides constructor transport)
   */
  async connect(transport?: StdioServerTransport): Promise<void> {
    if (this.isConnected) {
      logger.warn('Server is already connected');
      return;
    }

    const transportToUse = transport || this.transport || new StdioServerTransport();

    logger.info('Connecting MCP server to transport');
    await this.mcpServer.connect(transportToUse);

    this.isConnected = true;
    logger.info('MCP server connected successfully');
  }

  /**
   * Starts the server (convenience method that creates transport and connects)
   */
  async start(): Promise<void> {
    if (!this.transport) {
      this.transport = new StdioServerTransport();
    }
    await this.connect();
  }

  /**
   * Checks if the server is connected
   */
  isServerConnected(): boolean {
    return this.isConnected;
  }

  /**
   * Updates handler dependencies
   *
   * @param deps - New handler dependencies
   */
  updateHandlerDeps(deps: BaseHandlerDeps): void {
    this.toolRegistry.updateDefaultDeps(deps);
    logger.info('Handler dependencies updated');
  }

  /**
   * Gets registered tool names
   */
  getRegisteredTools(): string[] {
    return this.toolRegistry.getToolNames();
  }

  /**
   * Discovers and loads tools from filesystem (requires FEATURE_TOOL_DISCOVERY)
   *
   * @param options - Discovery options
   * @returns Array of discovered tool names
   */
  async discoverTools(options?: Record<string, unknown>): Promise<string[]> {
    logger.info('Starting tool discovery from DeepSourceMCPServer');
    return this.toolRegistry.discoverTools(options);
  }

  /**
   * Gets enhanced tool information including metadata
   */
  getToolsInfo(): Array<{
    name: string;
    description: string;
    category?: string;
    version?: string;
    tags?: string[];
    enabled?: boolean;
    discovered?: boolean;
  }> {
    return this.toolRegistry.getToolsInfo();
  }

  /**
   * Creates and optionally starts a DeepSource MCP server
   *
   * @param config - Server configuration
   * @returns The created server instance
   */
  static async create(config: MCPServerConfig = {}): Promise<DeepSourceMCPServer> {
    const server = new DeepSourceMCPServer(config);

    if (config.autoStart) {
      await server.start();
    }

    return server;
  }
}

/**
 * Convenience function to create a server with default configuration
 *
 * @param autoStart - Whether to start the server immediately
 * @returns The created server instance
 */
export async function createDeepSourceMCPServer(autoStart = false): Promise<DeepSourceMCPServer> {
  return DeepSourceMCPServer.create({ autoStart });
}