/**
 * Unit Tests for ContextPressureMonitor
 * Tests context pressure analysis and error probability detection
 */

const monitor = require('../../src/services/ContextPressureMonitor.service');

describe('ContextPressureMonitor', () => {
  beforeEach(() => {
    // Reset monitor state if method exists
    if (monitor.reset) {
      monitor.reset();
    }
  });

  describe('Token Usage Pressure', () => {
    test('should detect NORMAL pressure at low token usage', () => {
      const context = {
        token_usage: 0.2,
        token_limit: 200000
      };

      const result = monitor.analyzePressure(context);

      expect(result.level).toBe('NORMAL');
      expect(result.metrics.tokenUsage.score).toBeLessThan(0.5);
    });

    test('should detect ELEVATED pressure at moderate token usage', () => {
      const context = {
        token_usage: 0.55,
        token_limit: 200000
      };

      const result = monitor.analyzePressure(context);

      expect(['ELEVATED', 'HIGH']).toContain(result.level);
    });

    test('should detect CRITICAL pressure at high token usage', () => {
      const context = {
        token_usage: 0.85,
        token_limit: 200000
      };

      const result = monitor.analyzePressure(context);

      expect(['HIGH', 'CRITICAL']).toContain(result.level);
    });

    test('should detect DANGEROUS pressure near token limit', () => {
      const context = {
        token_usage: 0.95,
        token_limit: 200000
      };

      const result = monitor.analyzePressure(context);

      expect(['CRITICAL', 'DANGEROUS']).toContain(result.level);
      expect(result.recommendations).toContain('IMMEDIATE_HALT');
    });
  });

  describe('Conversation Length Pressure', () => {
    test('should detect NORMAL pressure for short conversations', () => {
      const context = {
        conversation_length: 10,
        messages_count: 10
      };

      const result = monitor.analyzePressure(context);

      expect(result.metrics.conversationLength.score).toBeLessThan(0.5);
    });

    test('should detect ELEVATED pressure for medium conversations', () => {
      const context = {
        conversation_length: 50,
        messages_count: 50
      };

      const result = monitor.analyzePressure(context);

      expect(result.metrics.conversationLength.score).toBeGreaterThan(0);
    });

    test('should detect HIGH pressure for long conversations', () => {
      const context = {
        conversation_length: 100,
        messages_count: 100
      };

      const result = monitor.analyzePressure(context);

      expect(result.metrics.conversationLength.score).toBeGreaterThan(0.5);
    });
  });

  describe('Task Complexity Pressure', () => {
    test('should detect low complexity for simple tasks', () => {
      const context = {
        task_depth: 1,
        dependencies: 0,
        file_modifications: 1
      };

      const result = monitor.analyzePressure(context);

      expect(result.metrics.taskComplexity.score).toBeLessThan(0.3);
    });

    test('should detect high complexity for multi-step tasks', () => {
      const context = {
        task_depth: 5,
        dependencies: 10,
        file_modifications: 15,
        concurrent_operations: 8
      };

      const result = monitor.analyzePressure(context);

      expect(result.metrics.taskComplexity.score).toBeGreaterThan(0.5);
    });

    test('should consider nested sub-tasks in complexity', () => {
      const context = {
        task_depth: 3,
        subtasks_pending: 12,
        dependencies: 8
      };

      const result = monitor.analyzePressure(context);

      expect(result.metrics.taskComplexity).toBeDefined();
      expect(result.metrics.taskComplexity.factors).toContain('high task depth');
    });
  });

  describe('Error Frequency Pressure', () => {
    test('should detect NORMAL with no recent errors', () => {
      const context = {
        errors_recent: 0,
        errors_last_hour: 0
      };

      const result = monitor.analyzePressure(context);

      expect(result.metrics.errorFrequency.score).toBe(0);
    });

    test('should detect ELEVATED with occasional errors', () => {
      const context = {
        errors_recent: 2,
        errors_last_hour: 2
      };

      const result = monitor.analyzePressure(context);

      expect(result.metrics.errorFrequency.score).toBeGreaterThan(0);
    });

    test('should detect CRITICAL with frequent errors', () => {
      const context = {
        errors_recent: 10,
        errors_last_hour: 10,
        error_pattern: 'repeating'
      };

      const result = monitor.analyzePressure(context);

      expect(result.metrics.errorFrequency.score).toBeGreaterThan(0.7);
      expect(result.level).toMatch(/HIGH|CRITICAL|DANGEROUS/);
    });

    test('should track error patterns over time', () => {
      // Simulate increasing error rate
      monitor.recordError({ type: 'syntax_error' });
      monitor.recordError({ type: 'syntax_error' });
      monitor.recordError({ type: 'syntax_error' });

      const context = {};
      const result = monitor.analyzePressure(context);

      expect(result.metrics.errorFrequency.recent_errors).toBe(3);
    });
  });

  describe('Overall Pressure Level Calculation', () => {
    test('should calculate NORMAL when all metrics low', () => {
      const context = {
        token_usage: 0.1,
        conversation_length: 5,
        task_depth: 1,
        errors_recent: 0
      };

      const result = monitor.analyzePressure(context);

      expect(result.level).toBe('NORMAL');
      expect(result.overall_score).toBeLessThan(0.3);
    });

    test('should calculate CRITICAL when multiple metrics high', () => {
      const context = {
        token_usage: 0.8,
        conversation_length: 90,
        task_depth: 6,
        errors_recent: 8
      };

      const result = monitor.analyzePressure(context);

      expect(['CRITICAL', 'DANGEROUS']).toContain(result.level);
      expect(result.overall_score).toBeGreaterThan(0.7);
    });

    test('should weight token usage heavily in calculation', () => {
      const highToken = monitor.analyzePressure({ token_usage: 0.9 });
      const highErrors = monitor.analyzePressure({ errors_recent: 10 });

      // High token usage should produce higher pressure than high errors alone
      expect(highToken.overall_score).toBeGreaterThan(highErrors.overall_score);
    });
  });

  describe('Pressure Level Thresholds', () => {
    test('should use correct thresholds for each level', () => {
      const levels = [
        { score: 0.1, expected: 'NORMAL' },
        { score: 0.35, expected: 'ELEVATED' },
        { score: 0.55, expected: 'HIGH' },
        { score: 0.75, expected: 'CRITICAL' },
        { score: 0.95, expected: 'DANGEROUS' }
      ];

      levels.forEach(({ score, expected }) => {
        const result = monitor._determinePressureLevel(score);
        expect(result).toBe(expected);
      });
    });
  });

  describe('Recommendations', () => {
    test('should recommend normal operation at NORMAL pressure', () => {
      const context = {
        token_usage: 0.2,
        conversation_length: 10
      };

      const result = monitor.analyzePressure(context);

      expect(result.recommendations).toContain('CONTINUE_NORMAL');
    });

    test('should recommend increased verification at ELEVATED pressure', () => {
      const context = {
        token_usage: 0.45,
        conversation_length: 40
      };

      const result = monitor.analyzePressure(context);

      expect(result.recommendations).toContain('INCREASE_VERIFICATION');
    });

    test('should recommend context refresh at HIGH pressure', () => {
      const context = {
        token_usage: 0.65,
        conversation_length: 75
      };

      const result = monitor.analyzePressure(context);

      expect(result.recommendations).toContain('SUGGEST_CONTEXT_REFRESH');
    });

    test('should recommend mandatory verification at CRITICAL pressure', () => {
      const context = {
        token_usage: 0.8,
        errors_recent: 8
      };

      const result = monitor.analyzePressure(context);

      expect(result.recommendations).toContain('MANDATORY_VERIFICATION');
    });

    test('should recommend immediate halt at DANGEROUS pressure', () => {
      const context = {
        token_usage: 0.95,
        conversation_length: 120,
        errors_recent: 15
      };

      const result = monitor.analyzePressure(context);

      expect(result.recommendations).toContain('IMMEDIATE_HALT');
    });
  });

  describe('27027 Incident Correlation', () => {
    test('should recognize 27027-like pressure conditions', () => {
      // Simulate conditions that led to 27027 failure
      const context = {
        token_usage: 0.535,  // 107k/200k
        conversation_length: 50,
        task_depth: 3,
        errors_recent: 0,
        debugging_session: true
      };

      const result = monitor.analyzePressure(context);

      expect(result.level).toMatch(/ELEVATED|HIGH/);
      expect(result.warnings).toContain('Conditions similar to documented failure modes');
    });

    test('should flag pattern-reliance risk at high pressure', () => {
      const context = {
        token_usage: 0.6,
        conversation_length: 60
      };

      const result = monitor.analyzePressure(context);

      expect(result.risks).toContain('increased pattern reliance');
    });
  });

  describe('Pressure History Tracking', () => {
    test('should track pressure over time', () => {
      monitor.analyzePressure({ token_usage: 0.2 });
      monitor.analyzePressure({ token_usage: 0.4 });
      monitor.analyzePressure({ token_usage: 0.6 });

      const history = monitor.getPressureHistory();

      expect(history.length).toBe(3);
      expect(history[0].level).toBe('NORMAL');
      expect(history[2].level).toMatch(/ELEVATED|HIGH/);
    });

    test('should detect pressure escalation trends', () => {
      monitor.analyzePressure({ token_usage: 0.3 });
      monitor.analyzePressure({ token_usage: 0.5 });
      monitor.analyzePressure({ token_usage: 0.7 });

      const result = monitor.analyzePressure({ token_usage: 0.8 });

      expect(result.trend).toBe('escalating');
      expect(result.warnings).toContain('Pressure is escalating rapidly');
    });

    test('should detect pressure de-escalation', () => {
      monitor.analyzePressure({ token_usage: 0.8 });
      monitor.analyzePressure({ token_usage: 0.6 });
      monitor.analyzePressure({ token_usage: 0.4 });

      const result = monitor.analyzePressure({ token_usage: 0.3 });

      expect(result.trend).toBe('improving');
    });
  });

  describe('Error Recording and Analysis', () => {
    test('should record errors with metadata', () => {
      monitor.recordError({
        type: 'platform_assumption',
        description: 'Used port 27017 instead of 27027',
        timestamp: new Date()
      });

      const stats = monitor.getStats();

      expect(stats.total_errors).toBe(1);
      expect(stats.error_types.platform_assumption).toBe(1);
    });

    test('should detect error clustering', () => {
      // Record multiple errors in short time
      for (let i = 0; i < 5; i++) {
        monitor.recordError({ type: 'syntax_error' });
      }

      const context = {};
      const result = monitor.analyzePressure(context);

      expect(result.warnings).toContain('Error clustering detected');
    });

    test('should track error patterns by type', () => {
      monitor.recordError({ type: 'platform_assumption' });
      monitor.recordError({ type: 'platform_assumption' });
      monitor.recordError({ type: 'context_loss' });

      const stats = monitor.getStats();

      expect(stats.error_types.platform_assumption).toBe(2);
      expect(stats.error_types.context_loss).toBe(1);
    });
  });

  describe('Reset and Cleanup', () => {
    test('should reset pressure monitoring state', () => {
      monitor.analyzePressure({ token_usage: 0.8 });
      monitor.recordError({ type: 'test' });

      monitor.reset();

      const stats = monitor.getStats();
      const history = monitor.getPressureHistory();

      expect(stats.total_analyses).toBe(0);
      expect(history).toHaveLength(0);
    });

    test('should clear error history on reset', () => {
      monitor.recordError({ type: 'test1' });
      monitor.recordError({ type: 'test2' });

      monitor.reset();

      const stats = monitor.getStats();
      expect(stats.total_errors).toBe(0);
    });
  });

  describe('Singleton Pattern', () => {
    test('should export singleton instance with required methods', () => {
      expect(typeof monitor.analyzePressure).toBe('function');
      expect(typeof monitor.recordError).toBe('function');
      expect(typeof monitor.getStats).toBe('function');
    });

    test('should maintain pressure history across calls', () => {
      if (monitor.analyzePressure && monitor.getPressureHistory) {
        monitor.analyzePressure({ token_usage: 0.5 });

        const history = monitor.getPressureHistory();

        expect(history).toBeDefined();
      }
    });
  });

  describe('Statistics Tracking', () => {
    test('should track analysis statistics', () => {
      const stats = monitor.getStats();

      expect(stats).toHaveProperty('total_analyses');
      expect(stats).toHaveProperty('by_level');
      expect(stats).toHaveProperty('total_errors');
    });

    test('should increment analysis count after analyzePressure()', () => {
      const before = monitor.getStats().total_analyses;

      monitor.analyzePressure({ token_usage: 0.3 });

      const after = monitor.getStats().total_analyses;

      expect(after).toBe(before + 1);
    });

    test('should track pressure level distribution', () => {
      monitor.analyzePressure({ token_usage: 0.2 });  // NORMAL
      monitor.analyzePressure({ token_usage: 0.4 });  // ELEVATED
      monitor.analyzePressure({ token_usage: 0.6 });  // HIGH

      const stats = monitor.getStats();

      expect(stats.by_level.NORMAL).toBeGreaterThan(0);
      expect(stats.by_level.ELEVATED).toBeGreaterThan(0);
    });
  });

  describe('Edge Cases', () => {
    test('should handle empty context gracefully', () => {
      const result = monitor.analyzePressure({});

      expect(result.level).toBe('NORMAL');
      expect(result.overall_score).toBeDefined();
    });

    test('should handle null context gracefully', () => {
      expect(() => {
        monitor.analyzePressure(null);
      }).not.toThrow();
    });

    test('should handle invalid token_usage values', () => {
      const result = monitor.analyzePressure({ token_usage: -1 });

      expect(result.metrics.tokenUsage.score).toBeGreaterThanOrEqual(0);
    });

    test('should handle token_usage over 1.0', () => {
      const result = monitor.analyzePressure({ token_usage: 1.5 });

      expect(result.level).toBe('DANGEROUS');
      expect(result.recommendations).toContain('IMMEDIATE_HALT');
    });
  });

  describe('Contextual Adjustments', () => {
    test('should consider debugging context in pressure calculation', () => {
      const normalContext = { token_usage: 0.5 };
      const debugContext = { token_usage: 0.5, debugging_session: true };

      const normalResult = monitor.analyzePressure(normalContext);
      const debugResult = monitor.analyzePressure(debugContext);

      // Debugging increases pressure
      expect(debugResult.overall_score).toBeGreaterThanOrEqual(normalResult.overall_score);
    });

    test('should adjust for production environment', () => {
      const context = {
        token_usage: 0.6,
        environment: 'production'
      };

      const result = monitor.analyzePressure(context);

      // Production should lower threshold for warnings
      expect(result.warnings.length).toBeGreaterThan(0);
    });
  });

  describe('Warning and Alert Generation', () => {
    test('should generate appropriate warnings for each pressure level', () => {
      const dangerous = monitor.analyzePressure({ token_usage: 0.95 });

      expect(dangerous.warnings.length).toBeGreaterThan(0);
      expect(dangerous.warnings.some(w => w.includes('critical'))).toBe(true);
    });

    test('should include specific metrics in warnings', () => {
      const result = monitor.analyzePressure({
        token_usage: 0.8,
        errors_recent: 10
      });

      expect(result.warnings.some(w => w.includes('token'))).toBe(true);
      expect(result.warnings.some(w => w.includes('error'))).toBe(true);
    });
  });
});