import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import {
  DocumentationGenerator,
  DocumentationSummarySchema,
  DocumentationGeneratorConfig,
  DocumentationInput,
  DocumentationResult,
  createDocumentationGenerator,
} from '../../../src/community/documentation-generator';

// Mock OpenAI
vi.mock('openai', () => {
  return {
    default: vi.fn().mockImplementation(() => ({
      chat: {
        completions: {
          create: vi.fn(),
        },
      },
    })),
  };
});

// Mock logger to prevent console output during tests
vi.mock('../../../src/utils/logger', () => ({
  logger: {
    info: vi.fn(),
    error: vi.fn(),
    warn: vi.fn(),
    debug: vi.fn(),
  },
}));

describe('DocumentationGenerator', () => {
  let generator: DocumentationGenerator;
  let mockCreate: ReturnType<typeof vi.fn>;

  const defaultConfig: DocumentationGeneratorConfig = {
    baseUrl: 'http://localhost:1234/v1',
    model: 'test-model',
    apiKey: 'test-key',
    timeout: 30000,
    maxTokens: 1000,
  };

  const validSummary = {
    purpose: 'Sends messages to Slack channels',
    capabilities: ['Send messages', 'Create channels', 'Upload files'],
    authentication: 'OAuth2 or API Token',
    commonUseCases: ['Team notifications', 'Alert systems'],
    limitations: ['Rate limits apply'],
    relatedNodes: ['n8n-nodes-base.slack'],
  };

  const sampleInput: DocumentationInput = {
    nodeType: 'n8n-nodes-community.slack',
    displayName: 'Slack Community',
    description: 'A community Slack integration',
    readme: '# Slack Community Node\n\nThis node allows you to send messages to Slack.',
    npmPackageName: '@community/n8n-nodes-slack',
  };

  beforeEach(() => {
    generator = new DocumentationGenerator(defaultConfig);

    // Get the mocked create function
    mockCreate = vi.fn();
    Object.defineProperty(generator, 'client', {
      value: {
        chat: {
          completions: {
            create: mockCreate,
          },
        },
      },
      writable: true,
    });
  });

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

  describe('Constructor Configuration', () => {
    it('should use provided configuration values', () => {
      const config: DocumentationGeneratorConfig = {
        baseUrl: 'http://custom-server:8080/v1',
        model: 'custom-model',
        apiKey: 'custom-key',
        timeout: 45000,
        maxTokens: 2500,
      };

      const customGenerator = new DocumentationGenerator(config);

      // Verify internal properties are set correctly
      expect(customGenerator['model']).toBe('custom-model');
      expect(customGenerator['maxTokens']).toBe(2500);
      expect(customGenerator['timeout']).toBe(45000);
    });

    it('should apply default values when optional config is omitted', () => {
      const minimalConfig: DocumentationGeneratorConfig = {
        baseUrl: 'http://localhost:1234/v1',
      };

      const minimalGenerator = new DocumentationGenerator(minimalConfig);

      expect(minimalGenerator['model']).toBe('qwen3-4b-thinking-2507');
      expect(minimalGenerator['maxTokens']).toBe(2000);
      expect(minimalGenerator['timeout']).toBe(60000);
    });

    it('should partially override defaults', () => {
      const partialConfig: DocumentationGeneratorConfig = {
        baseUrl: 'http://localhost:1234/v1',
        model: 'custom-model',
        // apiKey, timeout, maxTokens should use defaults
      };

      const partialGenerator = new DocumentationGenerator(partialConfig);

      expect(partialGenerator['model']).toBe('custom-model');
      expect(partialGenerator['maxTokens']).toBe(2000);
      expect(partialGenerator['timeout']).toBe(60000);
    });
  });

  describe('generateSummary()', () => {
    describe('Successful generation', () => {
      it('should generate documentation summary from valid LLM response', async () => {
        mockCreate.mockResolvedValue({
          choices: [
            {
              message: {
                content: JSON.stringify(validSummary),
              },
            },
          ],
        });

        const result = await generator.generateSummary(sampleInput);

        expect(result.nodeType).toBe('n8n-nodes-community.slack');
        expect(result.summary.purpose).toBe('Sends messages to Slack channels');
        expect(result.summary.capabilities).toEqual(['Send messages', 'Create channels', 'Upload files']);
        expect(result.summary.authentication).toBe('OAuth2 or API Token');
        expect(result.error).toBeUndefined();
      });

      it('should call OpenAI with correct parameters', async () => {
        mockCreate.mockResolvedValue({
          choices: [
            {
              message: {
                content: JSON.stringify(validSummary),
              },
            },
          ],
        });

        await generator.generateSummary(sampleInput);

        expect(mockCreate).toHaveBeenCalledWith({
          model: 'test-model',
          max_tokens: 1000,
          temperature: 0.3,
          messages: expect.arrayContaining([
            expect.objectContaining({ role: 'system' }),
            expect.objectContaining({ role: 'user' }),
          ]),
        });
      });

      it('should include node information in the prompt', async () => {
        mockCreate.mockResolvedValue({
          choices: [
            {
              message: {
                content: JSON.stringify(validSummary),
              },
            },
          ],
        });

        await generator.generateSummary(sampleInput);

        const userMessage = mockCreate.mock.calls[0][0].messages[1].content;
        expect(userMessage).toContain('Slack Community');
        expect(userMessage).toContain('n8n-nodes-community.slack');
        expect(userMessage).toContain('@community/n8n-nodes-slack');
        expect(userMessage).toContain('A community Slack integration');
      });
    });

    describe('JSON extraction from markdown code blocks', () => {
      it('should extract JSON from markdown json code block', async () => {
        mockCreate.mockResolvedValue({
          choices: [
            {
              message: {
                content: '```json\n' + JSON.stringify(validSummary) + '\n```',
              },
            },
          ],
        });

        const result = await generator.generateSummary(sampleInput);

        expect(result.error).toBeUndefined();
        expect(result.summary.purpose).toBe('Sends messages to Slack channels');
      });

      it('should extract JSON from generic markdown code block', async () => {
        mockCreate.mockResolvedValue({
          choices: [
            {
              message: {
                content: '```\n' + JSON.stringify(validSummary) + '\n```',
              },
            },
          ],
        });

        const result = await generator.generateSummary(sampleInput);

        expect(result.error).toBeUndefined();
        expect(result.summary.purpose).toBe('Sends messages to Slack channels');
      });

      it('should extract JSON object directly from response text', async () => {
        mockCreate.mockResolvedValue({
          choices: [
            {
              message: {
                content: 'Here is the summary:\n' + JSON.stringify(validSummary) + '\n\nDone.',
              },
            },
          ],
        });

        const result = await generator.generateSummary(sampleInput);

        expect(result.error).toBeUndefined();
        expect(result.summary.purpose).toBe('Sends messages to Slack channels');
      });

      it('should handle JSON with extra whitespace in code block', async () => {
        mockCreate.mockResolvedValue({
          choices: [
            {
              message: {
                content: '```json\n  \n' + JSON.stringify(validSummary, null, 2) + '\n  \n```',
              },
            },
          ],
        });

        const result = await generator.generateSummary(sampleInput);

        expect(result.error).toBeUndefined();
        expect(result.summary.purpose).toBe('Sends messages to Slack channels');
      });
    });

    describe('Error handling', () => {
      it('should return default summary when LLM returns no content', async () => {
        mockCreate.mockResolvedValue({
          choices: [
            {
              message: {
                content: null,
              },
            },
          ],
        });

        const result = await generator.generateSummary(sampleInput);

        expect(result.error).toBe('No content in LLM response');
        expect(result.summary.purpose).toBe('A community Slack integration');
        expect(result.summary.limitations).toContain('Documentation could not be automatically generated');
      });

      it('should return default summary when LLM returns empty content', async () => {
        mockCreate.mockResolvedValue({
          choices: [
            {
              message: {
                content: '',
              },
            },
          ],
        });

        const result = await generator.generateSummary(sampleInput);

        expect(result.error).toBeDefined();
        expect(result.summary.limitations).toContain('Documentation could not be automatically generated');
      });

      it('should return default summary when LLM returns invalid JSON', async () => {
        mockCreate.mockResolvedValue({
          choices: [
            {
              message: {
                content: 'This is not valid JSON at all',
              },
            },
          ],
        });

        const result = await generator.generateSummary(sampleInput);

        expect(result.error).toBeDefined();
        expect(result.summary.purpose).toBe('A community Slack integration');
      });

      it('should return default summary when LLM returns malformed JSON', async () => {
        mockCreate.mockResolvedValue({
          choices: [
            {
              message: {
                content: '{"purpose": "test", "capabilities": [}',
              },
            },
          ],
        });

        const result = await generator.generateSummary(sampleInput);

        expect(result.error).toBeDefined();
        expect(result.nodeType).toBe('n8n-nodes-community.slack');
      });

      it('should return default summary when choices array is empty', async () => {
        mockCreate.mockResolvedValue({
          choices: [],
        });

        const result = await generator.generateSummary(sampleInput);

        expect(result.error).toBe('No content in LLM response');
      });

      it('should return default summary on network error', async () => {
        mockCreate.mockRejectedValue(new Error('Connection refused'));

        const result = await generator.generateSummary(sampleInput);

        expect(result.error).toBe('Connection refused');
        expect(result.summary.limitations).toContain('Documentation could not be automatically generated');
      });

      it('should return default summary on timeout', async () => {
        mockCreate.mockRejectedValue(new Error('Request timed out'));

        const result = await generator.generateSummary(sampleInput);

        expect(result.error).toBe('Request timed out');
      });

      it('should return default summary when Zod validation fails', async () => {
        mockCreate.mockResolvedValue({
          choices: [
            {
              message: {
                content: JSON.stringify({
                  purpose: 'Valid purpose',
                  capabilities: 'not-an-array', // Should be array
                  authentication: 'API key',
                  commonUseCases: [],
                  limitations: [],
                  relatedNodes: [],
                }),
              },
            },
          ],
        });

        const result = await generator.generateSummary(sampleInput);

        expect(result.error).toBeDefined();
        expect(result.summary.limitations).toContain('Documentation could not be automatically generated');
      });

      it('should use node display name in default summary when description is missing', async () => {
        mockCreate.mockRejectedValue(new Error('API error'));

        const inputWithoutDescription: DocumentationInput = {
          nodeType: 'n8n-nodes-community.custom',
          displayName: 'Custom Node',
          readme: '# Custom Node',
        };

        const result = await generator.generateSummary(inputWithoutDescription);

        expect(result.summary.purpose).toBe('Community node: Custom Node');
      });

      it('should handle non-Error exceptions', async () => {
        mockCreate.mockRejectedValue('String error');

        const result = await generator.generateSummary(sampleInput);

        expect(result.error).toBe('Unknown error');
      });
    });
  });

  describe('generateBatch()', () => {
    const createInputs = (count: number): DocumentationInput[] => {
      return Array.from({ length: count }, (_, i) => ({
        nodeType: `n8n-nodes-community.node${i}`,
        displayName: `Node ${i}`,
        description: `Description for node ${i}`,
        readme: `# Node ${i} README`,
      }));
    };

    it('should process multiple nodes in parallel', async () => {
      mockCreate.mockResolvedValue({
        choices: [
          {
            message: {
              content: JSON.stringify(validSummary),
            },
          },
        ],
      });

      const inputs = createInputs(5);
      const results = await generator.generateBatch(inputs, 2);

      expect(results).toHaveLength(5);
      results.forEach((result, i) => {
        expect(result.nodeType).toBe(`n8n-nodes-community.node${i}`);
      });
    });

    it('should respect concurrency limit', async () => {
      const callOrder: number[] = [];
      let currentConcurrency = 0;
      let maxConcurrency = 0;

      mockCreate.mockImplementation(async () => {
        currentConcurrency++;
        maxConcurrency = Math.max(maxConcurrency, currentConcurrency);
        callOrder.push(currentConcurrency);

        await new Promise((resolve) => setTimeout(resolve, 50));

        currentConcurrency--;
        return {
          choices: [
            {
              message: {
                content: JSON.stringify(validSummary),
              },
            },
          ],
        };
      });

      const inputs = createInputs(6);
      await generator.generateBatch(inputs, 2);

      // Max concurrency should not exceed the limit
      expect(maxConcurrency).toBeLessThanOrEqual(2);
    });

    it('should call progress callback with correct values', async () => {
      mockCreate.mockResolvedValue({
        choices: [
          {
            message: {
              content: JSON.stringify(validSummary),
            },
          },
        ],
      });

      const progressCalls: Array<{ message: string; current: number; total: number }> = [];
      const progressCallback = (message: string, current: number, total: number) => {
        progressCalls.push({ message, current, total });
      };

      const inputs = createInputs(5);
      await generator.generateBatch(inputs, 2, progressCallback);

      expect(progressCalls.length).toBeGreaterThan(0);
      expect(progressCalls[0].message).toBe('Generating documentation');
      expect(progressCalls[progressCalls.length - 1].current).toBe(5);
      expect(progressCalls[progressCalls.length - 1].total).toBe(5);
    });

    it('should handle mixed success and failure results', async () => {
      let callCount = 0;
      mockCreate.mockImplementation(async () => {
        callCount++;
        if (callCount % 2 === 0) {
          throw new Error('Simulated failure');
        }
        return {
          choices: [
            {
              message: {
                content: JSON.stringify(validSummary),
              },
            },
          ],
        };
      });

      const inputs = createInputs(4);
      const results = await generator.generateBatch(inputs, 2);

      expect(results).toHaveLength(4);
      const successCount = results.filter((r) => !r.error).length;
      const errorCount = results.filter((r) => r.error).length;

      expect(successCount).toBe(2);
      expect(errorCount).toBe(2);
    });

    it('should handle empty input array', async () => {
      const results = await generator.generateBatch([], 3);

      expect(results).toHaveLength(0);
      expect(mockCreate).not.toHaveBeenCalled();
    });

    it('should handle single item input', async () => {
      mockCreate.mockResolvedValue({
        choices: [
          {
            message: {
              content: JSON.stringify(validSummary),
            },
          },
        ],
      });

      const inputs = createInputs(1);
      const results = await generator.generateBatch(inputs, 3);

      expect(results).toHaveLength(1);
      expect(mockCreate).toHaveBeenCalledTimes(1);
    });

    it('should use default concurrency of 3', async () => {
      let maxConcurrency = 0;
      let currentConcurrency = 0;

      mockCreate.mockImplementation(async () => {
        currentConcurrency++;
        maxConcurrency = Math.max(maxConcurrency, currentConcurrency);
        await new Promise((resolve) => setTimeout(resolve, 10));
        currentConcurrency--;
        return {
          choices: [
            {
              message: {
                content: JSON.stringify(validSummary),
              },
            },
          ],
        };
      });

      const inputs = createInputs(9);
      await generator.generateBatch(inputs);

      expect(maxConcurrency).toBeLessThanOrEqual(3);
    });
  });

  describe('testConnection()', () => {
    it('should return success when LLM responds', async () => {
      mockCreate.mockResolvedValue({
        choices: [
          {
            message: {
              content: 'Hello!',
            },
          },
        ],
      });

      const result = await generator.testConnection();

      expect(result.success).toBe(true);
      expect(result.message).toBe('Connected to test-model');
    });

    it('should return failure when LLM returns empty response', async () => {
      mockCreate.mockResolvedValue({
        choices: [
          {
            message: {
              content: null,
            },
          },
        ],
      });

      const result = await generator.testConnection();

      expect(result.success).toBe(false);
      expect(result.message).toBe('No response from LLM');
    });

    it('should return failure when LLM returns empty string', async () => {
      mockCreate.mockResolvedValue({
        choices: [
          {
            message: {
              content: '',
            },
          },
        ],
      });

      const result = await generator.testConnection();

      expect(result.success).toBe(false);
      expect(result.message).toBe('No response from LLM');
    });

    it('should return failure when choices array is empty', async () => {
      mockCreate.mockResolvedValue({
        choices: [],
      });

      const result = await generator.testConnection();

      expect(result.success).toBe(false);
      expect(result.message).toBe('No response from LLM');
    });

    it('should return failure on connection error', async () => {
      mockCreate.mockRejectedValue(new Error('Connection refused'));

      const result = await generator.testConnection();

      expect(result.success).toBe(false);
      expect(result.message).toBe('Connection failed: Connection refused');
    });

    it('should return failure on timeout', async () => {
      mockCreate.mockRejectedValue(new Error('Request timed out'));

      const result = await generator.testConnection();

      expect(result.success).toBe(false);
      expect(result.message).toBe('Connection failed: Request timed out');
    });

    it('should handle non-Error exceptions', async () => {
      mockCreate.mockRejectedValue('Network failure');

      const result = await generator.testConnection();

      expect(result.success).toBe(false);
      expect(result.message).toBe('Connection failed: Unknown error');
    });

    it('should use minimal tokens for connection test', async () => {
      mockCreate.mockResolvedValue({
        choices: [
          {
            message: {
              content: 'Hi',
            },
          },
        ],
      });

      await generator.testConnection();

      expect(mockCreate).toHaveBeenCalledWith(
        expect.objectContaining({
          max_tokens: 10,
          messages: [
            {
              role: 'user',
              content: 'Hello',
            },
          ],
        })
      );
    });
  });

  describe('DocumentationSummarySchema validation', () => {
    it('should validate correct documentation summary', () => {
      const result = DocumentationSummarySchema.safeParse(validSummary);

      expect(result.success).toBe(true);
    });

    it('should reject missing required fields', () => {
      const incompleteSummary = {
        purpose: 'Test purpose',
        capabilities: ['test'],
        // Missing: authentication, commonUseCases, limitations, relatedNodes
      };

      const result = DocumentationSummarySchema.safeParse(incompleteSummary);

      expect(result.success).toBe(false);
    });

    it('should enforce capabilities array max length of 10', () => {
      const tooManyCapabilities = {
        ...validSummary,
        capabilities: Array.from({ length: 11 }, (_, i) => `capability${i}`),
      };

      const result = DocumentationSummarySchema.safeParse(tooManyCapabilities);

      expect(result.success).toBe(false);
    });

    it('should enforce commonUseCases array max length of 5', () => {
      const tooManyUseCases = {
        ...validSummary,
        commonUseCases: Array.from({ length: 6 }, (_, i) => `useCase${i}`),
      };

      const result = DocumentationSummarySchema.safeParse(tooManyUseCases);

      expect(result.success).toBe(false);
    });

    it('should accept empty arrays for optional fields', () => {
      const minimalSummary = {
        purpose: 'Minimal node',
        capabilities: [],
        authentication: 'None',
        commonUseCases: [],
        limitations: [],
        relatedNodes: [],
      };

      const result = DocumentationSummarySchema.safeParse(minimalSummary);

      expect(result.success).toBe(true);
    });

    it('should reject non-string values in arrays', () => {
      const invalidSummary = {
        ...validSummary,
        capabilities: [1, 2, 3],
      };

      const result = DocumentationSummarySchema.safeParse(invalidSummary);

      expect(result.success).toBe(false);
    });

    it('should reject non-string purpose', () => {
      const invalidSummary = {
        ...validSummary,
        purpose: { text: 'purpose' },
      };

      const result = DocumentationSummarySchema.safeParse(invalidSummary);

      expect(result.success).toBe(false);
    });

    it('should reject null values', () => {
      const invalidSummary = {
        ...validSummary,
        authentication: null,
      };

      const result = DocumentationSummarySchema.safeParse(invalidSummary);

      expect(result.success).toBe(false);
    });
  });

  describe('createDocumentationGenerator factory', () => {
    const originalEnv = process.env;

    beforeEach(() => {
      process.env = { ...originalEnv };
    });

    afterEach(() => {
      process.env = originalEnv;
    });

    it('should use environment variables when set', () => {
      process.env.N8N_MCP_LLM_BASE_URL = 'http://custom:9999/v1';
      process.env.N8N_MCP_LLM_MODEL = 'custom-model';
      process.env.N8N_MCP_LLM_TIMEOUT = '90000';

      const factoryGenerator = createDocumentationGenerator();

      expect(factoryGenerator['model']).toBe('custom-model');
      expect(factoryGenerator['timeout']).toBe(90000);
    });

    it('should use default values when environment variables are not set', () => {
      delete process.env.N8N_MCP_LLM_BASE_URL;
      delete process.env.N8N_MCP_LLM_MODEL;
      delete process.env.N8N_MCP_LLM_TIMEOUT;

      const factoryGenerator = createDocumentationGenerator();

      expect(factoryGenerator['model']).toBe('qwen3-4b-thinking-2507');
      expect(factoryGenerator['timeout']).toBe(60000);
    });
  });

  describe('Private method behaviors', () => {
    describe('truncateReadme', () => {
      it('should not truncate short README', async () => {
        mockCreate.mockResolvedValue({
          choices: [
            {
              message: {
                content: JSON.stringify(validSummary),
              },
            },
          ],
        });

        const shortReadme = 'Short README content';
        const input = { ...sampleInput, readme: shortReadme };

        await generator.generateSummary(input);

        const userMessage = mockCreate.mock.calls[0][0].messages[1].content;
        expect(userMessage).toContain(shortReadme);
        expect(userMessage).not.toContain('[README truncated...]');
      });

      it('should truncate very long README', async () => {
        mockCreate.mockResolvedValue({
          choices: [
            {
              message: {
                content: JSON.stringify(validSummary),
              },
            },
          ],
        });

        const longReadme = 'A'.repeat(10000);
        const input = { ...sampleInput, readme: longReadme };

        await generator.generateSummary(input);

        const userMessage = mockCreate.mock.calls[0][0].messages[1].content;
        expect(userMessage).toContain('[README truncated...]');
      });

      it('should try to truncate at paragraph boundary', async () => {
        mockCreate.mockResolvedValue({
          choices: [
            {
              message: {
                content: JSON.stringify(validSummary),
              },
            },
          ],
        });

        const readmeWithParagraphs = 'A'.repeat(5000) + '\n\n' + 'B'.repeat(2000);
        const input = { ...sampleInput, readme: readmeWithParagraphs };

        await generator.generateSummary(input);

        const userMessage = mockCreate.mock.calls[0][0].messages[1].content;
        expect(userMessage).toContain('[README truncated...]');
      });
    });

    describe('buildPrompt', () => {
      it('should handle missing optional fields', async () => {
        mockCreate.mockResolvedValue({
          choices: [
            {
              message: {
                content: JSON.stringify(validSummary),
              },
            },
          ],
        });

        const minimalInput: DocumentationInput = {
          nodeType: 'n8n-nodes-community.minimal',
          displayName: 'Minimal Node',
          readme: '# Minimal',
        };

        await generator.generateSummary(minimalInput);

        const userMessage = mockCreate.mock.calls[0][0].messages[1].content;
        expect(userMessage).toContain('Package: unknown');
        expect(userMessage).toContain('Description: No description provided');
      });
    });
  });

  describe('Edge cases and security', () => {
    it('should handle README with special characters', async () => {
      mockCreate.mockResolvedValue({
        choices: [
          {
            message: {
              content: JSON.stringify(validSummary),
            },
          },
        ],
      });

      const specialReadme = '# Node with "quotes" and `backticks` and <html> tags';
      const input = { ...sampleInput, readme: specialReadme };

      const result = await generator.generateSummary(input);

      expect(result.error).toBeUndefined();
    });

    it('should handle Unicode content in README', async () => {
      mockCreate.mockResolvedValue({
        choices: [
          {
            message: {
              content: JSON.stringify(validSummary),
            },
          },
        ],
      });

      const unicodeReadme = '# Node with Unicode: emoji, Chinese: 中文, Arabic: العربية';
      const input = { ...sampleInput, readme: unicodeReadme };

      await generator.generateSummary(input);

      const userMessage = mockCreate.mock.calls[0][0].messages[1].content;
      expect(userMessage).toContain('中文');
      expect(userMessage).toContain('العربية');
    });

    it('should handle LLM response with thinking tokens', async () => {
      mockCreate.mockResolvedValue({
        choices: [
          {
            message: {
              content:
                '<think>Let me analyze this...</think>\n```json\n' + JSON.stringify(validSummary) + '\n```',
            },
          },
        ],
      });

      const result = await generator.generateSummary(sampleInput);

      expect(result.error).toBeUndefined();
      expect(result.summary.purpose).toBe('Sends messages to Slack channels');
    });

    it('should return error when response contains multiple JSON objects', async () => {
      // When the response contains multiple JSON objects concatenated,
      // JSON.parse will fail, and we should get a default summary with error
      mockCreate.mockResolvedValue({
        choices: [
          {
            message: {
              content: JSON.stringify(validSummary) + '\n\n' + JSON.stringify({ other: 'data' }),
            },
          },
        ],
      });

      const result = await generator.generateSummary(sampleInput);

      // This should fail to parse and return default summary with error
      expect(result.error).toBeDefined();
      expect(result.summary.limitations).toContain('Documentation could not be automatically generated');
    });
  });

  describe('truncateArrayFields helper', () => {
    it('should truncate capabilities array to 10 items', () => {
      const truncateMethod = (generator as any).truncateArrayFields.bind(generator);
      const input = {
        purpose: 'Test purpose',
        capabilities: Array.from({ length: 15 }, (_, i) => `capability${i}`),
        authentication: 'None',
        commonUseCases: [],
        limitations: [],
        relatedNodes: [],
      };

      const result = truncateMethod(input);

      expect(result.capabilities).toHaveLength(10);
      expect(result.capabilities[0]).toBe('capability0');
      expect(result.capabilities[9]).toBe('capability9');
    });

    it('should truncate commonUseCases array to 5 items', () => {
      const truncateMethod = (generator as any).truncateArrayFields.bind(generator);
      const input = {
        purpose: 'Test purpose',
        capabilities: [],
        authentication: 'None',
        commonUseCases: Array.from({ length: 8 }, (_, i) => `useCase${i}`),
        limitations: [],
        relatedNodes: [],
      };

      const result = truncateMethod(input);

      expect(result.commonUseCases).toHaveLength(5);
      expect(result.commonUseCases[0]).toBe('useCase0');
      expect(result.commonUseCases[4]).toBe('useCase4');
    });

    it('should truncate limitations array to 5 items', () => {
      const truncateMethod = (generator as any).truncateArrayFields.bind(generator);
      const input = {
        purpose: 'Test purpose',
        capabilities: [],
        authentication: 'None',
        commonUseCases: [],
        limitations: Array.from({ length: 10 }, (_, i) => `limitation${i}`),
        relatedNodes: [],
      };

      const result = truncateMethod(input);

      expect(result.limitations).toHaveLength(5);
      expect(result.limitations[0]).toBe('limitation0');
      expect(result.limitations[4]).toBe('limitation4');
    });

    it('should truncate relatedNodes array to 5 items', () => {
      const truncateMethod = (generator as any).truncateArrayFields.bind(generator);
      const input = {
        purpose: 'Test purpose',
        capabilities: [],
        authentication: 'None',
        commonUseCases: [],
        limitations: [],
        relatedNodes: Array.from({ length: 7 }, (_, i) => `node${i}`),
      };

      const result = truncateMethod(input);

      expect(result.relatedNodes).toHaveLength(5);
      expect(result.relatedNodes[0]).toBe('node0');
      expect(result.relatedNodes[4]).toBe('node4');
    });

    it('should not modify arrays within limits', () => {
      const truncateMethod = (generator as any).truncateArrayFields.bind(generator);
      const input = {
        purpose: 'Test purpose',
        capabilities: ['cap1', 'cap2', 'cap3'],
        authentication: 'None',
        commonUseCases: ['use1', 'use2'],
        limitations: ['lim1'],
        relatedNodes: [],
      };

      const result = truncateMethod(input);

      expect(result.capabilities).toHaveLength(3);
      expect(result.commonUseCases).toHaveLength(2);
      expect(result.limitations).toHaveLength(1);
      expect(result.relatedNodes).toHaveLength(0);
    });

    it('should not modify arrays at exact limits', () => {
      const truncateMethod = (generator as any).truncateArrayFields.bind(generator);
      const input = {
        purpose: 'Test purpose',
        capabilities: Array.from({ length: 10 }, (_, i) => `cap${i}`),
        authentication: 'None',
        commonUseCases: Array.from({ length: 5 }, (_, i) => `use${i}`),
        limitations: Array.from({ length: 5 }, (_, i) => `lim${i}`),
        relatedNodes: Array.from({ length: 5 }, (_, i) => `node${i}`),
      };

      const result = truncateMethod(input);

      expect(result.capabilities).toHaveLength(10);
      expect(result.commonUseCases).toHaveLength(5);
      expect(result.limitations).toHaveLength(5);
      expect(result.relatedNodes).toHaveLength(5);
    });

    it('should handle empty arrays', () => {
      const truncateMethod = (generator as any).truncateArrayFields.bind(generator);
      const input = {
        purpose: 'Test purpose',
        capabilities: [],
        authentication: 'None',
        commonUseCases: [],
        limitations: [],
        relatedNodes: [],
      };

      const result = truncateMethod(input);

      expect(result.capabilities).toHaveLength(0);
      expect(result.commonUseCases).toHaveLength(0);
      expect(result.limitations).toHaveLength(0);
      expect(result.relatedNodes).toHaveLength(0);
    });

    it('should preserve non-array fields unchanged', () => {
      const truncateMethod = (generator as any).truncateArrayFields.bind(generator);
      const input = {
        purpose: 'This is a long purpose string',
        capabilities: Array.from({ length: 15 }, (_, i) => `cap${i}`),
        authentication: 'OAuth2 with refresh token',
        commonUseCases: [],
        limitations: [],
        relatedNodes: [],
        extraField: 'should be preserved',
      };

      const result = truncateMethod(input);

      expect(result.purpose).toBe('This is a long purpose string');
      expect(result.authentication).toBe('OAuth2 with refresh token');
      expect(result.extraField).toBe('should be preserved');
    });

    it('should handle missing array fields gracefully', () => {
      const truncateMethod = (generator as any).truncateArrayFields.bind(generator);
      const input = {
        purpose: 'Test purpose',
        authentication: 'None',
        // Missing: capabilities, commonUseCases, limitations, relatedNodes
      };

      const result = truncateMethod(input);

      expect(result.purpose).toBe('Test purpose');
      expect(result.authentication).toBe('None');
      expect(result.capabilities).toBeUndefined();
    });

    it('should truncate multiple arrays simultaneously', () => {
      const truncateMethod = (generator as any).truncateArrayFields.bind(generator);
      const input = {
        purpose: 'Test purpose',
        capabilities: Array.from({ length: 12 }, (_, i) => `cap${i}`),
        authentication: 'None',
        commonUseCases: Array.from({ length: 8 }, (_, i) => `use${i}`),
        limitations: Array.from({ length: 6 }, (_, i) => `lim${i}`),
        relatedNodes: Array.from({ length: 10 }, (_, i) => `node${i}`),
      };

      const result = truncateMethod(input);

      expect(result.capabilities).toHaveLength(10);
      expect(result.commonUseCases).toHaveLength(5);
      expect(result.limitations).toHaveLength(5);
      expect(result.relatedNodes).toHaveLength(5);
    });

    it('should preserve order of items when truncating', () => {
      const truncateMethod = (generator as any).truncateArrayFields.bind(generator);
      const input = {
        purpose: 'Test purpose',
        capabilities: ['first', 'second', 'third', 'fourth', 'fifth', 'sixth', 'seventh', 'eighth', 'ninth', 'tenth', 'eleventh', 'twelfth'],
        authentication: 'None',
        commonUseCases: [],
        limitations: [],
        relatedNodes: [],
      };

      const result = truncateMethod(input);

      expect(result.capabilities[0]).toBe('first');
      expect(result.capabilities[9]).toBe('tenth');
      expect(result.capabilities).not.toContain('eleventh');
      expect(result.capabilities).not.toContain('twelfth');
    });

    it('should handle non-string array items', () => {
      const truncateMethod = (generator as any).truncateArrayFields.bind(generator);
      const input = {
        purpose: 'Test purpose',
        capabilities: Array.from({ length: 12 }, (_, i) => ({ id: i, name: `cap${i}` })),
        authentication: 'None',
        commonUseCases: [],
        limitations: [],
        relatedNodes: [],
      };

      const result = truncateMethod(input);

      expect(result.capabilities).toHaveLength(10);
      expect(result.capabilities[0]).toEqual({ id: 0, name: 'cap0' });
      expect(result.capabilities[9]).toEqual({ id: 9, name: 'cap9' });
    });

    it('should create a new object and not mutate the original', () => {
      const truncateMethod = (generator as any).truncateArrayFields.bind(generator);
      const original = {
        purpose: 'Test purpose',
        capabilities: Array.from({ length: 15 }, (_, i) => `cap${i}`),
        authentication: 'None',
        commonUseCases: [],
        limitations: [],
        relatedNodes: [],
      };
      const originalCapabilitiesLength = original.capabilities.length;

      const result = truncateMethod(original);

      // Original should not be mutated
      expect(original.capabilities).toHaveLength(originalCapabilitiesLength);
      // Result should be truncated
      expect(result.capabilities).toHaveLength(10);
      // They should not be the same reference
      expect(result).not.toBe(original);
    });
  });
});