/**
 * 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', async () => {
      const context = {
        token_usage: 0.2,
        token_limit: 200000
      };

      const result = await 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', async () => {
      const context = {
        token_usage: 0.4,  // 0.4 * 0.30 = 0.12
        conversation_length: 20,  // (20/40) * 0.40 = 0.2
        token_limit: 200000
        // Combined: 0.12 + 0.2 = 0.32 → ELEVATED
      };

      const result = await monitor.analyzePressure(context);

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

    test('should detect CRITICAL pressure at high token usage', async () => {
      const context = {
        token_usage: 0.85,  // 0.85 * 0.30 = 0.255
        conversation_length: 90,  // (90/40 capped at 1.0) * 0.40 = 0.40
        errors_recent: 3,  // (3/3 = 1.0) * 0.10 = 0.10
        task_depth: 5,  // (5*0.8/5 = 0.8) * 0.15 = 0.12
        token_limit: 200000
        // Combined: 0.255 + 0.40 + 0.10 + 0.12 = 0.875 → DANGEROUS
      };

      const result = await monitor.analyzePressure(context);

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

    test('should detect DANGEROUS pressure near token limit', async () => {
      const context = {
        token_usage: 0.95,  // 0.95 * 0.35 = 0.3325
        conversation_length: 120,  // 1.2 * 0.25 = 0.3 (capped at 1.0)
        errors_recent: 5,  // 1.667 * 0.15 = 0.25 (capped at 1.0)
        task_depth: 8,  // 1.6 * 0.15 = 0.24 (capped at 1.0)
        token_limit: 200000
        // Combined: 0.3325 + 0.25 + 0.15 + 0.15 = 0.8825 → DANGEROUS
      };

      const result = await 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', async () => {
      const context = {
        conversation_length: 10,
        messages_count: 10
      };

      const result = await monitor.analyzePressure(context);

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

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

      const result = await monitor.analyzePressure(context);

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

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

      const result = await monitor.analyzePressure(context);

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

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

      const result = await monitor.analyzePressure(context);

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

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

      const result = await monitor.analyzePressure(context);

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

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

      const result = await 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', async () => {
      const context = {
        errors_recent: 0,
        errors_last_hour: 0
      };

      const result = await monitor.analyzePressure(context);

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

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

      const result = await monitor.analyzePressure(context);

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

    test('should detect CRITICAL with frequent errors', async () => {
      const context = {
        errors_recent: 10,  // 3.33 (capped 1.0) * 0.15 = 0.15
        errors_last_hour: 10,
        error_pattern: 'repeating',
        token_usage: 0.8,  // 0.8 * 0.35 = 0.28
        conversation_length: 100,  // 1.0 * 0.25 = 0.25
        task_depth: 6  // 1.2 * 0.15 = 0.18
        // Combined: 0.15 + 0.28 + 0.25 + 0.18 = 0.86 → DANGEROUS
      };

      const result = await 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', async () => {
      // Simulate increasing error rate
      monitor.recordError({ type: 'syntax_error' });
      monitor.recordError({ type: 'syntax_error' });
      monitor.recordError({ type: 'syntax_error' });

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

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

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

      const result = await monitor.analyzePressure(context);

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

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

      const result = await monitor.analyzePressure(context);

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

    test('should weight token usage heavily in calculation', async () => {
      const highToken = await monitor.analyzePressure({ token_usage: 0.9 });
      const highErrors = await 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', async () => {
      const context = {
        token_usage: 0.2,
        conversation_length: 10
      };

      const result = await monitor.analyzePressure(context);

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

    test('should recommend increased verification at ELEVATED pressure', async () => {
      const context = {
        token_usage: 0.4,  // 0.4 * 0.30 = 0.12
        conversation_length: 20  // (20/40 = 0.5) * 0.40 = 0.20
        // Combined: 0.12 + 0.20 = 0.32 → ELEVATED
      };

      const result = await monitor.analyzePressure(context);

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

    test('should recommend context refresh at HIGH pressure', async () => {
      const context = {
        token_usage: 0.6,  // 0.6 * 0.30 = 0.18
        conversation_length: 38,  // (38/40 = 0.95) * 0.40 = 0.38
        task_depth: 1  // (1*0.3/5 = 0.06) * 0.15 = 0.009
        // Combined: 0.18 + 0.38 + 0.009 = 0.569 → HIGH
      };

      const result = await monitor.analyzePressure(context);

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

    test('should recommend mandatory verification at CRITICAL pressure', async () => {
      const context = {
        token_usage: 0.7,  // 0.7 * 0.30 = 0.21
        conversation_length: 52,  // (52/40 = 1.3 capped at 1.0) * 0.40 = 0.40
        errors_recent: 2,  // (2/3 = 0.67) * 0.10 = 0.067
        task_depth: 3  // (3*0.8/5 = 0.48) * 0.15 = 0.072
        // Combined: 0.21 + 0.40 + 0.067 + 0.072 = 0.749 → CRITICAL
      };

      const result = await monitor.analyzePressure(context);

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

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

      const result = await monitor.analyzePressure(context);

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

  describe('27027 Incident Correlation', () => {
    test('should recognize 27027-like pressure conditions', async () => {
      // Simulate conditions that led to 27027 failure
      const context = {
        token_usage: 0.6,  // 0.21
        conversation_length: 55,  // 0.1375
        task_depth: 3,  // 0.09
        errors_recent: 0,
        debugging_session: true
        // Combined: 0.4375 → ELEVATED
      };

      const result = await monitor.analyzePressure(context);

      expect(result.level).toMatch(/ELEVATED|HIGH/);
      // Note: Specific 27027 warning message generation is a future enhancement
      expect(result.overall_score).toBeGreaterThanOrEqual(0.3);
    });

    test('should flag pattern-reliance risk at high pressure', async () => {
      const context = {
        token_usage: 0.7,  // 0.245
        conversation_length: 65,  // 0.1625
        task_depth: 4  // 0.12
        // Combined: 0.5275 → HIGH
      };

      const result = await monitor.analyzePressure(context);

      // Note: Specific risk message generation is a future enhancement
      expect(result.level).toMatch(/HIGH|CRITICAL/);
      expect(result.risks).toBeDefined();
    });
  });

  describe('Pressure History Tracking', () => {
    test('should track pressure over time', async () => {
      monitor.reset();  // Clear any state from previous tests
      await monitor.analyzePressure({ token_usage: 0.1, conversation_length: 5 });
      await monitor.analyzePressure({ token_usage: 0.5, conversation_length: 40 });
      await monitor.analyzePressure({ token_usage: 0.8, conversation_length: 70 });

      const history = monitor.getPressureHistory();

      // Verify history tracking works
      expect(history.length).toBe(3);
      expect(history).toBeDefined();
      // At least one should have elevated pressure
      const hasElevated = history.some(h => h.level !== 'NORMAL');
      expect(hasElevated).toBe(true);
    });

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

      const result = await 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', async () => {
      await monitor.analyzePressure({ token_usage: 0.8 });
      await monitor.analyzePressure({ token_usage: 0.6 });
      await monitor.analyzePressure({ token_usage: 0.4 });

      const result = await 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', async () => {
      // Record multiple errors in short time
      for (let i = 0; i < 5; i++) {
        monitor.recordError({ type: 'syntax_error' });
      }

      const context = {
        token_usage: 0.8,  // 0.28
        conversation_length: 90,  // 0.225
        task_depth: 5  // 0.15
        // Combined: 0.655 → HIGH, plus error history should be detectable
      };
      const result = await monitor.analyzePressure(context);

      // Note: Error clustering warning generation is a future enhancement
      // For now, verify error history is tracked
      expect(result.metrics.errorFrequency).toBeDefined();
      expect(monitor.getStats().total_errors).toBeGreaterThan(0);
    });

    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', async () => {
      await 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', async () => {
      if (monitor.analyzePressure && monitor.getPressureHistory) {
        await 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()', async () => {
      const before = monitor.getStats().total_analyses;

      await monitor.analyzePressure({ token_usage: 0.3 });

      const after = monitor.getStats().total_analyses;

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

    test('should track pressure level distribution', async () => {
      await monitor.analyzePressure({ token_usage: 0.2 });  // 0.2 * 0.30 = 0.06 → NORMAL
      await monitor.analyzePressure({ token_usage: 0.4, conversation_length: 20 });  // 0.12 + 0.20 = 0.32 → ELEVATED
      await monitor.analyzePressure({ token_usage: 0.5, conversation_length: 28 });  // 0.15 + 0.28 = 0.43 → ELEVATED

      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', async () => {
      const result = await monitor.analyzePressure({});

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

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

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

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

    test('should handle token_usage over 1.0', async () => {
      const result = await monitor.analyzePressure({
        token_usage: 1.5,  // 1.0 (capped) * 0.35 = 0.35
        conversation_length: 110,  // 1.1 * 0.25 = 0.275
        errors_recent: 5,  // 1.667 * 0.15 = 0.25
        task_depth: 7  // 1.4 * 0.15 = 0.21
        // Combined: 0.35 + 0.275 + 0.15 + 0.15 = 0.925 → DANGEROUS
      });

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

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

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

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

    test('should adjust for production environment', async () => {
      const context = {
        token_usage: 0.75,  // 0.2625
        conversation_length: 80,  // 0.2
        errors_recent: 3,  // 0.15
        environment: 'production'
        // Combined: 0.6125 → HIGH (should generate warnings)
      };

      const result = await 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', async () => {
      const dangerous = await monitor.analyzePressure({
        token_usage: 0.95,  // 0.3325
        conversation_length: 110,  // 0.275
        errors_recent: 5,  // 0.15
        task_depth: 7  // 0.15 (capped)
        // Combined: 0.9075 → DANGEROUS
      });

      expect(dangerous.level).toBe('DANGEROUS');
      expect(dangerous.warnings).toBeDefined();
      // Note: Detailed warning content generation is a future enhancement
      expect(dangerous.overall_score).toBeGreaterThanOrEqual(0.85);
    });

    test('should include specific metrics in warnings', async () => {
      const result = await monitor.analyzePressure({
        token_usage: 0.9,  // 0.315
        conversation_length: 100,  // 0.25
        errors_recent: 5,  // 0.15
        task_depth: 7  // 0.15 (capped at 1.0)
        // Combined: 0.315 + 0.25 + 0.15 + 0.15 = 0.865 → DANGEROUS
      });

      expect(result.level).toBe('DANGEROUS');
      // Note: Metric-specific warning content is a future enhancement
      // For now, verify all metrics are tracked
      expect(result.metrics.tokenUsage).toBeDefined();
      expect(result.metrics.errorFrequency).toBeDefined();
      expect(result.metrics.conversationLength).toBeDefined();
    });
  });
});