import { describe, it, expect } from '@jest/globals';
import { getPrompts, getPrompt, PROMPTS } from '../src/prompts/index.js';

describe('Prompts', () => {
  describe('getPrompts', () => {
    it('should return all 8 prompts', () => {
      const prompts = getPrompts();
      expect(prompts).toHaveLength(8);
    });

    it('should return prompts with required fields', () => {
      const prompts = getPrompts();
      for (const prompt of prompts) {
        expect(prompt).toHaveProperty('name');
        expect(prompt).toHaveProperty('description');
        expect(typeof prompt.name).toBe('string');
        expect(typeof prompt.description).toBe('string');
        expect(prompt.name.length).toBeGreaterThan(0);
        expect(prompt.description.length).toBeGreaterThan(0);
      }
    });

    it('should return prompts with arguments array', () => {
      const prompts = getPrompts();
      for (const prompt of prompts) {
        expect(Array.isArray(prompt.arguments)).toBe(true);
      }
    });

    it('should not expose buildMessages function', () => {
      const prompts = getPrompts();
      for (const prompt of prompts) {
        expect(prompt).not.toHaveProperty('buildMessages');
      }
    });

    it('should have unique prompt names', () => {
      const prompts = getPrompts();
      const names = prompts.map((p) => p.name);
      const uniqueNames = new Set(names);
      expect(uniqueNames.size).toBe(names.length);
    });
  });

  describe('getPrompt', () => {
    it('should throw for unknown prompt', () => {
      expect(() => getPrompt('nonexistent', {})).toThrow('Unknown prompt: nonexistent');
    });

    it('should return description and messages', () => {
      const result = getPrompt('reframe', { problem: 'Test problem' });
      expect(result).toHaveProperty('description');
      expect(result).toHaveProperty('messages');
      expect(Array.isArray(result.messages)).toBe(true);
      expect(result.messages.length).toBeGreaterThan(0);
    });

    it('should throw for missing required arguments', () => {
      expect(() => getPrompt('perspectives', {})).toThrow();
      expect(() => getPrompt('perspectives', { problem: 'test' })).toThrow(); // missing perspectives
    });

    it('should wrap errors with prompt context', () => {
      try {
        getPrompt('perspectives', {});
        fail('Should have thrown');
      } catch (e) {
        expect((e as Error).message).toMatch(/^Failed to build prompt "perspectives":/);
        expect((e as Error).message).toContain('problem argument is required');
      }
    });

    it('should handle empty string arguments as missing', () => {
      expect(() => getPrompt('perspectives', { problem: '', perspectives: 'test' })).toThrow(
        'problem argument is required'
      );
    });

    it('should handle whitespace-only arguments as valid', () => {
      // Whitespace is truthy in JS, so it passes validation (this is intentional)
      const result = getPrompt('perspectives', { problem: '   ', perspectives: 'test' });
      expect(result.messages).toHaveLength(1);
    });
  });

  describe('perspectives prompt', () => {
    it('should require problem and perspectives arguments', () => {
      expect(() => getPrompt('perspectives', {})).toThrow('problem argument is required');
      expect(() => getPrompt('perspectives', { problem: 'test' })).toThrow(
        'perspectives argument is required'
      );
    });

    it('should build valid messages with required args', () => {
      const result = getPrompt('perspectives', {
        problem: 'Test problem',
        perspectives: 'security, performance',
      });
      expect(result.messages).toHaveLength(1);
      expect(result.messages[0].role).toBe('user');
      expect(result.messages[0].content).toHaveProperty('type', 'text');
    });

    it('should include optional context in message', () => {
      const result = getPrompt('perspectives', {
        problem: 'Test problem',
        perspectives: 'security',
        context: 'Additional context',
      });
      const text = (result.messages[0].content as { type: string; text: string }).text;
      expect(text).toContain('Additional context');
    });
  });

  describe('assumptions prompt', () => {
    it('should require plan argument', () => {
      expect(() => getPrompt('assumptions', {})).toThrow('plan argument is required');
    });

    it('should build valid messages', () => {
      const result = getPrompt('assumptions', { plan: 'Test plan' });
      expect(result.messages).toHaveLength(1);
      const text = (result.messages[0].content as { type: string; text: string }).text;
      expect(text).toContain('Test plan');
    });

    it('should include optional constraints and concerns', () => {
      const result = getPrompt('assumptions', {
        plan: 'Test plan',
        constraints: 'Must be fast',
        concerns: 'Worried about scale',
      });
      const text = (result.messages[0].content as { type: string; text: string }).text;
      expect(text).toContain('Must be fast');
      expect(text).toContain('Worried about scale');
    });
  });

  describe('blindspots prompt', () => {
    it('should require proposal argument', () => {
      expect(() => getPrompt('blindspots', {})).toThrow('proposal argument is required');
    });

    it('should build valid messages', () => {
      const result = getPrompt('blindspots', { proposal: 'Test proposal' });
      expect(result.messages).toHaveLength(1);
    });
  });

  describe('tradeoffs prompt', () => {
    it('should require options and criteria arguments', () => {
      expect(() => getPrompt('tradeoffs', {})).toThrow('options argument is required');
      expect(() => getPrompt('tradeoffs', { options: 'A, B' })).toThrow(
        'criteria argument is required'
      );
    });

    it('should build valid messages with required args', () => {
      const result = getPrompt('tradeoffs', {
        options: 'Option A, Option B',
        criteria: 'cost, speed',
      });
      expect(result.messages).toHaveLength(1);
    });
  });

  describe('red_team prompt', () => {
    it('should require target argument', () => {
      expect(() => getPrompt('red_team', {})).toThrow('target argument is required');
    });

    it('should build valid messages', () => {
      const result = getPrompt('red_team', { target: 'Test system' });
      expect(result.messages).toHaveLength(1);
      const text = (result.messages[0].content as { type: string; text: string }).text;
      expect(text).toContain('Test system');
    });
  });

  describe('reframe prompt', () => {
    it('should require problem argument', () => {
      expect(() => getPrompt('reframe', {})).toThrow('problem argument is required');
    });

    it('should include three reframing types', () => {
      const result = getPrompt('reframe', { problem: 'Test problem' });
      const text = (result.messages[0].content as { type: string; text: string }).text;
      expect(text).toContain('HIGHER ABSTRACTION');
      expect(text).toContain('INVERSION');
      expect(text).toContain('SIMPLIFICATION');
    });
  });

  describe('architecture prompt', () => {
    it('should require design, workloads, and priorities arguments', () => {
      expect(() => getPrompt('architecture', {})).toThrow('design argument is required');
      expect(() => getPrompt('architecture', { design: 'test' })).toThrow(
        'workloads argument is required'
      );
      expect(() => getPrompt('architecture', { design: 'test', workloads: 'test' })).toThrow(
        'priorities argument is required'
      );
    });

    it('should build valid messages with all required args', () => {
      const result = getPrompt('architecture', {
        design: 'Microservices',
        workloads: '1000 req/s',
        priorities: 'latency, cost',
      });
      expect(result.messages).toHaveLength(1);
    });

    it('should include cross-cutting concerns', () => {
      const result = getPrompt('architecture', {
        design: 'test',
        workloads: 'test',
        priorities: 'test',
      });
      const text = (result.messages[0].content as { type: string; text: string }).text;
      expect(text).toContain('Scalability');
      expect(text).toContain('Reliability');
      expect(text).toContain('Operational Complexity');
      expect(text).toContain('Developer Experience');
      expect(text).toContain('Cost Efficiency');
    });
  });

  describe('diverge_converge prompt', () => {
    it('should require challenge argument', () => {
      expect(() => getPrompt('diverge_converge', {})).toThrow('challenge argument is required');
    });

    it('should include diverge and converge phases', () => {
      const result = getPrompt('diverge_converge', { challenge: 'Test challenge' });
      const text = (result.messages[0].content as { type: string; text: string }).text;
      expect(text).toContain('PHASE 1: DIVERGE');
      expect(text).toContain('PHASE 2: CONVERGE');
    });

    it('should use default width and criteria when not provided', () => {
      const result = getPrompt('diverge_converge', { challenge: 'Test challenge' });
      const text = (result.messages[0].content as { type: string; text: string }).text;
      expect(text).toContain('balanced');
      expect(text).toContain('feasibility, impact, and effort required');
    });
  });

  describe('PROMPTS registry', () => {
    it('should have all expected prompts', () => {
      const expectedNames = [
        'perspectives',
        'assumptions',
        'blindspots',
        'tradeoffs',
        'red_team',
        'reframe',
        'architecture',
        'diverge_converge',
      ];
      for (const name of expectedNames) {
        expect(PROMPTS).toHaveProperty(name);
      }
    });

    it('should have buildMessages function for all prompts', () => {
      for (const [name, prompt] of Object.entries(PROMPTS)) {
        expect(typeof prompt.buildMessages).toBe('function');
        expect(prompt.name).toBe(name);
      }
    });
  });

  describe('MCP spec compliance', () => {
    it('should return messages with valid role (user or assistant)', () => {
      const result = getPrompt('reframe', { problem: 'test' });
      for (const message of result.messages) {
        expect(['user', 'assistant']).toContain(message.role);
      }
    });

    it('should return messages with valid content type', () => {
      const result = getPrompt('reframe', { problem: 'test' });
      for (const message of result.messages) {
        const content = message.content as { type: string; text?: string };
        expect(['text', 'image', 'resource']).toContain(content.type);
        if (content.type === 'text') {
          expect(typeof content.text).toBe('string');
        }
      }
    });

    it('should preserve user input in generated messages', () => {
      const userInput = 'Special chars: <>&"\' and unicode: 日本語';
      const result = getPrompt('reframe', { problem: userInput });
      const text = (result.messages[0].content as { type: string; text: string }).text;
      expect(text).toContain(userInput);
    });

    it('should handle very long inputs without truncation', () => {
      const longInput = 'x'.repeat(50000);
      const result = getPrompt('reframe', { problem: longInput });
      const text = (result.messages[0].content as { type: string; text: string }).text;
      expect(text).toContain(longInput);
    });

    it('should handle inputs with newlines and special whitespace', () => {
      const multilineInput = 'Line 1\nLine 2\n\tTabbed line\r\nWindows line';
      const result = getPrompt('reframe', { problem: multilineInput });
      const text = (result.messages[0].content as { type: string; text: string }).text;
      expect(text).toContain(multilineInput);
    });
  });
});