"""
Integration tests for Language Context Manager

Tests the integration of language context management with the overall system
to verify requirements are met.
"""

import unittest
from chat_agent.services import LanguageContextManager


class TestLanguageContextIntegration(unittest.TestCase):
    """Integration tests for LanguageContextManager."""
    
    def setUp(self):
        """Set up test fixtures."""
        self.manager = LanguageContextManager()
    
    def test_requirement_1_1_default_python(self):
        """
        Test Requirement 1.1: WHEN a user starts a new chat session 
        THEN the system SHALL default to Python as the programming language
        """
        session_id = "new-user-session"
        
        # New session should default to Python
        language = self.manager.get_language(session_id)
        self.assertEqual(language, 'python')
        
        # Context should also default to Python
        context = self.manager.get_session_context(session_id)
        self.assertEqual(context['language'], 'python')
        self.assertIn('Python', context['prompt_template'])
    
    def test_requirement_1_2_language_switching(self):
        """
        Test Requirement 1.2: WHEN a user explicitly selects a different programming language 
        THEN the system SHALL switch context to that language for subsequent interactions
        """
        session_id = "language-switch-session"
        
        # Start with default Python
        self.assertEqual(self.manager.get_language(session_id), 'python')
        
        # Switch to JavaScript
        result = self.manager.set_language(session_id, 'javascript')
        self.assertTrue(result)
        
        # Verify language switched
        language = self.manager.get_language(session_id)
        self.assertEqual(language, 'javascript')
        
        # Verify context updated for subsequent interactions
        template = self.manager.get_language_prompt_template(session_id=session_id)
        self.assertIn('JavaScript', template)
        self.assertNotIn('Python', template)
    
    def test_requirement_1_3_language_specific_responses(self):
        """
        Test Requirement 1.3: WHEN a user asks language-specific questions 
        THEN the system SHALL provide responses tailored to the selected programming language
        """
        session_id = "language-specific-session"
        
        # Test different languages have different prompt templates
        languages_to_test = ['python', 'java', 'javascript', 'cpp']
        
        for language in languages_to_test:
            with self.subTest(language=language):
                self.manager.set_language(session_id, language)
                template = self.manager.get_language_prompt_template(session_id=session_id)
                
                # Each language should have its specific template
                display_name = self.manager.get_language_display_name(language)
                self.assertIn(display_name, template)
                self.assertIn('programming assistant', template)
    
    def test_requirement_1_5_language_switching_preserves_session(self):
        """
        Test Requirement 1.5: WHEN a user switches languages mid-conversation 
        THEN the system SHALL maintain the chat history while updating the language context
        """
        session_id = "preserve-session-test"
        
        # Set initial language
        self.manager.set_language(session_id, 'python')
        initial_context = self.manager.get_session_context(session_id)
        
        # Switch language
        self.manager.set_language(session_id, 'java')
        updated_context = self.manager.get_session_context(session_id)
        
        # Language should be updated
        self.assertEqual(updated_context['language'], 'java')
        self.assertIn('Java', updated_context['prompt_template'])
        
        # Session should be preserved (same session_id context exists)
        self.assertIsNotNone(updated_context['updated_at'])
        
        # Can still get context for the same session
        final_language = self.manager.get_language(session_id)
        self.assertEqual(final_language, 'java')
    
    def test_supported_languages_comprehensive(self):
        """Test that all major programming languages are supported."""
        supported = self.manager.get_supported_languages()
        
        # Verify major languages are supported
        expected_languages = {
            'python', 'javascript', 'java', 'cpp', 'csharp', 
            'go', 'rust', 'typescript', 'c', 'php', 'ruby', 'swift'
        }
        
        self.assertTrue(expected_languages.issubset(supported))
        
        # Test that each supported language has a prompt template
        for language in supported:
            template = self.manager.get_language_prompt_template(language=language)
            self.assertIsInstance(template, str)
            self.assertGreater(len(template), 0)
    
    def test_multiple_concurrent_sessions(self):
        """Test that multiple sessions can have different language contexts simultaneously."""
        sessions = {
            'session-1': 'python',
            'session-2': 'javascript', 
            'session-3': 'java',
            'session-4': 'cpp'
        }
        
        # Set different languages for each session
        for session_id, language in sessions.items():
            result = self.manager.set_language(session_id, language)
            self.assertTrue(result)
        
        # Verify each session maintains its own context
        for session_id, expected_language in sessions.items():
            actual_language = self.manager.get_language(session_id)
            self.assertEqual(actual_language, expected_language)
            
            template = self.manager.get_language_prompt_template(session_id=session_id)
            display_name = self.manager.get_language_display_name(expected_language)
            self.assertIn(display_name, template)


if __name__ == '__main__':
    unittest.main()