/**
 * @fileoverview Integration tests for the registry-based MCP server implementation
 */

import { vi } from 'vitest';

// Mock MCP SDK modules FIRST using unstable_mockModule
vi.mock('@modelcontextprotocol/sdk/server/mcp.js', () => ({
  McpServer: vi.fn().mockImplementation(() => ({
    registerTool: vi.fn(),
    connect: vi.fn().mockResolvedValue(undefined),
  })),
}));

vi.mock('@modelcontextprotocol/sdk/server/stdio.js', () => ({
  StdioServerTransport: vi.fn().mockImplementation(() => ({})),
}));

// Mock logger
vi.mock('../utils/logging/logger.js', () => ({
  createLogger: vi.fn(() => ({
    info: vi.fn(),
    debug: vi.fn(),
    error: vi.fn(),
    warn: vi.fn(),
  })),
}));

// Mock the handlers
vi.mock('../handlers/index.js', () => ({
  handleProjects: vi.fn().mockResolvedValue({
    content: [{ type: 'text', text: JSON.stringify([{ key: 'test', name: 'Test Project' }]) }],
  }),
  handleDeepsourceQualityMetrics: vi.fn().mockResolvedValue({
    content: [{ type: 'text', text: JSON.stringify({ metrics: [] }) }],
  }),
  handleDeepsourceUpdateMetricThreshold: vi.fn().mockResolvedValue({
    content: [{ type: 'text', text: JSON.stringify({ ok: true }) }],
  }),
  handleDeepsourceUpdateMetricSetting: vi.fn().mockResolvedValue({
    content: [{ type: 'text', text: JSON.stringify({ success: true }) }],
  }),
  handleDeepsourceComplianceReport: vi.fn().mockResolvedValue({
    content: [{ type: 'text', text: JSON.stringify({ report: {} }) }],
  }),
  handleDeepsourceProjectIssues: vi.fn().mockResolvedValue({
    content: [{ type: 'text', text: JSON.stringify({ issues: [] }) }],
  }),
  handleDeepsourceProjectRuns: vi.fn().mockResolvedValue({
    content: [{ type: 'text', text: JSON.stringify({ runs: [] }) }],
  }),
  handleDeepsourceRun: vi.fn().mockResolvedValue({
    content: [{ type: 'text', text: JSON.stringify({ run: {} }) }],
  }),
  handleDeepsourceRecentRunIssues: vi.fn().mockResolvedValue({
    content: [{ type: 'text', text: JSON.stringify({ issues: [] }) }],
  }),
  handleDeepsourceDependencyVulnerabilities: vi.fn().mockResolvedValue({
    content: [{ type: 'text', text: JSON.stringify({ vulnerabilities: [] }) }],
  }),
}));

// Mock the server/tool-helpers
vi.mock('../server/tool-helpers.js', () => ({
  logToolInvocation: vi.fn(),
  logToolResult: vi.fn(),
  logAndFormatError: vi.fn().mockReturnValue('Formatted error'),
}));

// Mock the handler-adapters
vi.mock('../adapters/handler-adapters.js', () => ({
  adaptQualityMetricsParams: vi.fn((params) => params),
  adaptUpdateMetricThresholdParams: vi.fn((params) => params),
  adaptComplianceReportParams: vi.fn((params) => params),
  adaptProjectIssuesParams: vi.fn((params) => params),
}));

// Mock zod for schema validation
vi.mock('zod', () => ({
  z: {
    object: vi.fn(() => ({ safeParse: vi.fn(() => ({ success: true, data: {} })) })),
    string: vi.fn(() => ({})),
    number: vi.fn(() => ({})),
    boolean: vi.fn(() => ({})),
    array: vi.fn(() => ({})),
    optional: vi.fn(() => ({})),
  },
}));

// Mock handler base modules
vi.mock('../handlers/base/handler.interface.js', () => ({
  HandlerFunction: {},
  BaseHandlerDeps: {},
}));

vi.mock('../handlers/base/handler.factory.js', () => ({
  createDefaultHandlerDeps: vi.fn(),
  isApiResponse: vi.fn(() => false),
  createErrorResponse: vi.fn((error) => ({
    content: [{ type: 'text', text: `Error: ${error.message}` }],
    isError: true,
  })),
}));

// Mock the ToolRegistry class
class MockToolRegistry {
  private tools: Array<{
    name: string;
    description: string;
    inputSchema?: Record<string, unknown>;
    handler: MockedFunction<(...args: unknown[]) => Promise<unknown>>;
  }> = [];

  registerTool(tool: {
    name: string;
    description: string;
    inputSchema?: Record<string, unknown>;
    handler: MockedFunction<(...args: unknown[]) => Promise<unknown>>;
  }) {
    if (this.tools.find((t) => t.name === tool.name)) {
      throw new Error(`Tool ${tool.name} is already registered`);
    }
    this.tools.push(tool);
  }

  getTools() {
    return this.tools;
  }

  registerWithMcpServer(server: {
    registerTool: (_config: {
      name: string;
      description: string;
      inputSchema?: unknown;
      handler: unknown;
    }) => void;
  }) {
    this.tools.forEach((tool) => {
      server.registerTool({
        name: tool.name,
        description: tool.description,
        inputSchema: tool.inputSchema,
        handler: tool.handler,
      });
    });
  }
}

vi.mock('../server/tool-registry.js', () => ({
  ToolRegistry: MockToolRegistry,
}));

// Now import test utilities and modules after mocks are set
const { describe, it, expect, beforeEach, afterEach } = await import('vitest');
const { McpServer } = await import('@modelcontextprotocol/sdk/server/mcp.js');
const { ToolRegistry } = await import('../server/tool-registry.js');
const {
  adaptQualityMetricsParams,
  adaptUpdateMetricThresholdParams,
  adaptComplianceReportParams,
  adaptProjectIssuesParams,
} = await import('../adapters/handler-adapters.js');

describe('Registry-based MCP Server Integration', () => {
  let registry: MockToolRegistry;
  let mockMcpServer: {
    registerTool: ReturnType<typeof vi.fn>;
    connect: MockedFunction<() => Promise<void>>;
  };

  beforeEach(() => {
    // Create fresh instances for each test
    mockMcpServer = {
      registerTool: vi.fn(),
      connect: vi.fn().mockResolvedValue(undefined),
    };
    const MockedMcpServer = McpServer as ReturnType<typeof vi.fn>;
    MockedMcpServer.mockImplementation(() => mockMcpServer as ReturnType<typeof McpServer>);
    registry = new ToolRegistry();
    vi.clearAllMocks();
  });

  afterEach(() => {
    vi.clearAllMocks();
  });

  describe('ToolRegistry', () => {
    it('should register tools successfully', () => {
      const tool = {
        name: 'test-tool',
        description: 'A test tool',
        inputSchema: {
          type: 'object',
          properties: {
            param: { type: 'string' },
          },
        },
        handler: vi.fn().mockResolvedValue({ success: true }),
      };

      registry.registerTool(tool);
      const tools = registry.getTools();

      expect(tools).toHaveLength(1);
      expect(tools[0].name).toBe('test-tool');
    });

    it('should prevent duplicate tool registration', () => {
      const tool = {
        name: 'test-tool',
        description: 'A test tool',
        handler: vi.fn(),
      };

      registry.registerTool(tool);

      expect(() => registry.registerTool(tool)).toThrow('Tool test-tool is already registered');
    });

    it('should register tools with MCP server', () => {
      const server = new McpServer('test-server', '1.0.0') as ReturnType<typeof McpServer>;
      const tool = {
        name: 'test-tool',
        description: 'A test tool',
        handler: vi.fn(),
      };

      registry.registerTool(tool);
      registry.registerWithMcpServer(server);

      expect(server.registerTool).toHaveBeenCalledWith({
        name: 'test-tool',
        description: 'A test tool',
        inputSchema: undefined,
        handler: expect.any(Function),
      });
    });
  });

  describe('Handler Adapter Integration', () => {
    it('should correctly adapt quality metrics parameters', () => {
      const params = {
        project_key: 'test-project',
        from_date: '2024-01-01',
        to_date: '2024-01-31',
      };

      const adapted = adaptQualityMetricsParams(params);
      expect(adapted).toEqual(params);
      expect(adaptQualityMetricsParams).toHaveBeenCalledWith(params);
    });

    it('should correctly adapt update metric threshold parameters', () => {
      const params = {
        project_key: 'test-project',
        metric_key: 'coverage',
        threshold: 80,
      };

      const adapted = adaptUpdateMetricThresholdParams(params);
      expect(adapted).toEqual(params);
      expect(adaptUpdateMetricThresholdParams).toHaveBeenCalledWith(params);
    });

    it('should correctly adapt compliance report parameters', () => {
      const params = {
        project_key: 'test-project',
        framework: 'OWASP',
      };

      const adapted = adaptComplianceReportParams(params);
      expect(adapted).toEqual(params);
      expect(adaptComplianceReportParams).toHaveBeenCalledWith(params);
    });

    it('should correctly adapt project issues parameters', () => {
      const params = {
        project_key: 'test-project',
        page: 1,
        limit: 20,
        category: 'bug',
      };

      const adapted = adaptProjectIssuesParams(params);
      expect(adapted).toEqual(params);
      expect(adaptProjectIssuesParams).toHaveBeenCalledWith(params);
    });
  });

  describe('End-to-End Tool Registration', () => {
    it('should handle successful tool execution', async () => {
      const handler = vi.fn().mockResolvedValue({
        content: [{ type: 'text', text: 'Success' }],
      });

      const tool = {
        name: 'test-tool',
        description: 'A test tool',
        inputSchema: {
          type: 'object',
          properties: {
            param: { type: 'string' },
          },
          required: ['param'],
        },
        handler,
      };

      registry.registerTool(tool);
      const registeredTool = registry.getTools()[0];

      // Call the wrapped handler
      const result = await registeredTool.handler({ param: 'test' });

      expect(handler).toHaveBeenCalledWith({ param: 'test' });
      expect(result).toEqual({
        content: [{ type: 'text', text: 'Success' }],
      });
    });

    it('should handle tool execution errors', async () => {
      const handler = vi.fn().mockRejectedValue(new Error('Tool error'));

      const tool = {
        name: 'test-tool',
        description: 'A test tool',
        handler,
      };

      registry.registerTool(tool);
      const registeredTool = registry.getTools()[0];

      // Call the wrapped handler
      await expect(registeredTool.handler({})).rejects.toThrow('Tool error');
    });
  });

  describe('Schema Validation', () => {
    it('should validate input schema when provided', async () => {
      const handler = vi.fn().mockResolvedValue({ success: true });

      const tool = {
        name: 'test-tool',
        description: 'A test tool',
        inputSchema: {
          type: 'object',
          properties: {
            required_param: { type: 'string' },
          },
          required: ['required_param'],
        },
        handler,
      };

      registry.registerTool(tool);
      const registeredTool = registry.getTools()[0];

      // This will be validated by the registry's wrapper
      await registeredTool.handler({ required_param: 'value' });

      expect(handler).toHaveBeenCalledWith({ required_param: 'value' });
    });
  });
});