Initial commit without node_modules

.gitattributes

@@ -0,0 +1,11 @@
+custom_components/st-audiorec/** filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.tar.gz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+custom_components/** filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,47 @@
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*.pyc
+*.log
+*.sqlite3
+*.db
+venv/
+.venv/
+env/
+ENV/
+env.bak/
+pip-wheel-metadata/
+dist/
+*.egg-info/
+
+# Editor / OS
+.vscode/
+.idea/
+*.swp
+.DS_Store
+Thumbs.db
+
+# Node / frontend
+node_modules/
+npm-debug.log*
+yarn-error.log*
+package-lock.json
+.pnpm-debug.log
+
+# Specific frontend inside your component
+custom_components/st-audiorec/st_audiorec/frontend/node_modules/
+
+# Virtual env / credentials
+*.env
+.env.*
+
+# Hugging Face / caches
+.cache/
+.hf/
+
+# IDE metadata
+*.sublime-workspace
+*.sublime-project
+custom_components/st-audiorec/st_audiorec/frontend/node_modules

.kiro/specs/ai-questions/design.md

@@ -0,0 +1,262 @@
+# Design Document
+
+## Overview
+
+The AI Questions feature integrates with the existing SyncMaster broadcast system to provide interactive AI-powered questioning capabilities. Students can select any text segment from broadcast content and engage in natural language conversations with AI to better understand the material. The system leverages the existing Gemini AI infrastructure and maintains the current multilingual support.
+
+## Architecture
+
+### High-Level Architecture
+
+```
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   Broadcast UI  │    │  Question Engine│    │   AI Service    │
+│                 │    │                 │    │                 │
+│ - Text Selection│───▶│ - Context Prep  │───▶│ - Gemini AI     │
+│ - Ask AI Button │    │ - Question Proc │    │ - Translation   │
+│ - Response Area │◀───│ - Response Format│◀───│ - Conversation  │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+         │                       │                       │
+         │                       │                       │
+         ▼                       ▼                       ▼
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│ Session State   │    │ Question History│    │ Context Manager │
+│                 │    │                 │    │                 │
+│ - Selected Text │    │ - Q&A Pairs     │    │ - Text Context  │
+│ - Active Conv   │    │ - Timestamps    │    │ - Conversation  │
+│ - UI Language   │    │ - User Prefs    │    │ - Memory Mgmt   │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+```
+
+### Component Integration
+
+The AI Questions feature integrates seamlessly with existing components:
+- **Broadcast System**: Uses existing `broadcast_segments` for text selection
+- **Translation System**: Leverages current `translator.py` for AI responses
+- **UI System**: Extends Streamlit interface with question components
+
+## Components and Interfaces
+
+### 1. Question Engine (`ai_questions.py`)
+
+**Primary Class: `AIQuestionEngine`**
+
+```python
+class AIQuestionEngine:
+    def __init__(self, translator_instance):
+        self.translator = translator_instance
+        self.conversation_history = {}
+        self.question_templates = {
+            'ar': [
+                "اشرح هذا النص",
+                "أعطني أمثلة على هذا",
+                "ما معنى هذا؟",
+                "كيف يُستخدم هذا؟",
+                "ما أهمية هذا؟"
+            ],
+            'en': [
+                "Explain this text",
+                "Give me examples of this",
+                "What does this mean?",
+                "How is this used?",
+                "Why is this important?"
+            ]
+        }
+    
+    def process_question(self, selected_text, question, ui_language='ar'):
+        """Process user question about selected text"""
+        
+    def get_question_templates(self, ui_language='ar'):
+        """Get pre-defined question templates"""
+        
+    def format_ai_response(self, response, ui_language='ar'):
+        """Format AI response for display"""
+        
+    def save_conversation(self, text_id, question, answer):
+        """Save Q&A pair to conversation history"""
+        
+    def get_conversation_history(self, text_id):
+        """Retrieve conversation history for specific text"""
+```
+
+### 2. UI Components (Extended `app.py`)
+
+**Text Selection Interface**
+- Click-to-select functionality for broadcast segments
+- Visual highlighting of selected text
+- Context-aware "Ask AI" button activation
+
+**Question Input Modal**
+- Template selection buttons
+- Free-form question input
+- Context display showing selected text
+- Submit and cancel options
+
+**Response Display Area**
+- Formatted AI responses
+- Conversation history
+- Copy functionality
+- Follow-up question options
+
+### 3. Context Manager
+
+**Text Context Preparation**
+```python
+@dataclass
+class QuestionContext:
+    selected_text: str
+    segment_info: Dict[str, Any]  # timestamp, translations, etc.
+    conversation_id: str
+    ui_language: str
+    previous_questions: List[Dict[str, str]]
+```
+
+**Conversation Management**
+- Maintains context across multiple questions
+- Manages conversation threads per text segment
+- Handles context window limitations
+- Provides conversation persistence
+
+## Data Models
+
+### Question Session
+```python
+@dataclass
+class QuestionSession:
+    session_id: str
+    selected_text: str
+    segment_id: str
+    start_timestamp: int
+    ui_language: str
+    conversation: List[QAPair]
+    created_at: datetime
+```
+
+### Q&A Pair
+```python
+@dataclass
+class QAPair:
+    question: str
+    answer: str
+    timestamp: datetime
+    question_type: str  # 'template' or 'custom'
+    response_time_ms: int
+```
+
+### Text Selection
+```python
+@dataclass
+class TextSelection:
+    text: str
+    segment_id: str
+    start_ms: int
+    end_ms: int
+    translations: Dict[str, str]
+    selection_timestamp: int
+```
+
+## Error Handling
+
+### AI Service Error Handling
+
+1. **Service Unavailability**
+   - Graceful degradation when Gemini AI is unavailable
+   - Clear error messages to users
+   - Retry mechanisms for transient failures
+
+2. **Response Quality Issues**
+   - Validation of AI responses
+   - Fallback to simpler question processing
+   - User feedback mechanisms for poor responses
+
+3. **Context Management Errors**
+   - Handling of oversized context windows
+   - Conversation history cleanup
+   - Memory management for long sessions
+
+### User Experience Error Handling
+
+```python
+def handle_question_error(self, error_type, context):
+    """Handle various question processing errors"""
+    error_messages = {
+        'ai_unavailable': {
+            'ar': 'خدمة الذكاء الاصطناعي غير متاحة حالياً. يرجى المحاولة لاحقاً.',
+            'en': 'AI service is currently unavailable. Please try again later.'
+        },
+        'invalid_selection': {
+            'ar': 'يرجى تحديد نص صالح قبل طرح السؤال.',
+            'en': 'Please select valid text before asking a question.'
+        },
+        'processing_timeout': {
+            'ar': 'انتهت مهلة معالجة السؤال. يرجى المحاولة مرة أخرى.',
+            'en': 'Question processing timed out. Please try again.'
+        }
+    }
+```
+
+## Testing Strategy
+
+### Unit Testing
+- **Question Processing Tests**: Various question types and text selections
+- **Context Management Tests**: Conversation history and memory management
+- **AI Integration Tests**: Response formatting and error handling
+- **UI Component Tests**: Text selection and modal interactions
+
+### Integration Testing
+- **End-to-End Question Flow**: From text selection to AI response display
+- **Multi-language Testing**: Arabic and English question processing
+- **Conversation Continuity**: Follow-up questions and context maintenance
+- **Performance Testing**: Response times and memory usage
+
+### User Acceptance Testing
+- **Student Workflow Testing**: Real-world usage scenarios
+- **Question Quality Testing**: Relevance and accuracy of AI responses
+- **Interface Usability Testing**: Ease of text selection and question input
+- **Accessibility Testing**: Screen reader compatibility and keyboard navigation
+
+## Implementation Phases
+
+### Phase 1: Core Question Engine
+- Implement `AIQuestionEngine` class
+- Add basic question processing with Gemini AI
+- Create question templates for both languages
+- Integrate with existing translator system
+
+### Phase 2: UI Integration
+- Add text selection functionality to broadcast segments
+- Implement "Ask AI" button and modal interface
+- Create question input and response display components
+- Add visual feedback for text selection
+
+### Phase 3: Conversation Management
+- Implement conversation history tracking
+- Add follow-up question capabilities
+- Create context management for multi-turn conversations
+- Add conversation persistence across sessions
+
+### Phase 4: Advanced Features
+- Add copy/export functionality for Q&A pairs
+- Implement conversation search and filtering
+- Add question analytics and usage tracking
+- Create advanced question templates and suggestions
+
+## Performance Considerations
+
+### Response Time Optimization
+- Asynchronous AI request processing
+- Response caching for common questions
+- Progressive loading for long conversations
+- Optimized context preparation
+
+### Memory Management
+- Efficient conversation history storage
+- Automatic cleanup of old conversations
+- Streaming responses for long AI answers
+- Optimized text selection handling
+
+### Scalability
+- Support for multiple concurrent question sessions
+- Efficient handling of large broadcast segments
+- Configurable conversation history limits
+- Resource usage monitoring and optimization

.kiro/specs/ai-questions/requirements.md

@@ -0,0 +1,91 @@
+# Requirements Document
+
+## Introduction
+
+This feature adds AI-powered question generation functionality to the SyncMaster broadcast system. Students can select any text segment from the broadcast and ask the AI to generate questions, explanations, or provide additional information about specific content. This enhances the learning experience by allowing interactive exploration of lecture content through intelligent questioning.
+
+## Requirements
+
+### Requirement 1
+
+**User Story:** As a student reviewing broadcast content, I want to select any text segment and ask AI questions about it, so that I can better understand specific concepts or get clarification on unclear points.
+
+#### Acceptance Criteria
+
+1. WHEN the user clicks on any broadcast segment THEN the system SHALL highlight the selected text
+2. WHEN text is selected THEN the system SHALL display a "❓ Ask AI" button
+3. WHEN the user clicks "Ask AI" THEN the system SHALL open a question input interface
+4. WHEN the user submits a question THEN the system SHALL send the selected text and question to the AI service
+5. IF no text is selected THEN the "Ask AI" button SHALL be disabled with explanatory tooltip
+
+### Requirement 2
+
+**User Story:** As a student, I want to ask different types of questions about the selected content, so that I can get explanations, examples, or deeper insights about the material.
+
+#### Acceptance Criteria
+
+1. WHEN the question interface opens THEN the system SHALL provide quick question templates
+2. WHEN templates are provided THEN they SHALL include: "Explain this", "Give examples", "What does this mean?", "How is this used?"
+3. WHEN the user selects a template THEN the system SHALL auto-fill the question input
+4. WHEN the user types a custom question THEN the system SHALL accept free-form text input
+5. WHEN processing the question THEN the system SHALL include the selected text as context for the AI
+
+### Requirement 3
+
+**User Story:** As a student, I want to receive AI-generated answers in my preferred language, so that I can understand the explanations clearly.
+
+#### Acceptance Criteria
+
+1. WHEN generating AI responses THEN the system SHALL use the current UI language setting
+2. WHEN the UI is in Arabic THEN AI responses SHALL be in Arabic
+3. WHEN the UI is in English THEN AI responses SHALL be in English
+4. WHEN the selected text is in a different language THEN the AI SHALL provide context-aware responses
+5. IF language detection fails THEN the system SHALL default to the UI language
+
+### Requirement 4
+
+**User Story:** As a student, I want to see the AI's answer clearly formatted and easy to read, so that I can quickly understand the information provided.
+
+#### Acceptance Criteria
+
+1. WHEN the AI responds THEN the answer SHALL be displayed in a dedicated response area
+2. WHEN displaying the response THEN the system SHALL show the original selected text for reference
+3. WHEN formatting the response THEN the system SHALL use clear typography and spacing
+4. WHEN the response is long THEN the system SHALL provide scrollable content area
+5. WHEN multiple questions are asked THEN the system SHALL maintain a conversation history
+
+### Requirement 5
+
+**User Story:** As a student, I want to ask follow-up questions about the same content, so that I can have a natural conversation with the AI about the topic.
+
+#### Acceptance Criteria
+
+1. WHEN an AI response is displayed THEN the system SHALL provide an option to ask follow-up questions
+2. WHEN asking follow-up questions THEN the system SHALL maintain context from previous questions
+3. WHEN the conversation continues THEN the system SHALL display the full conversation thread
+4. WHEN starting a new question on different content THEN the system SHALL start a fresh conversation
+5. IF the conversation becomes too long THEN the system SHALL provide option to clear history
+
+### Requirement 6
+
+**User Story:** As a student, I want to copy or save the AI's answers, so that I can include them in my notes or study materials.
+
+#### Acceptance Criteria
+
+1. WHEN an AI response is displayed THEN the system SHALL provide a "Copy" button
+2. WHEN the user clicks "Copy" THEN the response text SHALL be copied to clipboard
+3. WHEN copying THEN the system SHALL include both the original question and AI answer
+4. WHEN multiple Q&A pairs exist THEN the user SHALL be able to copy individual answers or the entire conversation
+5. WHEN copying THEN the system SHALL format the text appropriately for pasting into documents
+
+### Requirement 7
+
+**User Story:** As a student, I want the AI question feature to work seamlessly with the existing broadcast interface, so that my workflow is not disrupted.
+
+#### Acceptance Criteria
+
+1. WHEN the question interface is open THEN the broadcast content SHALL remain visible
+2. WHEN asking questions THEN the broadcast playback SHALL not be interrupted
+3. WHEN switching between segments THEN any open question interface SHALL adapt to the new selection
+4. WHEN the broadcast is updated with new segments THEN the question feature SHALL work with new content
+5. IF the AI service is unavailable THEN the system SHALL display appropriate error messages and fallback options

.kiro/specs/ai-questions/tasks.md

@@ -0,0 +1,209 @@
+# Implementation Plan
+
+- [x] 1. Set up AI question engine infrastructure
+
+
+  - Create ai_questions.py module with AIQuestionEngine class
+  - Implement basic question processing using existing Gemini AI integration
+  - Add question templates for Arabic and English languages
+  - Create data models for question sessions and Q&A pairs
+  - _Requirements: 1.1, 2.1, 3.1_
+
+
+
+- [ ] 2. Implement text selection functionality
+- [ ] 2.1 Add clickable text selection to broadcast segments
+  - Modify broadcast segment display to make text selectable
+  - Implement visual highlighting for selected text
+  - Add session state management for selected text
+  - Create text selection validation and error handling
+
+  - Write unit tests for text selection functionality
+  - _Requirements: 1.1, 1.5_
+
+- [ ] 2.2 Create "Ask AI" button with conditional display
+  - Add "Ask AI" button that appears when text is selected
+  - Implement button state management (enabled/disabled)
+  - Add tooltips and help text for button functionality
+  - Create button styling consistent with existing UI
+
+  - Test button behavior with different text selections
+  - _Requirements: 1.2, 1.5_
+
+- [ ] 3. Build question input interface
+- [ ] 3.1 Create question input modal with templates
+  - Implement modal dialog for question input
+  - Add pre-defined question templates with quick selection
+
+  - Create free-form text input for custom questions
+  - Display selected text context in the modal
+  - Add submit and cancel functionality
+  - _Requirements: 2.1, 2.2, 2.3, 2.4_
+
+- [ ] 3.2 Implement question processing and AI integration
+  - Connect question input to AIQuestionEngine
+  - Add context preparation including selected text and metadata
+
+  - Implement AI request processing with error handling
+  - Add loading indicators during AI processing
+  - Create timeout handling for long AI responses
+  - _Requirements: 1.4, 2.5, 7.5_
+
+- [ ] 4. Create AI response display system
+- [x] 4.1 Build response display area with formatting
+
+  - Create dedicated area for displaying AI responses
+  - Implement proper text formatting and typography
+  - Add scrollable content area for long responses
+  - Display original selected text for reference
+  - Create responsive design for different screen sizes
+  - _Requirements: 4.1, 4.2, 4.3, 4.4_
+
+- [x] 4.2 Add conversation history management
+
+  - Implement conversation thread display
+  - Add conversation history storage in session state
+  - Create conversation navigation and scrolling
+  - Add conversation clearing functionality
+  - Test conversation persistence across UI interactions
+  - _Requirements: 5.1, 5.2, 5.3, 5.4, 5.5_
+
+
+- [ ] 5. Implement multilingual support
+- [ ] 5.1 Add language-aware AI response generation
+  - Configure AI responses based on UI language setting
+  - Implement language detection for selected text
+  - Add context-aware response generation
+  - Create fallback mechanisms for language detection failures
+  - Test multilingual question processing
+  - _Requirements: 3.1, 3.2, 3.3, 3.4, 3.5_
+
+
+- [ ] 5.2 Create multilingual question templates
+  - Implement Arabic question templates
+  - Add English question templates
+  - Create template selection based on UI language
+  - Add template customization and expansion
+  - Test template functionality in both languages
+  - _Requirements: 2.1, 2.2, 2.3_
+
+- [ ] 6. Add copy and export functionality
+- [ ] 6.1 Implement response copying features
+  - Add "Copy" button for individual AI responses
+  - Implement clipboard integration for copying text
+  - Create formatted copying including questions and answers
+  - Add copy confirmation feedback to users
+  - Test copying functionality across different browsers
+
+
+  - _Requirements: 6.1, 6.2, 6.3_
+
+- [ ] 6.2 Create conversation export capabilities
+  - Add functionality to copy entire conversations
+  - Implement formatted export for study materials
+  - Create export options for individual Q&A pairs
+  - Add export formatting for different use cases
+  - Test export functionality with various conversation lengths
+  - _Requirements: 6.4, 6.5_
+
+- [ ] 7. Integrate with existing broadcast system
+- [ ] 7.1 Ensure seamless broadcast integration
+  - Integrate question interface with existing broadcast UI
+  - Maintain broadcast visibility during question sessions
+  - Ensure broadcast playback is not interrupted by questions
+  - Add smooth transitions between broadcast and question modes
+  - Test integration with all existing broadcast features
+  - _Requirements: 7.1, 7.2_
+
+- [ ] 7.2 Handle dynamic broadcast updates
+  - Adapt question interface to new broadcast segments
+  - Update text selection when broadcast content changes
+  - Maintain question sessions across broadcast updates
+  - Handle segment deletion and modification gracefully
+  - Test with real-time broadcast updates
+  - _Requirements: 7.3, 7.4_
+
+- [ ] 8. Implement error handling and fallbacks
+- [ ] 8.1 Add comprehensive error handling
+  - Implement AI service unavailability handling
+  - Add user-friendly error messages in both languages
+  - Create retry mechanisms for failed AI requests
+  - Add fallback options when AI service fails
+  - Test error scenarios and recovery mechanisms
+  - _Requirements: 7.5_
+
+- [ ] 8.2 Create robust conversation management
+  - Add conversation cleanup for memory management
+  - Implement conversation size limits and warnings
+  - Create automatic conversation archiving
+  - Add conversation recovery after errors
+  - Test conversation stability under various conditions
+  - _Requirements: 5.5_
+
+- [ ] 9. Add advanced question features
+- [ ] 9.1 Implement follow-up question capabilities
+  - Add "Ask follow-up" functionality to responses
+  - Maintain conversation context across multiple questions
+  - Create intelligent context summarization for long conversations
+  - Add conversation branching for different topics
+  - Test follow-up question accuracy and relevance
+  - _Requirements: 5.1, 5.2, 5.3_
+
+- [ ] 9.2 Create question suggestion system
+  - Implement AI-powered question suggestions based on selected text
+  - Add smart question recommendations
+  - Create question difficulty levels (basic, intermediate, advanced)
+  - Add question categorization (explanation, examples, application)
+  - Test suggestion quality and relevance
+  - _Requirements: 2.1, 2.2_
+
+- [ ] 10. Optimize performance and user experience
+- [ ] 10.1 Implement performance optimizations
+  - Add asynchronous processing for AI requests
+  - Implement response caching for common questions
+  - Create progressive loading for long conversations
+  - Add memory optimization for conversation history
+  - Test performance with large broadcast segments
+  - _Requirements: 4.4, 5.5_
+
+- [ ] 10.2 Enhance user experience features
+  - Add keyboard shortcuts for common actions
+  - Implement drag-and-drop text selection
+  - Create question history search functionality
+  - Add question bookmarking and favorites
+  - Test accessibility features and screen reader compatibility
+  - _Requirements: 7.1, 7.2_
+
+- [ ] 11. Create comprehensive testing suite
+- [ ] 11.1 Write unit tests for question engine
+  - Create tests for AIQuestionEngine class methods
+  - Add tests for question processing and formatting
+  - Write tests for conversation management
+  - Create tests for error handling scenarios
+  - Implement test data fixtures for various question types
+  - _Requirements: All requirements validation_
+
+- [ ] 11.2 Implement integration tests
+  - Create end-to-end tests for complete question flow
+  - Add tests for multilingual question processing
+  - Write tests for UI component interactions
+  - Create tests for broadcast system integration
+  - Implement performance tests for AI response times
+  - _Requirements: All requirements validation_
+
+- [ ] 12. Final integration and polish
+- [ ] 12.1 Complete system integration
+  - Ensure seamless integration with all existing features
+  - Test compatibility with export functionality
+  - Verify proper session state management
+  - Add configuration options for question features
+  - Create deployment-ready code with proper error handling
+  - _Requirements: All requirements_
+
+- [ ] 12.2 Create user documentation and help
+  - Write user guide for AI question features
+  - Create in-app help and tooltips
+  - Add troubleshooting documentation
+  - Create video tutorials for complex workflows
+  - Document keyboard shortcuts and advanced features
+  - _Requirements: 7.5_

.kiro/specs/broadcast-export/design.md

@@ -0,0 +1,274 @@
+# Design Document
+
+## Overview
+
+The broadcast export feature extends SyncMaster Enhanced with the ability to export lecture content from a specific timestamp. The system will integrate seamlessly with the existing broadcast functionality, providing students with formatted documents containing original text, translations, and AI-generated summaries. The design prioritizes simplicity, reliability, and multilingual support.
+
+## Architecture
+
+### High-Level Architecture
+
+```
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   Streamlit UI  │    │  Export Engine  │    │  File Generators│
+│                 │    │                 │    │                 │
+│ - Export Button │───▶│ - Data Filter   │───▶│ - Word Exporter │
+│ - Preview Modal │    │ - Content Prep  │    │ - GDocs Exporter│
+│ - Download Link │◀───│ - Format Router │◀───│ - Summary Gen   │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+         │                       │                       │
+         │                       │                       │
+         ▼                       ▼                       ▼
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│ Session State   │    │ Broadcast Data  │    │ External APIs   │
+│                 │    │                 │    │                 │
+│ - Export Time   │    │ - Segments      │    │ - Google Docs   │
+│ - UI Language   │    │ - Translations  │    │ - Gemini AI     │
+│ - Export Config │    │ - Timestamps    │    │ - File System   │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+```
+
+### Component Integration
+
+The export feature integrates with existing SyncMaster components:
+- **Broadcast System**: Uses `st.session_state.broadcast_segments` for data
+- **Translation System**: Leverages existing `translator.py` for summaries
+- **UI System**: Extends current Streamlit interface with export controls
+
+## Components and Interfaces
+
+### 1. Export Engine (`exporter.py`)
+
+**Primary Class: `BroadcastExporter`**
+
+```python
+class BroadcastExporter:
+    def __init__(self, translator_instance):
+        self.translator = translator_instance
+        self.supported_formats = ['word', 'google_docs']
+    
+    def filter_segments_from_timestamp(self, segments, export_timestamp):
+        """Filter broadcast segments from export timestamp"""
+        
+    def prepare_export_content(self, segments, include_summary=True):
+        """Prepare structured content for export"""
+        
+    def export_to_word(self, content, filename):
+        """Generate Word document"""
+        
+    def export_to_google_docs(self, content, title):
+        """Create Google Docs document"""
+        
+    def generate_export_summary(self, segments, target_language='ar'):
+        """Generate summary for export content"""
+```
+
+### 2. UI Components (Extended `app.py`)
+
+**Export Button Integration**
+- Location: Within the broadcast expander section
+- Trigger: Records current timestamp and opens export modal
+- State Management: Uses session state for export configuration
+
+**Export Modal**
+- Preview content display
+- Format selection (Word/Google Docs)
+- Export confirmation/cancellation
+- Progress indication during export
+
+### 3. Document Generators
+
+**Word Document Structure:**
+```
+Title: محاضرة - [Date/Time]
+Export Time: [Timestamp]
+═══════════════════════════════════
+
+📻 البرودكاست المُصدر
+═══════════════════════════════════
+
+[Segment 1: Time Range]
+Original: [Text]
+Translation: [Text]
+
+[Segment 2: Time Range]
+Original: [Text]
+Translation: [Text]
+
+📝 الملخص
+═══════════════════════════════════
+[AI-Generated Summary]
+```
+
+**Google Docs Integration:**
+- Uses Google Docs API v1
+- Creates shareable documents
+- Applies consistent formatting
+- Handles authentication via service account
+
+## Data Models
+
+### Export Configuration
+```python
+@dataclass
+class ExportConfig:
+    export_timestamp: int  # Unix timestamp in milliseconds
+    format_type: str      # 'word' or 'google_docs'
+    include_summary: bool # Whether to include AI summary
+    ui_language: str      # 'ar' or 'en' for interface
+    target_language: str  # Translation language for summary
+```
+
+### Export Content
+```python
+@dataclass
+class ExportContent:
+    title: str
+    export_time: str
+    segments: List[BroadcastSegment]
+    summary: Optional[str]
+    metadata: Dict[str, Any]
+```
+
+### Broadcast Segment (Extended)
+```python
+@dataclass
+class BroadcastSegment:
+    id: str
+    start_ms: int
+    end_ms: int
+    text: str
+    translations: Dict[str, str]  # language_code -> translated_text
+    timestamp_formatted: str     # Human-readable time range
+```
+
+## Error Handling
+
+### Export Process Error Handling
+
+1. **Timestamp Validation**
+   - Verify export timestamp is valid
+   - Handle edge cases (no segments after timestamp)
+   - Provide user feedback for empty exports
+
+2. **Document Generation Errors**
+   - Word document creation failures
+   - Google Docs API errors
+   - File system permission issues
+   - Network connectivity problems
+
+3. **Summary Generation Errors**
+   - AI service unavailability
+   - Empty content handling
+   - Fallback to export without summary
+
+4. **User Experience Error Handling**
+   - Clear error messages in user's language
+   - Graceful degradation (Word fallback for Google Docs)
+   - Retry mechanisms for transient failures
+
+### Error Recovery Strategies
+
+```python
+def export_with_fallback(self, content, format_type):
+    """Export with automatic fallback handling"""
+    try:
+        if format_type == 'google_docs':
+            return self.export_to_google_docs(content)
+    except GoogleDocsError:
+        # Fallback to Word export
+        return self.export_to_word(content)
+    except Exception as e:
+        # Log error and provide user feedback
+        return self.handle_export_error(e)
+```
+
+## Testing Strategy
+
+### Unit Testing
+- **Export Engine Tests**: Data filtering, content preparation, format generation
+- **Document Generator Tests**: Word document structure, Google Docs API integration
+- **Error Handling Tests**: Various failure scenarios and recovery mechanisms
+
+### Integration Testing
+- **End-to-End Export Flow**: From button click to document download
+- **Multi-language Testing**: Arabic and English interface testing
+- **Cross-format Testing**: Consistency between Word and Google Docs exports
+
+### User Acceptance Testing
+- **Student Workflow Testing**: Real lecture scenario testing
+- **Performance Testing**: Export speed with large broadcast segments
+- **Accessibility Testing**: Screen reader compatibility, keyboard navigation
+
+### Test Data Scenarios
+```python
+# Test scenarios for broadcast segments
+test_scenarios = [
+    "empty_broadcast",           # No segments to export
+    "single_segment",           # One segment after timestamp
+    "multiple_segments",        # Multiple segments with translations
+    "mixed_languages",          # Segments in different languages
+    "large_content",           # Performance testing with many segments
+    "special_characters",      # Unicode and RTL text handling
+]
+```
+
+## Implementation Phases
+
+### Phase 1: Core Export Engine
+- Implement `BroadcastExporter` class
+- Add timestamp filtering functionality
+- Create basic Word document generation
+- Integrate with existing broadcast data
+
+### Phase 2: UI Integration
+- Add export button to broadcast section
+- Implement export modal with preview
+- Add progress indicators and user feedback
+- Handle multilingual UI elements
+
+### Phase 3: Advanced Features
+- Google Docs integration
+- Enhanced document formatting
+- Summary generation for export content
+- Error handling and fallback mechanisms
+
+### Phase 4: Testing and Optimization
+- Comprehensive testing suite
+- Performance optimization
+- User experience refinements
+- Documentation and help content
+
+## Security Considerations
+
+### Data Privacy
+- Export content remains on user's device or chosen cloud service
+- No intermediate storage of sensitive lecture content
+- Google Docs integration uses user's own Google account
+
+### API Security
+- Google Docs API authentication via OAuth 2.0
+- Secure handling of API credentials
+- Rate limiting and quota management
+
+### File Security
+- Generated Word documents include no executable content
+- Sanitization of user input in document titles
+- Secure temporary file handling during generation
+
+## Performance Considerations
+
+### Export Speed Optimization
+- Lazy loading of large broadcast segments
+- Asynchronous document generation
+- Progress feedback for long-running exports
+
+### Memory Management
+- Streaming document generation for large content
+- Cleanup of temporary files and resources
+- Efficient handling of multilingual text encoding
+
+### Scalability
+- Support for exports with hundreds of broadcast segments
+- Optimized data structures for large lecture sessions
+- Configurable export limits to prevent system overload

.kiro/specs/broadcast-export/requirements.md

@@ -0,0 +1,87 @@
+# Requirements Document
+
+## Introduction
+
+This feature adds export functionality to the SyncMaster Enhanced application, specifically for the broadcast section. The feature allows students to export their lecture content (original text, translations, and summaries) from a specific point in time when they press the export button, rather than exporting the entire broadcast history. This enables students to capture and save important lecture segments for later review in Word or Google Docs format.
+
+## Requirements
+
+### Requirement 1
+
+**User Story:** As a student using SyncMaster during a lecture, I want to export the broadcast content from a specific moment, so that I can save important lecture segments for later review.
+
+#### Acceptance Criteria
+
+1. WHEN the user clicks the export button THEN the system SHALL record the current timestamp as the export starting point
+2. WHEN exporting THEN the system SHALL include only broadcast segments that occurred after the export timestamp
+3. WHEN exporting THEN the system SHALL include both original text and translations for each segment
+4. IF no segments exist after the export timestamp THEN the system SHALL display a message indicating no content to export
+
+### Requirement 2
+
+**User Story:** As a student, I want to export my lecture content to Word format, so that I can easily review and edit the content offline.
+
+#### Acceptance Criteria
+
+1. WHEN the user selects Word export THEN the system SHALL generate a .docx file
+2. WHEN generating the Word document THEN the system SHALL include a header with lecture title and export timestamp
+3. WHEN generating the Word document THEN the system SHALL format the content with clear sections for broadcast segments and summary
+4. WHEN the Word document is generated THEN the system SHALL provide a download link to the user
+5. IF the Word generation fails THEN the system SHALL display an error message and suggest alternative export options
+
+### Requirement 3
+
+**User Story:** As a student, I want to export my lecture content to Google Docs, so that I can access and share it from anywhere.
+
+#### Acceptance Criteria
+
+1. WHEN the user selects Google Docs export THEN the system SHALL create a new Google Docs document
+2. WHEN creating the Google Docs document THEN the system SHALL use the same formatting structure as Word export
+3. WHEN the Google Docs document is created THEN the system SHALL provide a shareable link to the user
+4. IF Google Docs integration is not available THEN the system SHALL fall back to Word export
+5. WHEN Google Docs export fails THEN the system SHALL display an error message with troubleshooting steps
+
+### Requirement 4
+
+**User Story:** As a student, I want the exported content to include the Arabic summary, so that I can have a comprehensive review document.
+
+#### Acceptance Criteria
+
+1. WHEN exporting THEN the system SHALL include the current Arabic summary if available
+2. WHEN no Arabic summary exists THEN the system SHALL generate a new summary based on the exported segments
+3. WHEN generating a new summary THEN the system SHALL use the same AI translation service as the main application
+4. IF summary generation fails THEN the system SHALL export without the summary section and notify the user
+
+### Requirement 5
+
+**User Story:** As a student, I want to preview the export content before downloading, so that I can verify it contains the information I need.
+
+#### Acceptance Criteria
+
+1. WHEN the user clicks export THEN the system SHALL display a preview modal showing the content to be exported
+2. WHEN showing the preview THEN the system SHALL display the number of segments and estimated document length
+3. WHEN in preview mode THEN the user SHALL be able to confirm or cancel the export
+4. WHEN the user confirms export THEN the system SHALL proceed with the selected format
+5. WHEN the user cancels export THEN the system SHALL close the preview without creating any files
+
+### Requirement 6
+
+**User Story:** As a student, I want the export feature to work in both Arabic and English interfaces, so that I can use it regardless of my language preference.
+
+#### Acceptance Criteria
+
+1. WHEN the interface language is Arabic THEN all export UI elements SHALL be displayed in Arabic
+2. WHEN the interface language is English THEN all export UI elements SHALL be displayed in English
+3. WHEN exporting THEN the document structure SHALL adapt to the interface language while preserving content languages
+4. WHEN displaying error messages THEN they SHALL be shown in the current interface language
+
+### Requirement 7
+
+**User Story:** As a student, I want the export button to be easily accessible in the broadcast section, so that I can quickly export content during live lectures.
+
+#### Acceptance Criteria
+
+1. WHEN viewing the broadcast section THEN the export button SHALL be prominently displayed
+2. WHEN the broadcast section is collapsed THEN the export button SHALL remain visible
+3. WHEN clicking the export button THEN the system SHALL respond within 2 seconds
+4. WHEN no broadcast segments exist THEN the export button SHALL be disabled with an explanatory tooltip

.kiro/specs/broadcast-export/tasks.md

@@ -0,0 +1,194 @@
+# Implementation Plan
+
+- [x] 1. Set up export infrastructure and dependencies
+
+
+  - Install required Python packages for document generation (python-docx, google-api-python-client)
+  - Update requirements.txt with new dependencies
+  - Create basic project structure for export functionality
+  - _Requirements: 1.1, 2.1, 3.1_
+
+- [ ] 2. Implement core export engine
+- [x] 2.1 Create BroadcastExporter class with timestamp filtering
+
+
+
+  - Write BroadcastExporter class in new exporter.py file
+  - Implement filter_segments_from_timestamp method to filter segments by export time
+  - Add prepare_export_content method to structure data for export
+  - Create unit tests for timestamp filtering logic
+  - _Requirements: 1.1, 1.2, 1.3_
+
+- [ ] 2.2 Implement Word document generation functionality
+  - Add export_to_word method using python-docx library
+  - Create document template with proper Arabic/English formatting
+  - Implement structured content layout (header, segments, summary sections)
+  - Add proper RTL text support for Arabic content
+  - Write unit tests for Word document generation
+  - _Requirements: 2.1, 2.2, 2.3, 6.3_
+
+- [ ] 2.3 Add export content preparation and formatting
+  - Implement content structuring for both original text and translations
+  - Add timestamp formatting for human-readable time ranges
+  - Create multilingual document headers and section titles
+  - Handle special characters and Unicode text properly
+  - Write tests for content preparation logic
+  - _Requirements: 1.3, 2.3, 6.1, 6.2_
+
+
+- [ ] 3. Integrate export functionality with existing UI
+- [ ] 3.1 Add export button to broadcast section
+
+
+  - Modify app.py to add export button in broadcast expander
+  - Implement export timestamp recording when button is clicked
+  - Add button state management (enabled/disabled based on content)
+  - Create multilingual button text and tooltips
+  - _Requirements: 7.1, 7.2, 7.4, 6.1, 6.2_
+
+- [ ] 3.2 Create export preview modal interface
+  - Implement export preview modal using Streamlit components
+  - Add content preview showing segments count and estimated length
+  - Create format selection interface (Word/Google Docs options)
+  - Add confirm/cancel buttons with proper event handling
+  - Write UI tests for modal functionality
+  - _Requirements: 5.1, 5.2, 5.3, 5.4, 5.5_
+
+- [ ] 3.3 Implement export progress and feedback system
+  - Add progress indicators during export generation
+  - Create success/error message display system
+  - Implement download link generation for completed exports
+  - Add multilingual error messages and user feedback
+  - Handle export cancellation and cleanup
+  - _Requirements: 7.3, 6.4, 2.4_
+
+- [ ] 4. Add summary generation for export content
+- [ ] 4.1 Integrate AI summary generation for export segments
+  - Extend exporter.py with generate_export_summary method
+  - Use existing translator.py functionality for summary generation
+  - Implement summary generation based on filtered segments only
+  - Add fallback handling when summary generation fails
+  - Create tests for summary integration
+  - _Requirements: 4.1, 4.2, 4.3, 4.4_
+
+- [ ] 4.2 Handle summary inclusion in export documents
+  - Modify Word document generation to include summary section
+  - Add conditional summary inclusion based on user preferences
+  - Implement proper formatting for Arabic summary text
+  - Handle cases where summary is unavailable or generation fails
+  - Test summary formatting in exported documents
+  - _Requirements: 4.1, 4.4, 6.3_
+
+- [ ] 5. Implement Google Docs integration
+- [x] 5.1 Set up Google Docs API integration
+
+
+
+  - Create Google Docs API service setup and authentication
+  - Implement OAuth 2.0 flow for user authorization
+  - Add Google API credentials management
+  - Create basic Google Docs document creation functionality
+  - Write integration tests for Google API connectivity
+  - _Requirements: 3.1, 3.2_
+
+- [ ] 5.2 Implement Google Docs export functionality
+  - Add export_to_google_docs method to BroadcastExporter
+  - Implement document formatting using Google Docs API
+  - Add proper RTL text support for Arabic content in Google Docs
+  - Create shareable link generation for exported documents
+  - Handle Google Docs API errors and rate limiting
+  - _Requirements: 3.1, 3.2, 3.3, 6.3_
+
+- [ ] 5.3 Add Google Docs fallback and error handling
+  - Implement automatic fallback to Word export when Google Docs fails
+  - Add user-friendly error messages for Google Docs issues
+  - Create retry mechanisms for transient API failures
+  - Handle authentication errors and re-authorization flow
+  - Test fallback scenarios and error recovery
+  - _Requirements: 3.4, 3.5_
+
+- [ ] 6. Implement comprehensive error handling
+- [ ] 6.1 Add export validation and error prevention
+  - Implement pre-export validation (timestamp, content availability)
+  - Add user input sanitization for document titles and content
+  - Create validation for export configuration parameters
+  - Handle edge cases (empty segments, invalid timestamps)
+  - Write comprehensive validation tests
+  - _Requirements: 1.4, 7.4_
+
+- [ ] 6.2 Create robust error recovery system
+  - Implement try-catch blocks for all export operations
+  - Add logging for debugging export failures
+  - Create user-friendly error messages in multiple languages
+  - Implement cleanup procedures for failed exports
+  - Add error reporting and diagnostics functionality
+  - _Requirements: 2.5, 3.5, 6.4_
+
+- [ ] 7. Add multilingual support and localization
+- [ ] 7.1 Implement Arabic interface support for export features
+  - Add Arabic translations for all export UI elements
+  - Create RTL-compatible export modal layout
+  - Implement Arabic document templates and formatting
+  - Add Arabic error messages and user feedback
+  - Test Arabic interface functionality thoroughly
+  - _Requirements: 6.1, 6.4_
+
+- [ ] 7.2 Ensure consistent multilingual document generation
+  - Implement language-aware document formatting
+  - Add proper font selection for Arabic and English text
+  - Create consistent styling across different languages
+  - Handle mixed-language content in exports
+  - Test document generation with various language combinations
+  - _Requirements: 6.3_
+
+Auto-process snapshots (keeps recording)
+- [ ] 8. Create comprehensive testing suite
+- [ ] 8.1 Write unit tests for export functionality
+  - Create tests for BroadcastExporter class methods
+  - Add tests for timestamp filtering and content preparation
+  - Write tests for Word document generation
+  - Create tests for error handling and edge cases
+  - Implement test data fixtures for various scenarios
+  - _Requirements: All requirements validation_
+
+- [ ] 8.2 Implement integration tests for complete export flow
+  - Create end-to-end tests from button click to document download
+  - Add tests for multilingual export scenarios
+  - Write tests for Google Docs integration (with mocking)
+  - Create performance tests for large broadcast segments
+  - Implement user workflow simulation tests
+  - _Requirements: All requirements validation_
+
+- [ ] 9. Optimize performance and user experience
+- [ ] 9.1 Implement export performance optimizations
+  - Add asynchronous processing for large exports
+  - Implement memory-efficient document generation
+  - Create progress tracking for long-running exports
+  - Add export size limits and warnings
+  - Optimize data structures for large segment collections
+  - _Requirements: 7.3_
+
+- [ ] 9.2 Enhance user experience and accessibility
+  - Add keyboard navigation support for export interface
+  - Implement screen reader compatibility
+  - Create helpful tooltips and user guidance
+  - Add export history and recent exports tracking
+  - Implement user preferences for export settings
+  - _Requirements: 5.1, 7.1, 7.2_
+
+- [ ] 10. Final integration and documentation
+- [ ] 10.1 Complete integration with main application
+  - Ensure seamless integration with existing broadcast functionality
+  - Test compatibility with all existing features
+  - Verify proper session state management
+  - Add configuration options for export features
+  - Create deployment-ready code with proper error handling
+  - _Requirements: All requirements_
+
+- [ ] 10.2 Create user documentation and help content
+  - Write user guide for export functionality
+  - Create troubleshooting documentation
+  - Add inline help text and tooltips
+  - Create video tutorials or screenshots for complex workflows
+  - Document API integration requirements for Google Docs
+  - _Requirements: 3.5, 6.4_

.kiro/specs/model-management/design.md

@@ -0,0 +1,225 @@
+# Model Management System Design
+
+## Overview
+
+The Model Management System provides a centralized, robust approach to managing AI model configurations across multiple providers (Gemini, OpenRouter, Groq). It includes automatic validation, fallback mechanisms, health monitoring, and user-friendly status reporting.
+
+## Architecture
+
+### Core Components
+
+1. **ModelManager**: Central coordinator for all model operations
+2. **ModelValidator**: Validates model configurations against provider APIs
+3. **ModelHealthMonitor**: Monitors model availability and performance
+4. **FallbackChain**: Manages automatic fallback to alternative models
+5. **ModelConfigStore**: Centralized configuration management
+6. **StatusReporter**: Provides real-time status information to users
+
+### Component Interactions
+
+```
+User Request → ModelManager → ModelValidator → Provider API
+                    ↓
+            FallbackChain → Alternative Models
+                    ↓
+            StatusReporter → User Feedback
+```
+
+## Components and Interfaces
+
+### ModelManager
+
+**Purpose**: Central coordinator for all AI model operations
+
+**Key Methods**:
+- `get_available_model(provider, task_type)`: Returns best available model for a task
+- `execute_with_fallback(prompt, preferences)`: Executes request with automatic fallback
+- `get_system_status()`: Returns current status of all models
+- `refresh_configurations()`: Reloads and validates all configurations
+
+**Interfaces**:
+- Input: User requests, configuration updates
+- Output: Model responses, status information, error messages
+
+### ModelValidator
+
+**Purpose**: Validates model configurations against provider APIs
+
+**Key Methods**:
+- `validate_model(provider, model_id)`: Tests if a model is valid and accessible
+- `validate_all_models()`: Validates all configured models
+- `suggest_alternatives(invalid_model)`: Suggests working alternatives for invalid models
+- `update_model_status(model, status)`: Updates model availability status
+
+**Validation Process**:
+1. Send minimal test request to provider API
+2. Check response for success/error patterns
+3. Update model status based on results
+4. Log validation results with timestamps
+
+### ModelHealthMonitor
+
+**Purpose**: Continuously monitors model health and availability
+
+**Key Methods**:
+- `start_monitoring()`: Begins periodic health checks
+- `check_model_health(model)`: Performs health check on specific model
+- `handle_model_failure(model, error)`: Responds to model failures
+- `get_health_report()`: Returns comprehensive health status
+
+**Monitoring Strategy**:
+- Periodic health checks every 5 minutes
+- Immediate checks after failures
+- Exponential backoff for failed models
+- Automatic recovery detection
+
+### FallbackChain
+
+**Purpose**: Manages automatic fallback to alternative models
+
+**Fallback Priority**:
+1. **Primary Models**: User-configured preferred models
+2. **Secondary Models**: Validated working alternatives
+3. **Emergency Models**: Always-available simple response system
+
+**Fallback Logic**:
+```
+Primary Model → Secondary Models → Emergency Response
+     ↓               ↓                    ↓
+  Full AI        Reduced AI         Rule-based
+  Response       Response           Response
+```
+
+### ModelConfigStore
+
+**Purpose**: Centralized configuration management
+
+**Configuration Structure**:
+```json
+{
+  "providers": {
+    "openrouter": {
+      "api_key": "...",
+      "models": {
+        "primary": "meta-llama/llama-3.2-3b-instruct:free",
+        "fallbacks": [
+          "meta-llama/llama-3.1-8b-instruct:free",
+          "google/gemma-2-9b-it:free"
+        ]
+      }
+    },
+    "groq": {
+      "api_key": "...",
+      "models": {
+        "primary": "llama-3.3-70b-versatile",
+        "fallbacks": ["mixtral-8x7b-32768"]
+      }
+    }
+  }
+}
+```
+
+## Data Models
+
+### ModelStatus
+```python
+@dataclass
+class ModelStatus:
+    provider: str
+    model_id: str
+    status: str  # 'available', 'unavailable', 'quota_exceeded', 'error'
+    last_checked: datetime
+    error_message: Optional[str]
+    response_time_ms: Optional[int]
+    success_rate: float
+```
+
+### ProviderConfig
+```python
+@dataclass
+class ProviderConfig:
+    name: str
+    api_key: str
+    base_url: str
+    primary_models: List[str]
+    fallback_models: List[str]
+    timeout_seconds: int = 30
+    retry_attempts: int = 3
+```
+
+### ValidationResult
+```python
+@dataclass
+class ValidationResult:
+    model_id: str
+    is_valid: bool
+    error_message: Optional[str]
+    suggested_alternatives: List[str]
+    validation_timestamp: datetime
+```
+
+## Error Handling
+
+### Error Categories
+
+1. **Configuration Errors**: Invalid API keys, malformed model IDs
+2. **Network Errors**: Timeout, connection failures
+3. **Provider Errors**: Rate limits, quota exceeded, model unavailable
+4. **Validation Errors**: Model not found, unsupported parameters
+
+### Error Response Strategy
+
+1. **Immediate Fallback**: Switch to next available model
+2. **User Notification**: Inform user of fallback with clear messaging
+3. **Automatic Recovery**: Retry failed models after cooldown period
+4. **Graceful Degradation**: Provide simple responses when all AI fails
+
+### Error Logging
+
+- Structured logging with error categories
+- Performance metrics tracking
+- User-friendly error messages
+- Detailed technical logs for debugging
+
+## Testing Strategy
+
+### Unit Tests
+- Model validation logic
+- Fallback chain behavior
+- Configuration parsing
+- Error handling scenarios
+
+### Integration Tests
+- End-to-end model requests
+- Provider API interactions
+- Fallback mechanisms
+- Configuration updates
+
+### Performance Tests
+- Response time monitoring
+- Concurrent request handling
+- Memory usage optimization
+- Fallback performance impact
+
+### User Acceptance Tests
+- Model status visibility
+- Error message clarity
+- Fallback transparency
+- Configuration management UI
+
+## Implementation Phases
+
+### Phase 1: Core Infrastructure
+- ModelManager implementation
+- Basic validation system
+- Simple fallback mechanism
+
+### Phase 2: Advanced Features
+- Health monitoring
+- Comprehensive error handling
+- Performance optimization
+
+### Phase 3: User Experience
+- Status dashboard
+- Configuration UI
+- Advanced monitoring features

.kiro/specs/model-management/requirements.md

@@ -0,0 +1,62 @@
+# Requirements Document
+
+## Introduction
+
+This feature aims to create a robust model management system that prevents invalid model configurations, provides automatic fallback mechanisms, and ensures reliable AI service availability. The system should handle model validation, automatic updates, and graceful error handling to prevent service disruptions.
+
+## Requirements
+
+### Requirement 1
+
+**User Story:** As a system administrator, I want automatic model validation so that invalid model configurations are detected and corrected before they cause service failures.
+
+#### Acceptance Criteria
+
+1. WHEN the system starts THEN it SHALL validate all configured AI models against their respective service APIs
+2. WHEN an invalid model is detected THEN the system SHALL automatically replace it with a known working fallback model
+3. WHEN model validation fails THEN the system SHALL log the error and continue with fallback models
+4. WHEN a model becomes unavailable THEN the system SHALL automatically switch to the next available model in the priority list
+
+### Requirement 2
+
+**User Story:** As a developer, I want centralized model configuration management so that all AI services use consistent and validated model settings.
+
+#### Acceptance Criteria
+
+1. WHEN the application initializes THEN it SHALL load model configurations from a centralized configuration system
+2. WHEN model configurations are updated THEN all AI services SHALL automatically use the new configurations
+3. WHEN a service requests a model THEN the system SHALL provide the most appropriate available model based on priority and availability
+4. WHEN model configurations are invalid THEN the system SHALL provide clear error messages and suggested fixes
+
+### Requirement 3
+
+**User Story:** As an end user, I want transparent model status information so that I understand which AI services are available and their current status.
+
+#### Acceptance Criteria
+
+1. WHEN I access the application THEN I SHALL see the current status of all AI models (available, unavailable, quota exceeded, etc.)
+2. WHEN a model fails THEN I SHALL receive a clear notification about the fallback being used
+3. WHEN model status changes THEN the UI SHALL update to reflect the current availability
+4. WHEN I encounter an AI error THEN I SHALL receive helpful information about alternative options
+
+### Requirement 4
+
+**User Story:** As a system operator, I want automatic model health monitoring so that model issues are detected and resolved proactively.
+
+#### Acceptance Criteria
+
+1. WHEN the system is running THEN it SHALL periodically check the health of all configured AI models
+2. WHEN a model health check fails THEN the system SHALL attempt to use alternative models
+3. WHEN all models for a service fail THEN the system SHALL provide graceful degradation with simple responses
+4. WHEN model health is restored THEN the system SHALL automatically resume using the preferred models
+
+### Requirement 5
+
+**User Story:** As a developer, I want comprehensive error handling and logging so that model-related issues can be quickly diagnosed and resolved.
+
+#### Acceptance Criteria
+
+1. WHEN a model error occurs THEN the system SHALL log detailed error information including model name, error type, and suggested resolution
+2. WHEN fallback models are used THEN the system SHALL log the fallback chain and reasons for each fallback
+3. WHEN model configurations are automatically corrected THEN the system SHALL log the changes made
+4. WHEN users encounter model errors THEN they SHALL receive user-friendly error messages with actionable guidance

.kiro/specs/model-management/tasks.md

@@ -0,0 +1,103 @@
+# Implementation Plan
+
+- [ ] 1. Create core model management infrastructure
+  - Implement ModelStatus and ProviderConfig data classes
+  - Create ModelConfigStore for centralized configuration management
+  - Set up basic logging and error handling framework
+  - _Requirements: 2.1, 2.2, 5.1_
+
+- [ ] 2. Implement ModelValidator component
+  - Create ModelValidator class with validation methods
+  - Implement validate_model() method for individual model testing
+  - Add validate_all_models() method for batch validation
+  - Create suggest_alternatives() method for fallback recommendations
+  - Write unit tests for validation logic
+  - _Requirements: 1.1, 1.2, 1.3_
+
+- [ ] 3. Build FallbackChain system
+  - Implement FallbackChain class with priority-based model selection
+  - Create fallback logic that tries primary, secondary, and emergency models
+  - Add automatic model switching when failures occur
+  - Implement graceful degradation to simple responses
+  - Write tests for fallback scenarios
+  - _Requirements: 1.4, 4.2, 4.3_
+
+- [ ] 4. Create ModelManager central coordinator
+  - Implement ModelManager class as main interface
+  - Add get_available_model() method for model selection
+  - Create execute_with_fallback() method for request handling
+  - Implement get_system_status() for status reporting
+  - Add refresh_configurations() for dynamic config updates
+  - Write integration tests for ModelManager
+  - _Requirements: 2.3, 3.2, 4.1_
+
+- [ ] 5. Implement ModelHealthMonitor
+  - Create ModelHealthMonitor class for continuous monitoring
+  - Add periodic health check functionality (5-minute intervals)
+  - Implement check_model_health() for individual model testing
+  - Create handle_model_failure() for failure response
+  - Add exponential backoff for failed models
+  - Write tests for health monitoring scenarios
+  - _Requirements: 4.1, 4.2, 4.4_
+
+- [ ] 6. Build StatusReporter for user feedback
+  - Create StatusReporter class for user-facing status information
+  - Implement real-time status updates for UI
+  - Add user-friendly error message generation
+  - Create status dashboard data formatting
+  - Implement notification system for model changes
+  - Write tests for status reporting functionality
+  - _Requirements: 3.1, 3.2, 3.3, 3.4_
+
+- [ ] 7. Integrate with existing AI services
+  - Update AITranslator to use ModelManager
+  - Modify AIQuestionEngine to use new model management
+  - Update all AI service calls to use execute_with_fallback()
+  - Replace hardcoded model configurations with centralized config
+  - Add model status display to existing UI components
+  - _Requirements: 2.2, 2.3, 3.1_
+
+- [ ] 8. Implement comprehensive error handling
+  - Add structured error logging with categories
+  - Create user-friendly error messages for each error type
+  - Implement automatic error recovery mechanisms
+  - Add performance metrics tracking
+  - Create error reporting dashboard
+  - Write tests for all error scenarios
+  - _Requirements: 5.1, 5.2, 5.3, 5.4_
+
+- [ ] 9. Add configuration management features
+  - Create configuration validation on startup
+  - Implement automatic model configuration updates
+  - Add configuration backup and restore functionality
+  - Create configuration migration tools for updates
+  - Add configuration validation UI
+  - Write tests for configuration management
+  - _Requirements: 2.1, 2.4, 1.2_
+
+- [ ] 10. Create monitoring and analytics
+  - Implement performance metrics collection
+  - Add model usage statistics tracking
+  - Create health monitoring dashboard
+  - Add alerting for critical model failures
+  - Implement trend analysis for model performance
+  - Write tests for monitoring functionality
+  - _Requirements: 4.1, 4.4, 5.1_
+
+- [ ] 11. Build user interface components
+  - Create model status display widget
+  - Add model selection interface for users
+  - Implement error notification system
+  - Create configuration management UI
+  - Add health monitoring dashboard
+  - Write UI tests for all components
+  - _Requirements: 3.1, 3.2, 3.3, 3.4_
+
+- [ ] 12. Implement final integration and testing
+  - Integrate all components into main application
+  - Run comprehensive end-to-end tests
+  - Perform load testing with multiple concurrent requests
+  - Test all fallback scenarios under various failure conditions
+  - Validate user experience with real-world usage patterns
+  - Create deployment and maintenance documentation
+  - _Requirements: All requirements validation_

Dockerfile

@@ -0,0 +1,41 @@
+#
+# -- Dockerfile for Streamlit app --
+#
+
+# Base image
+FROM python:3.9-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies (including ffmpeg)
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements file
+COPY requirements.txt ./requirements.txt
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the entire app
+COPY . .
+
+# Create .streamlit directory and set permissions
+RUN mkdir -p /app/.streamlit && \
+    chmod -R 755 /app/.streamlit
+
+# Set environment variable for Streamlit config
+ENV STREAMLIT_CONFIG_DIR=/app/.streamlit
+
+# Expose the port that Streamlit runs on
+EXPOSE 8501
+
+# Add a health check
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+
+# Command to run the app
+ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

FIX_GOOGLE_ACCESS.md

@@ -0,0 +1,27 @@
+# 🔧 حل مشكلة Google Access
+
+## 🎯 المشكلة:
+```
+Error 403: access_denied
+SyncMaster Export has not completed the Google verification process
+```
+
+## ✅ الحل السريع:
+
+### 1️⃣ إضافة نفسك كـ Test User:
+1. اذهب إلى [Google Cloud Console](https://console.cloud.google.com/)
+2. اختر مشروع `syncmaster-export`
+3. اذهب إلى: **APIs & Services** → **OAuth consent screen**
+4. اضغط على **"ADD USERS"** في قسم "Test users"
+5. أضف إيميل Google الخاص بك
+6. اضغط **"SAVE"**
+
+### 2️⃣ أو: نشر التطبيق للعامة (أسرع):
+1. في نفس صفحة **OAuth consent screen**
+2. اضغط **"PUBLISH APP"**
+3. اضغط **"CONFIRM"**
+4. الآن يمكن لأي شخص استخدام التطبيق
+
+## 🔧 حل مشكلة المنفذ:
+
+المشكلة أن Streamlit يستخدم المنفذ 8501، لذلك سنغير المنفذ للمصادقة.

GOOGLE_SETUP.md

@@ -0,0 +1,47 @@
+# إعداد Google Docs للتصدير المباشر
+
+## الخطوات المطلوبة:
+
+### 1. إنشاء مشروع Google Cloud
+1. اذهب إلى [Google Cloud Console](https://console.cloud.google.com/)
+2. أنشئ مشروع جديد أو اختر مشروع موجود
+3. اكتب اسم المشروع (مثل: "SyncMaster Export")
+
+### 2. تفعيل Google Docs API
+1. في القائمة الجانبية، اذهب إلى "APIs & Services" > "Library"
+2. ابحث عن "Google Docs API"
+3. اضغط على "Enable"
+
+### 3. إنشاء بيانات الاعتماد
+1. اذهب إلى "APIs & Services" > "Credentials"
+2. اضغط على "Create Credentials" > "OAuth 2.0 Client ID"
+3. إذا لم تكن قد أعددت شاشة الموافقة، ستحتاج لإعدادها:
+   - اختر "External" للمستخدمين العاديين
+   - املأ المعلومات المطلوبة (اسم التطبيق، إيميل الدعم)
+   - أضف نطاقات Google Docs
+4. اختر "Desktop application" كنوع التطبيق
+5. اكتب اسم العميل (مثل: "SyncMaster Desktop")
+6. اضغط "Create"
+
+### 4. تحميل ملف بيانات الاعتماد
+1. بعد إنشاء بيانات الاعتماد، اضغط على أيقونة التحميل
+2. احفظ الملف باسم `credentials.json`
+3. ضع الملف في نفس مجلد التطبيق
+
+### 5. تشغيل التطبيق
+1. شغل التطبيق: `streamlit run app.py`
+2. اضغط على زر "📤 تصدير إلى Google Docs"
+3. ستفتح نافذة متصفح للمصادقة مع Google
+4. سجل دخول بحساب Google الخاص بك
+5. امنح الصلاحيات المطلوبة
+6. ارجع للتطبيق وستجد رابط المستند الجديد
+
+## ملاحظات مهمة:
+- يتم حفظ بيانات المصادقة في ملف `token.json` لاستخدامها لاحقاً
+- لا تشارك ملفات `credentials.json` أو `token.json` مع أحد
+- يمكنك إلغاء الصلاحيات من إعدادات حساب Google في أي وقت
+
+## استكشاف الأخطاء:
+- إذا ظهر خطأ "credentials.json not found"، تأكد من وضع الملف في المجلد الصحيح
+- إذا فشلت المصادقة، احذف ملف `token.json` وحاول مرة أخرى
+- تأكد من تفعيل Google Docs API في مشروعك

GOOGLE_SETUP_EASY.md

@@ -0,0 +1,82 @@
+# 🚀 إعداد Google Docs - الطريقة السهلة
+
+## 📝 الإجابات على أسئلتك:
+
+### ❓ ماذا أدخل في هذه الحقول؟
+```
+Authorised JavaScript origins: اتركه فارغ (لا تدخل شيء)
+Authorised redirect URIs: اتركه فارغ (لا تدخل شيء)
+```
+**السبب**: نحن ننشئ تطبيق Desktop وليس Web، لذلك لا نحتاج هذه الحقول.
+
+### ❓ لم أستطع الوصول إلى صفحة Scopes؟
+**الحل**: لا تقلق! يمكنك تخطي إضافة الـ Scopes يدوياً. التطبيق سيطلبها تلقائياً.
+
+---
+
+## 🎯 الطريقة المبسطة (5 دقائق فقط):
+
+### 1️⃣ اذهب إلى Google Cloud Console
+🔗 **الرابط**: https://console.cloud.google.com/
+
+### 2️⃣ أنشئ مشروع جديد
+- اضغط "Select a project" → "NEW PROJECT"
+- اسم المشروع: `SyncMaster`
+- اضغط "CREATE"
+
+### 3️⃣ فعّل Google Docs API
+- من القائمة الجانبية: "APIs & Services" → "Library"
+- ابحث عن: `Google Docs API`
+- اضغط على النتيجة الأولى → "ENABLE"
+
+### 4️⃣ إعداد OAuth Consent Screen (مبسط)
+- اذهب إلى: "APIs & Services" → "OAuth consent screen"
+- اختر "External" → "CREATE"
+- املأ فقط:
+  - **App name**: `SyncMaster`
+  - **User support email**: إيميلك
+  - **Developer contact information**: إيميلك
+- اضغط "SAVE AND CONTINUE" في جميع الصفحات (لا تغير شيء آخر)
+
+### 5️⃣ إنشاء Client ID
+- اذهب إلى: "APIs & Services" → "Credentials"
+- اضغط "+ CREATE CREDENTIALS" → "OAuth 2.0 Client ID"
+- اختر "Desktop application"
+- الاسم: `SyncMaster Desktop`
+- **اترك جميع الحقول الأخرى فارغة**
+- اضغط "CREATE"
+
+### 6️⃣ تحميل الملف
+- ستظهر نافذة منبثقة
+- اضغط "DOWNLOAD JSON"
+- احفظ الملف باسم `credentials.json`
+- ضعه في مجلد التطبيق (نفس مكان app.py)
+
+### 7️⃣ اختبار
+```bash
+python check_credentials.py
+```
+يجب أن ترى: ✅ ملف بيانات الاعتماد صحيح!
+
+---
+
+## 🎉 الآن جرب الزر!
+- شغل التطبيق
+- اضغط "📤 تصدير إلى Google Docs"
+- ستفتح نافذة متصفح
+- سجل دخول بحساب Google
+- اضغط "Allow" لمنح الصلاحيات
+- ستحصل على رابط المستند!
+
+---
+
+## 🔧 إذا ظهر تحذير "App isn't verified":
+هذا طبيعي! اضغط:
+1. "Advanced"
+2. "Go to SyncMaster (unsafe)"
+3. "Allow"
+
+---
+
+## 📞 مازلت تواجه مشاكل؟
+أرسل لي لقطة شاشة من الخطأ وسأساعدك فوراً!

GOOGLE_SETUP_SIMPLE.md

@@ -0,0 +1,85 @@
+# 🚀 إعداد Google Docs - دليل مبسط
+
+## ❌ المشكلة الحالية:
+```
+Error 401: invalid_client
+The OAuth client was not found.
+```
+
+## ✅ الحل السريع:
+
+### الخطوة 1: اذهب إلى Google Cloud Console
+🔗 **الرابط المباشر**: https://console.cloud.google.com/
+
+### الخطوة 2: إنشاء مشروع جديد
+1. اضغط على "Select a project" في الأعلى
+2. اضغط على "NEW PROJECT"
+3. اكتب اسم المشروع: `SyncMaster Export`
+4. اضغط "CREATE"
+
+### الخطوة 3: تفعيل Google Docs API
+1. في القائمة الجانبية ← "APIs & Services" ← "Library"
+2. ابحث عن: `Google Docs API`
+3. اضغط على النتيجة الأولى
+4. اضغط "ENABLE"
+
+### الخطوة 4: إعداد OAuth Consent Screen
+1. اذهب إلى "APIs & Services" ← "OAuth consent screen"
+2. اختر "External"
+3. اضغط "CREATE"
+4. املأ المعلومات المطلوبة:
+   - **App name**: `SyncMaster Export`
+   - **User support email**: إيميلك
+   - **Developer contact information**: إيميلك
+5. اضغط "SAVE AND CONTINUE"
+6. **في صفحة "Scopes"**: 
+   - **لا تضيف أي Scopes يدوياً**
+   - فقط اضغط "SAVE AND CONTINUE" مباشرة
+   - (التطبيق سيطلب الصلاحيات تلقائياً عند الاستخدام)
+7. في صفحة "Test users": اضغط "SAVE AND CONTINUE" 
+8. في صفحة "Summary": اضغط "BACK TO DASHBOARD"
+
+### الخطوة 5: إنشاء OAuth 2.0 Client ID
+1. اذهب إلى "APIs & Services" ← "Credentials"
+2. اضغط "+ CREATE CREDENTIALS" ← "OAuth 2.0 Client ID"
+3. اختر "Desktop application"
+4. اكتب الاسم: `SyncMaster Desktop`
+5. **اترك الحقول فارغة**:
+   - **Authorised JavaScript origins**: اتركه فارغ (لا تدخل شيء)
+   - **Authorised redirect URIs**: اتركه فارغ (لا تدخل شيء)
+6. اضغط "CREATE"
+
+### الخطوة 6: تحميل ملف البيانات
+1. ستظهر نافذة منبثقة مع Client ID و Client Secret
+2. اضغط "DOWNLOAD JSON"
+3. احفظ الملف باسم `credentials.json`
+4. انسخ الملف إلى مجلد التطبيق (نفس مجلد app.py)
+
+### الخطوة 7: اختبار التطبيق
+1. احذف ملف `token.json` إذا كان موجوداً
+2. شغل التطبيق
+3. اضغط على زر "📤 تصدير إلى Google Docs"
+4. ستفتح نافذة متصفح للمصادقة
+5. سجل دخول بحساب Google
+6. اضغط "Allow" لمنح الصلاحيات
+
+## 🎯 نصائح مهمة:
+- **استخدم نفس حساب Google** الذي أنشأت به المشروع
+- **لا تشارك ملف credentials.json** مع أحد
+- **إذا ظهر تحذير "App isn't verified"** اضغط "Advanced" ثم "Go to SyncMaster Export (unsafe)"
+
+## 🔧 استكشاف الأخطاء:
+
+### إذا ظهر "invalid_client":
+- تأكد من استبدال ملف `credentials.json` بالملف الحقيقي من Google
+- تأكد من أن الملف في نفس مجلد `app.py`
+
+### إذا ظهر "access_denied":
+- تأكد من الضغط على "Allow" في صفحة المصادقة
+- تأكد من تسجيل الدخول بنفس حساب Google الذي أنشأت به المشروع
+
+### إذا ظهر "redirect_uri_mismatch":
+- احذف ملف `token.json` وحاول مرة أخرى
+
+## 📞 إذا احتجت مساعدة:
+أرسل لي لقطة شاشة من الخطأ وسأساعدك في حله!

INTEGRATION_SOLUTION.md

@@ -0,0 +1,75 @@
+# SyncMaster - Integrated Setup
+
+## 🚀 التشغيل المبسط (HuggingFace Ready)
+
+الآن يمكنك تشغيل التطبيق بأمر واحد فقط:
+
+```bash
+npm run dev
+```
+
+أو 
+
+```bash
+npm start
+```
+
+## 🔧 كيف تم حل المشكلة
+
+### المشكلة السابقة:
+- كان يتطلب تشغيل `python recorder_server.py` و `npm run dev` بشكل منفصل
+- غير مناسب للنشر على HuggingFace أو المنصات السحابية
+
+### الحل الجديد:
+1. **خادم متكامل**: تم إنشاء `integrated_server.py` الذي يشغل خادم التسجيل تلقائياً
+2. **نقطة دخول موحدة**: ملف `main.py` يبدأ كل شيء معاً
+3. **تكوين ذكي**: يكتشف البيئة تلقائياً (محلي أو سحابي)
+
+## 📁 الملفات الجديدة
+
+- `integrated_server.py` - يدير خادم التسجيل المدمج
+- `main.py` - نقطة الدخول الرئيسية 
+- `app_config.py` - إعدادات التطبيق
+- `startup.py` - مُشغل متقدم للتطوير
+
+## 🎯 للاستخدام العادي
+
+```bash
+# تشغيل التطبيق (يشمل خادم التسجيل)
+npm run dev
+
+# أو استخدام Python مباشرة
+streamlit run main.py
+```
+
+## ⚙️ للتطوير المتقدم
+
+```bash
+# تشغيل الخوادم بشكل منفصل (للتطوير)
+npm run dev-separate
+```
+
+## 🌐 للنشر على HuggingFace
+
+فقط ارفع المشروع واستخدم:
+- **Command**: `npm run start`
+- **Port**: `5050`
+
+سيتم تشغيل خادم التسجيل تلقائياً في الخلفية!
+
+## ✅ اختبار النظام
+
+```bash
+python integrated_server.py
+```
+
+## 🎉 النتيجة
+
+- **✅ تشغيل بأمر واحد فقط**
+- **✅ جاهز للنشر على HuggingFace**
+- **✅ يعمل محلياً وسحابياً**
+- **✅ لا حاجة لتشغيل أوامر متعددة**
+
+---
+
+المشكلة محلولة! الآن يمكنك استخدام `npm run dev` فقط وسيعمل كل شيء تلقائياً 🎊

PERFORMANCE_IMPROVEMENTS.md

@@ -0,0 +1,76 @@
+# 🚀 تحسينات الأداء - مشكلة الشاشة البيضاء محلولة
+
+## 🔍 التحليل والمشكلة:
+كانت المشكلة أن خادم التسجيل يبدأ **بشكل متزامن** عند تحميل الصفحة، مما يسبب:
+- ⏰ تأخير في التحميل (نصف ثانية إلى ثانية)
+- ⚪ شاشة بيضاء أثناء انتظار بدء الخادم
+- 🐌 تجربة مستخدم بطيئة
+
+## ✅ الحلول المطبقة:
+
+### 1. **تشغيل غير متزامن للخادم**
+```python
+# بدلاً من:
+ensure_recorder_server()  # يحجب الواجهة
+
+# الآن:
+recorder_thread = threading.Thread(target=start_recorder_async, daemon=True)
+recorder_thread.start()  # لا يحجب الواجهة
+```
+
+### 2. **تسريع فحص الاستجابة**
+```python
+# قبل: timeout=3 ثوان
+# الآن: timeout=0.5 ثانية
+response = requests.get(url, timeout=0.5)
+```
+
+### 3. **تحسين انتظار بدء الخادم**
+```python
+# قبل: sleep(1) × 10 مرات = 10 ثوان
+# الآن: sleep(0.5) × 15 مرة = 7.5 ثانية
+time.sleep(0.5)
+```
+
+### 4. **تحسين CSS لمنع الفلاش**
+```css
+.main .block-container { 
+    animation: fadeIn 0.2s ease-in-out; 
+}
+.stSpinner { display: none !important; }
+```
+
+### 5. **فحص ذكي للخادم**
+```python
+# فحص سريع أولاً
+if integrated_server.is_server_responding():
+    return True  # خروج فوري إذا كان يعمل
+```
+
+## 📊 النتائج:
+
+### قبل التحسين:
+- ⏱️ **تحميل الصفحة**: 1+ ثانية
+- ⚪ **شاشة بيضاء**: نعم
+- 🔄 **تأخير ملحوظ**: نعم
+
+### بعد التحسين:
+- ⏱️ **تحميل الصفحة**: 0.008-0.023 ثانية
+- ⚪ **شاشة بيضاء**: لا
+- ⚡ **تحميل فوري**: نعم
+
+## 🎯 التحسينات الإضافية:
+
+1. **عدم عرض رسائل تحميل غير ضرورية**
+2. **بدء الخادم في الخلفية فقط عند الحاجة**
+3. **تقليل عدد رسائل السجل**
+4. **تحسين CSS للانتقالات السلسة**
+
+## 🚀 النتيجة النهائية:
+
+✅ **لا مزيد من الشاشة البيضاء**  
+✅ **تحميل فوري للمحتوى**  
+✅ **تجربة مستخدم سلسة**  
+✅ **أداء ممتاز (0.008 ثانية)**  
+
+**المشكلة محلولة تماماً!** 🎊

QUICK_START.md

@@ -0,0 +1,202 @@
+# 🎯 دليل الإصلاح والتشغيل السريع - SyncMaster Enhanced
+# Quick Fix and Startup Guide - SyncMaster Enhanced
+
+## ✅ النظام جاهز للعمل! / System Ready!
+
+تم اختبار جميع المكونات بنجاح ✅ All components tested successfully
+
+## 🚀 طرق التشغيل / Startup Methods
+
+### 1. التشغيل التلقائي المتقدم / Advanced Auto-Start (موصى به / Recommended)
+```bash
+python start_debug.py
+```
+**المزايا / Benefits:**
+- فحص تلقائي للمشاكل / Automatic problem detection
+- إصلاح تضارب المنافذ / Port conflict resolution  
+- رسائل خطأ واضحة / Clear error messages
+- تشغيل آمن / Safe startup
+
+### 2. التشغيل اليدوي / Manual Startup
+```bash
+# النافذة الأولى / First Terminal
+python recorder_server.py
+
+# النافذة الثانية / Second Terminal  
+streamlit run app.py --server.port 8501
+```
+
+### 3. التشغيل السريع / Quick Start (Windows)
+```bash
+start_enhanced.bat
+```
+
+## 🌐 الروابط / URLs
+
+بعد التشغيل الناجح / After successful startup:
+
+- **🎙️ واجهة التسجيل / Recording Interface**: http://localhost:5001
+- **💻 التطبيق الرئيسي / Main Application**: http://localhost:8501
+- **🔄 فحص حالة الخادم / Server Status**: http://localhost:5001/record
+
+## 📋 خطوات الاستخدام / Usage Steps
+
+### للطلاب الجدد / For New Users:
+
+#### 1. إعداد اللغة / Language Setup
+- اختر اللغة المفضلة (عربي/English)
+- فعّل الترجمة التلقائية
+- اختر اللغة المستهدفة
+
+#### 2. التسجيل / Recording
+- اذهب لتبويب "🎙️ Record Audio"  
+- اضغط "Start Recording" / "بدء التسجيل"
+- تحدث بوضوح
+- استخدم "Mark Important" للنقاط المهمة
+- اضغط "Stop" عند الانتهاء
+
+#### 3. المعالجة / Processing
+- اضغط "Extract Text" / "استخراج النص"
+- انتظر المعالجة (قد تستغرق دقائق)
+- راجع النص الأصلي والمترجم
+
+#### 4. الحفظ / Saving
+- انسخ النص المطلوب
+- احفظ ملف JSON للمراجعة لاحقاً
+
+## 🔧 استكشاف الأخطاء / Troubleshooting
+
+### المشكلة الأكثر شيوعاً / Most Common Issue:
+```
+Error: Failed to fetch
+POST http://localhost:5001/record net::ERR_CONNECTION_REFUSED
+```
+
+### الحل السريع / Quick Fix:
+```bash
+# 1. أوقف جميع العمليات / Stop all processes
+taskkill /f /im python.exe
+
+# 2. شغّل الاختبار / Run test
+python test_system.py
+
+# 3. شغّل النظام / Start system
+python start_debug.py
+```
+
+### إذا لم يعمل / If Still Not Working:
+```bash
+# فحص المنافذ / Check ports
+netstat -an | findstr :5001
+netstat -an | findstr :8501
+
+# إعادة تثبيت التبعيات / Reinstall dependencies
+pip install --upgrade -r requirements.txt
+```
+
+## 💡 نصائح مهمة / Important Tips
+
+### للحصول على أفضل النتائج / For Best Results:
+
+#### جودة التسجيل / Recording Quality:
+- استخدم سماعة رأس بميكروفون
+- اجلس في مكان هادئ
+- تحدث بوضوح وبطء نسبي
+- تجنب الضوضاء الخلفية
+
+#### إعدادات الترجمة / Translation Settings:
+- **للطلاب العرب**: فعّل الترجمة للإنجليزية لفهم المصطلحات التقنية
+- **للطلاب الدوليين**: استخدم الترجمة للغتك الأم
+- **للمحاضرات المختلطة**: راجع النص بكلا اللغتين
+
+#### استخدام العلامات / Using Markers:
+- ضع علامة عند المفاهيم الجديدة
+- اعلم النقاط المهمة للامتحان
+- استخدم العلامات للتنظيم
+
+## 📱 متطلبات النظام / System Requirements
+
+### الحد الأدنى / Minimum:
+- Python 3.8+
+- 4 GB RAM
+- اتصال إنترنت للترجمة
+- مساحة 1 GB على القرص الصلب
+
+### الموصى به / Recommended:
+- Python 3.10+
+- 8 GB RAM
+- اتصال إنترنت سريع
+- SSD للتخزين
+- ميكروفون عالي الجودة
+
+## 🌟 ميزات متقدمة / Advanced Features
+
+### اختصارات لوحة المفاتيح / Keyboard Shortcuts:
+- **Space**: بدء/إيقاف التسجيل
+- **M**: وضع علامة مهمة  
+- **P**: إيقاف مؤقت/استئناف
+- **R**: إعادة تسجيل
+
+### واجهة برمجة التطبيقات / API Features:
+- ترجمة نصوص مستقلة
+- معالجة مجمعة للملفات
+- كشف اللغة التلقائي
+- تخصيص إعدادات الصوت
+
+## 📞 الدعم التقني / Technical Support
+
+### أدوات التشخيص / Diagnostic Tools:
+```bash
+# اختبار شامل / Complete test
+python test_system.py
+
+# فحص الاتصال / Connection test  
+python -c "import requests; print(requests.get('http://localhost:5001/record').status_code)"
+
+# اختبار الترجمة / Translation test
+python -c "from translator import AITranslator; t=AITranslator(); print(t.translate_text('Hello', 'ar'))"
+```
+
+### ملفات السجل / Log Files:
+- تحقق من console المتصفح (F12)
+- راجع سجلات الطرفية
+- ابحث عن ملفات tmp*.json
+
+## 🎓 للمدرسين والمحاضرين / For Teachers and Lecturers
+
+### إعدادات الفصل / Classroom Setup:
+- تأكد من إذن التسجيل
+- وضح للطلاب كيفية الاستخدام
+- اقترح جلسات تدريبية
+
+### نصائح للمحاضرات / Lecture Tips:
+- تحدث بوضوح
+- اكرر المصطلحات المهمة  
+- استخدم فترات صمت قصيرة
+- اشرح بعدة لغات إذا أمكن
+
+---
+
+## 🎉 مبروك! / Congratulations!
+
+**النظام جاهز للاستخدام! / System is ready to use!**
+
+```bash
+# للبدء الآن / To start now:
+python start_debug.py
+```
+
+**استمتع بتجربة تعليمية محسنة مع SyncMaster! 🚀**
+**Enjoy an enhanced learning experience with SyncMaster! 🚀**
+
+---
+
+### 📋 Checklist
+
+- ✅ Python مثبت / Python installed
+- ✅ التبعيات مثبتة / Dependencies installed  
+- ✅ مفتاح API مُعد / API key configured
+- ✅ اختبار النظام نجح / System test passed
+- ✅ جاهز للاستخدام / Ready to use
+
+**🎯 التالي: python start_debug.py**

README.md

@@ -0,0 +1,221 @@
+---
+title: SyncMaster Enhanced
+emoji: 🚀
+colorFrom: red
+colorTo: red
+sdk: docker
+app_port: 8501
+tags:
+- streamlit
+- ai-translation
+- speech-to-text
+- multilingual
+- education
+pinned: false
+short_description: AI-powered audio transcription
+license: mit
+---
+
+# SyncMaster Enhanced - AI-Powered Audio Transcription & Translation
+
+> **🌟 New: Enhanced with AI Translation Support for International Students**
+> **جديد: محسن مع دعم الترجمة بالذكاء الاصطناعي للطلاب الدوليين**
+
+SyncMaster is an intelligent audio-text synchronization platform specifically designed for international students in universities. It provides real-time audio recording, AI-powered transcription, and automatic translation to help students better understand and review their lectures.
+
+## ✨ Key Features
+
+### 🌐 Multi-Language Support
+- **Full Arabic Interface**: Complete Arabic UI for better accessibility
+- **AI-Powered Translation**: Automatic translation to Arabic, English, French, and Spanish
+- **Language Detection**: Automatically detects the source language
+- **Academic Context**: Specialized translation for academic content
+
+### 🎙️ Enhanced Recording
+- **Browser-based Recording**: Record directly from your web browser
+- **Real-time Audio Visualization**: Visual feedback during recording
+- **Important Markers**: Mark important points during lectures
+- **Pause/Resume**: Full control over recording sessions
+
+### 🤖 AI Technology
+- **Gemini AI Integration**: Accurate transcription using Google's Gemini AI
+- **Advanced Translation**: Context-aware translation for educational content
+- **Parallel Processing**: Fast and efficient audio processing
+
+### 📱 Student-Friendly Features
+- **Responsive Design**: Works on desktop, tablet, and mobile
+- **Keyboard Shortcuts**: Quick access to common functions
+- **Accessibility**: Screen reader support and RTL language support
+- **Offline Capability**: Process recordings without constant internet
+
+## 🚀 Quick Start
+
+### For International Students:
+
+1. **Setup**:
+   ```bash
+   # Clone or download the project
+   # Install Python 3.8+
+   python setup_enhanced.py
+   ```
+
+2. **Run**:
+   ```bash
+   # Windows
+   start_enhanced.bat
+   
+   # Linux/Mac
+   python setup_enhanced.py
+   ```
+
+3. **Configure**:
+   - Add your Gemini API key to `.env` file
+   - Choose your preferred language (Arabic/English)
+   - Enable translation and select target language
+
+### API Key Setup:
+1. Get a free Gemini API key from [Google AI Studio](https://makersuite.google.com/app/apikey)
+2. Add it to your `.env` file:
+   ```
+   GEMINI_API_KEY=your_api_key_here
+   ```
+
+## 📖 Usage Guide
+
+### Recording Lectures:
+1. Go to the **Record Audio** tab
+2. Click **Start Recording**
+3. Use **Mark Important** for key points
+4. Click **Stop** when finished
+5. Click **Extract Text** to process
+
+### Translation:
+1. Enable translation in settings
+2. Select target language
+3. Process your audio
+4. Review both original and translated text
+
+### Export Options:
+- Copy text for notes
+- Save as files for later review
+- Generate synchronized videos (coming soon)
+
+## 🎓 For Students
+
+### Arabic Students (للطلاب العرب):
+- استخدم الواجهة العربية لسهولة الاستخدام
+- فعّل الترجمة للإنجليزية لفهم المصطلحات التقنية
+- ضع علامات على المفاهيم الجديدة أثناء المحاضرة
+
+### International Students:
+- Use translation to your native language for better understanding
+- Mark important concepts during lectures
+- Review both original and translated text together
+
+## ⌨️ Keyboard Shortcuts
+- **Space**: Start/Stop recording
+- **M**: Mark important point
+- **P**: Pause/Resume
+- **R**: Re-record
+
+## 🔧 Technical Requirements
+
+### System Requirements:
+- Python 3.8 or higher
+- Modern web browser (Chrome, Firefox, Safari, Edge)
+- Microphone access for recording
+- Internet connection for AI processing
+
+### Dependencies:
+- Streamlit (Web interface)
+- Google Generative AI (Transcription & Translation)
+- Flask (Recording server)
+- LibROSA (Audio processing)
+
+## 📱 Browser Compatibility
+
+| Browser | Recording | Translation | UI |
+|---------|-----------|-------------|----| 
+| Chrome | ✅ | ✅ | ✅ |
+| Firefox | ✅ | ✅ | ✅ |
+| Safari | ✅ | ✅ | ✅ |
+| Edge | ✅ | ✅ | ✅ |
+
+## 🛠️ Troubleshooting
+
+### Common Issues:
+
+**Microphone not working:**
+- Grant microphone permission to your browser
+- Check system audio settings
+- Try a different browser
+
+**Translation errors:**
+- Check internet connection
+- Verify Gemini API key
+- Try processing again
+
+**Poor transcription quality:**
+- Ensure clear audio recording
+- Reduce background noise
+- Speak clearly and at moderate pace
+
+## 🔮 Roadmap
+
+### Coming Soon:
+- **Smart Content Analysis**: Automatic extraction of key concepts
+- **Study Cards**: Generate flashcards from lectures
+- **Platform Integration**: Connect with Moodle, Canvas, etc.
+- **Collaborative Features**: Share recordings with classmates
+- **Advanced Analytics**: Learning progress tracking
+
+## 📚 Documentation
+
+- [**Arabic Guide**](README_AR.md) - دليل باللغة العربية
+- [**API Documentation**](docs/api.md) - Technical API reference
+- [**Troubleshooting**](docs/troubleshooting.md) - Detailed problem solving
+
+## 🤝 Contributing
+
+We welcome contributions from the international student community:
+
+1. Fork the repository
+2. Create a feature branch
+3. Add your improvements
+4. Submit a pull request
+
+### Areas for Contribution:
+- Additional language support
+- UI improvements
+- Mobile optimization
+- Documentation translation
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- Google Gemini AI for transcription and translation
+- Streamlit team for the amazing web framework
+- International student community for feedback and testing
+
+## 📞 Support
+
+For technical support or questions:
+- Check the browser console (F12) for error details
+- Review log files in the application directory
+- Ensure all dependencies are up to date
+
+---
+
+**Made with ❤️ for international students worldwide**
+**صُنع بـ ❤️ للطلاب الدوليين حول العالم**
+
+---
+
+### Quick Links:
+- 🚀 [Quick Start Guide](docs/quickstart.md)
+- 🌐 [Arabic Documentation](README_AR.md)
+- 🎓 [Student Guide](docs/student-guide.md)
+- 🔧 [Technical Setup](docs/technical-setup.md)

README_AR.md

@@ -0,0 +1,134 @@
+# SyncMaster - دليل المستخدم للطلاب الأجانب
+
+## 🎯 نظرة عامة
+SyncMaster هو تطبيق ذكي مطور خصيصاً للطلاب الأجانب في الجامعات لتسجيل المحاضرات وتحويلها إلى نص مكتوب مع ترجمة فورية باستخدام الذكاء الاصطناعي.
+
+## ✨ الميزات الجديدة
+
+### 🌐 دعم متعدد اللغات
+- **واجهة عربية كاملة**: تم تطوير واجهة باللغة العربية لتسهيل الاستخدام
+- **ترجمة فورية**: ترجمة النص المنسوخ إلى العربية والإنجليزية والفرنسية والإسبانية
+- **كشف اللغة التلقائي**: يتعرف النظام على لغة المحاضرة تلقائياً
+
+### 🎙️ ميزات التسجيل المحسنة
+- **تسجيل مباشر**: تسجيل المحاضرات مباشرة من المتصفح
+- **علامات مهمة**: وضع علامات على النقاط المهمة أثناء التسجيل
+- **مؤشر مستوى الصوت**: عرض مرئي لمستوى الصوت
+- **إيقاف مؤقت واستئناف**: تحكم كامل في التسجيل
+
+### 🤖 ذكاء اصطناعي متطور
+- **نسخ دقيق**: استخدام Gemini AI لنسخ دقيق للمحاضرات
+- **ترجمة محسنة**: ترجمة متخصصة للمحتوى الأكاديمي
+- **معالجة متوازية**: معالجة سريعة وفعالة
+
+## 🚀 كيفية الاستخدام
+
+### الخطوة 1: إعداد اللغة
+1. اختر لغة الواجهة من القائمة العلوية (العربية/English)
+2. فعّل الترجمة التلقائية
+3. اختر اللغة المستهدفة للترجمة
+
+### الخطوة 2: التسجيل
+1. اضغط على تبويب "🎙️ Record Audio"
+2. اضغط "Start Recording" لبدء التسجيل
+3. استخدم "Mark Important" لوضع علامات على النقاط المهمة
+4. اضغط "Stop" لإنهاء التسجيل
+
+### الخطوة 3: المعالجة والترجمة
+1. اضغط "Extract Text" لبدء المعالجة
+2. انتظر حتى يكتمل النسخ والترجمة
+3. راجع النص الأصلي والمترجم
+
+### الخطوة 4: التصدير
+1. احفظ النتائج أو انسخها
+2. استخدم الملف المحفوظ للمراجعة لاحقاً
+
+## ⌨️ اختصارات لوحة المفاتيح
+- **Space**: بدء/إيقاف التسجيل
+- **M**: وضع علامة مهمة
+- **P**: إيقاف مؤقت/استئناف
+- **R**: إعادة تسجيل
+
+## 📱 نصائح للطلاب الأجانب
+
+### للطلاب العرب:
+- استخدم الواجهة العربية للسهولة
+- فعّل الترجمة للإنجليزية لفهم المصطلحات التقنية
+- ضع علامات على المفاهيم الجديدة
+
+### للطلاب الدوليين:
+- استخدم الترجمة إلى لغتك الأم للفهم الأفضل
+- اعتمد على العلامات المهمة للمراجعة السريعة
+- راجع النص المترجم والأصلي معاً
+
+## 🔧 إعدادات متقدمة
+
+### جودة التسجيل:
+- **عالية**: للمحاضرات المهمة (320 kbps)
+- **متوسطة**: للاستخدام العادي (192 kbps)
+- **منخفضة**: لتوفير المساحة (128 kbps)
+
+### إعدادات الترجمة:
+- **Arabic**: للطلاب العرب
+- **English**: للمحتوى الدولي
+- **French**: للطلاب الفرنكوفونيين
+- **Spanish**: للطلاب الناطقين بالإسبانية
+
+## 🛠️ استكشاف الأخطاء
+
+### مشاكل الميكروفون:
+1. تأكد من إعطاء إذن الميكروفون للمتصفح
+2. تحقق من إعدادات الصوت في النظام
+3. جرب متصفح آخر إذا لزم الأمر
+
+### مشاكل الترجمة:
+1. تأكد من اتصال الإنترنت
+2. تحقق من صحة مفتاح API
+3. جرب إعادة المعالجة
+
+### مشاكل في النسخ:
+1. تأكد من وضوح الصوت
+2. قلل الضوضاء في الخلفية
+3. تحدث بوضوح وبطء نسبياً
+
+## 📞 الدعم التقني
+
+### الحصول على المساعدة:
+- تحقق من console المتصفح (F12) للأخطاء
+- راجع ملفات السجل في مجلد التطبيق
+- تأكد من تحديث جميع المكتبات
+
+### نصائح للأداء الأفضل:
+- استخدم Chrome أو Firefox للتوافق الأفضل
+- أغلق التطبيقات الأخرى أثناء التسجيل
+- تأكد من مساحة كافية على القرص الصلب
+
+## 🎓 نصائح أكاديمية
+
+### للمحاضرات:
+- اجلس في مقدمة القاعة للصوت الأوضح
+- استخدم علامات المحاضر المهمة كدليل
+- راجع الترجمة مع زملاء الدراسة
+
+### للمذاكرة:
+- استخدم النص المترجم للمراجعة السريعة
+- ابحث عن المفاهيم المترجمة في مصادر إضافية
+- اربط النص الأصلي بالترجمة لتحسين اللغة
+
+## 🔮 ميزات قادمة
+
+### التحديثات المخططة:
+- **تحليل المحتوى**: استخراج النقاط الرئيسية تلقائياً
+- **بطاقات المراجعة**: إنشاء بطاقات دراسة من المحاضرات
+- **التكامل مع المنصات**: ربط مع Moodle وCanvas
+- **المشاركة التعاونية**: مشاركة المحاضرات مع الزملاء
+
+---
+
+## 📄 إخلاء المسؤولية
+
+هذا التطبيق مخصص للاستخدام التعليمي. تأكد من الحصول على إذن المحاضر قبل تسجيل المحاضرات. النسخ والترجمة قد يحتويان على أخطاء، لذا راجعهما دائماً.
+
+---
+
+**نتمنى لك تجربة تعليمية ممتازة مع SyncMaster! 🎓✨**

SOLUTION_SUMMARY.md

@@ -0,0 +1,69 @@
+# 🎉 تم حل المشكلة بنجاح!
+
+## ✅ ملخص الحل
+
+تم حل مشكلة "system offline" في ميزة Lecture Recorder بنجاح. الآن يمكنك تشغيل التطبيق بأمر واحد فقط:
+
+```bash
+npm run dev
+```
+
+## 🔧 التغييرات التي تمت
+
+### 1. ملفات جديدة تم إنشاؤها:
+- `integrated_server.py` - خادم متكامل للتسجيل
+- `main.py` - نقطة دخول بسيطة ومدمجة
+- `app_config.py` - إعدادات التطبيق
+- `startup.py` - مُشغل متقدم للتطوير
+
+### 2. ملفات تم تعديلها:
+- `app.py` - إضافة استيراد الخادم المدمج
+- `package.json` - تحديث أوامر التشغيل
+
+## 🚀 كيفية الاستخدام
+
+### للاستخدام العادي:
+```bash
+npm run dev
+```
+
+### للنشر على HuggingFace:
+```bash
+npm start
+```
+
+### للتطوير المتقدم (خوادم منفصلة):
+```bash
+npm run dev-separate
+```
+
+## ✨ المميزات الجديدة
+
+1. **🎯 تشغيل موحد**: أمر واحد فقط لتشغيل كل شيء
+2. **☁️ جاهز للسحابة**: يعمل تلقائياً على HuggingFace و Railway
+3. **🔧 تكوين ذكي**: يكتشف البيئة ويتكيف معها
+4. **🛡️ معالجة أخطاء محسنة**: تشغيل احتياطي في حالة فشل الطريقة الأولى
+5. **📊 مراقبة الحالة**: فحص تلقائي لحالة الخوادم
+
+## 🧪 اختبار النظام
+
+تم اختبار النظام وأظهر النتائج التالية:
+- ✅ خادم التسجيل يبدأ تلقائياً
+- ✅ Streamlit يعمل على المنفذ 5050
+- ✅ خادم التسجيل يعمل على المنفذ 5001
+- ✅ التكامل بين الخوادم يعمل بنجاح
+
+## 🎊 النتيجة النهائية
+
+**المشكلة محلولة تماماً!** 
+
+لن تحتاج بعد الآن إلى:
+- ❌ تشغيل `python recorder_server.py` منفصلاً
+- ❌ القلق بشأن "system offline"
+- ❌ تشغيل أوامر متعددة
+
+فقط استخدم `npm run dev` وسيعمل كل شيء تلقائياً! 🚀
+
+---
+
+**جاهز للنشر على HuggingFace الآن!** 🌟

SUMMARY_FIX_REPORT.md

@@ -0,0 +1,169 @@
+# حل مشكلة زر التلخيص - تقرير الإصلاح النهائي 🎉
+
+## 📋 ملخص المشكلة
+كان زر "Generate Smart Lecture Summary" لا يعمل في تلخيص النص المستخرج من الذكاء الاصطناعي بعد جلبه من الصوت، مع ظهور خطأ CORS:
+
+```
+Access to fetch at 'http://localhost:5001/summarize' from origin 'http://localhost:5054' has been blocked by CORS policy: Response to preflight request doesn't pass access control check: The 'Access-Control-Allow-Origin' header contains multiple values '*, *', but only one is allowed.
+```
+
+## 🔍 التشخيص المنجز
+تم إنشاء نظام تشخيص شامل كشف عن:
+
+### 1. مشكلة CORS الرئيسية ❌
+- **المشكلة**: الخادم يرسل `'*, *'` بدلاً من `'*'`
+- **السبب**: تكرار إعدادات CORS - مرة من `flask-cors` ومرة يدوياً في كل endpoint
+- **النتيجة**: تكرار header `Access-Control-Allow-Origin`
+
+### 2. مكتبة مفقودة ❌
+- **المشكلة**: `google-generativeai` غير مثبتة
+- **التأثير**: فشل في وظيفة التلخيص
+
+## ✅ الحلول المطبقة
+
+### 1. إصلاح مشكلة CORS
+#### أ. تبسيط إعداد CORS في `recorder_server.py`:
+```python
+# قبل الإصلاح - إعداد معقد
+CORS(app, resources={
+    r"/record": {"origins": "*"},
+    r"/translate": {"origins": "*"},
+    r"/languages": {"origins": "*"},
+    r"/ui-translations/*": {"origins": "*"},
+    r"/notes": {"origins": "*"},
+    r"/notes/*": {"origins": "*"},
+    r"/summarize": {"origins": "*"}
+})
+
+# بعد الإصلاح - إعداد مبسط وصحيح
+CORS(app, 
+     origins="*",
+     methods=['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+     allow_headers=['Content-Type', 'Authorization']
+)
+```
+
+#### ب. إزالة الإعدادات اليدوية المكررة:
+```python
+# قبل الإصلاح - إعداد يدوي مكرر
+if request.method == 'OPTIONS':
+    headers = {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'POST, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type',
+    }
+    return ('', 204, headers)
+
+# بعد الإصلاح - تبسيط
+if request.method == 'OPTIONS':
+    return '', 204  # flask-cors ستتولى الأمر
+```
+
+### 2. تثبيت المكتبات المفقودة
+```bash
+pip install google-generativeai
+```
+
+### 3. تحسين معالجة الأخطاء في JavaScript
+تم تحديث دالة `generateSummary()` في `templates/recorder.html`:
+- رسائل خطأ محددة باللغة العربية
+- معالجة أفضل لتنسيقات الاستجابة المختلفة
+- تشخيص أوضح للمشاكل
+
+### 4. تحسين دالة عرض النتائج
+تم تحديث `displaySummaryResults()` للتعامل مع:
+- تنسيقات مختلفة للاستجابة (نص أو كائن)
+- عرض محتوى احتياطي في حالة عدم وجود المحتوى المتوقع
+
+## 🧪 أدوات التشخيص المُنشأة
+
+### 1. `diagnose_summary.py`
+نظام تشخيص شامل يفحص:
+- حالة العمليات والمنافذ
+- إعدادات CORS
+- وظيفة التلخيص
+- المكتبات المطلوبة
+
+### 2. `test_summary_button.py`
+اختبار مبسط ومباشر لزر التلخيص
+
+### 3. `test_summarize.py`
+اختبار أساسي لـ endpoint التلخيص
+
+## 📊 نتائج الاختبار النهائية ✅
+
+```
+🎉 جميع الاختبارات نجحت!
+✅ زر التلخيص يعمل بشكل صحيح
+
+📊 ملخص التشخيص:
+  📦 المكتبات: ✅ موجودة
+  🔧 عملية Python: ✅ تعمل
+  🌐 المنفذ 5001: ✅ مفتوح
+  🔧 CORS: ✅ صحيح
+  🤖 التلخيص: ✅ يعمل
+```
+
+## 🔧 الملفات المُعدّلة
+
+### 1. `recorder_server.py`
+- إصلاح إعدادات CORS
+- إزالة التكرار في headers
+- تبسيط معالجة OPTIONS requests
+
+### 2. `templates/recorder.html`
+- تحسين دالة `generateSummary()`
+- تحسين دالة `displaySummaryResults()`
+- رسائل خطأ أوضح
+
+### 3. ملفات التشخيص الجديدة
+- `diagnose_summary.py`
+- `test_summary_button.py`
+- `test_summarize.py`
+
+## 🚀 كيفية التحقق من الحل
+
+### 1. تشغيل الخادم:
+```bash
+python recorder_server.py
+```
+
+### 2. تشغيل التشخيص:
+```bash
+python diagnose_summary.py
+```
+
+### 3. اختبار زر التلخيص:
+```bash
+python test_summary_button.py
+```
+
+### 4. اختبار من الواجهة:
+1. افتح `http://localhost:5054`
+2. سجل صوت أو ادخل نص
+3. اضغط زر "🤖 Generate Smart Lecture Summary"
+4. تأكد من ظهور الملخص
+
+## 💡 نصائح للمستقبل
+
+### 1. تجنب تكرار CORS
+- استخدم إعداد CORS واحد فقط
+- لا تضع إعدادات يدوية إضافية
+
+### 2. مراقبة التبعيات
+- تأكد من تثبيت جميع المكتبات المطلوبة
+- استخدم `requirements.txt` محدث
+
+### 3. استخدام أدوات التشخيص
+- شغل `diagnose_summary.py` عند مواجهة مشاكل
+- يوفر تشخيص سريع وشامل
+
+## 🎯 الخلاصة
+
+تم حل مشكلة زر التلخيص بنجاح من خلال:
+1. ✅ إصلاح مشكلة CORS المزدوجة
+2. ✅ تثبيت المكتبات المفقودة  
+3. ✅ تحسين معالجة الأخطاء
+4. ✅ إنشاء أدوات تشخيص شاملة
+
+**النتيجة: زر التلخيص يعمل بشكل مثالي الآن! 🎉**

TECHNICAL_IMPLEMENTATION.md

@@ -0,0 +1,299 @@
+# SyncMaster Enhanced - Technical Implementation Summary
+
+## 🎯 Summary of Enhancements
+
+This document outlines the comprehensive improvements made to SyncMaster to support AI-powered translation for international students.
+
+## 🔧 New Components Added
+
+### 1. `translator.py` - AI Translation Engine
+```python
+class AITranslator:
+    - translate_text(text, target_language='ar', source_language='auto')
+    - detect_language(text)
+    - translate_ui_elements(ui_dict, target_language='ar')
+    - batch_translate(texts, target_language='ar')
+```
+
+**Features:**
+- Gemini AI-powered translation
+- Academic content optimization
+- Multi-language support (Arabic, English, French, Spanish)
+- Batch processing capabilities
+- Context-aware translation
+
+### 2. Enhanced `audio_processor.py`
+```python
+class AudioProcessor:
+    - get_word_timestamps_with_translation(audio_file_path, target_language='ar')
+    - batch_translate_transcription(audio_file_path, target_languages)
+    - _create_translated_timestamps(original_timestamps, original_text, translated_text)
+```
+
+**New Features:**
+- Integrated translation with transcription
+- Proportional timestamp mapping for translated text
+- Multi-language processing
+- Enhanced error handling and logging
+
+### 3. Updated `recorder_server.py`
+```python
+@app.route('/record', methods=['POST'])
+def record():
+    # Enhanced with translation parameters:
+    # - target_language
+    # - enable_translation
+    # - comprehensive response with both original and translated text
+
+@app.route('/translate', methods=['POST'])
+def translate_text():
+    # Standalone translation endpoint
+
+@app.route('/languages', methods=['GET'])
+def get_supported_languages():
+    # Get list of supported languages
+
+@app.route('/ui-translations/<language>', methods=['GET'])
+def get_ui_translations(language):
+    # Get UI translations for specific language
+```
+
+### 4. Enhanced `templates/recorder.html`
+**New Features:**
+- Multi-language interface (English/Arabic)
+- RTL support for Arabic
+- Translation toggle controls
+- Target language selection
+- Enhanced visual design
+- Keyboard shortcuts
+- Accessibility improvements
+
+**UI Improvements:**
+- Modern gradient design
+- Responsive layout for mobile devices
+- Real-time language switching
+- Visual feedback for translation status
+- Better error messaging
+
+### 5. Updated `app.py` - Main Application
+**Enhancements:**
+- Language selection in sidebar
+- Translation settings integration
+- Enhanced processing workflow
+- Bilingual interface support
+- Improved user experience flow
+
+## 🌐 Multi-Language Support Implementation
+
+### UI Translation System
+```python
+UI_TRANSLATIONS = {
+    'en': { /* English translations */ },
+    'ar': { /* Arabic translations */ }
+}
+```
+
+### Dynamic Language Switching
+- Client-side language detection
+- Server-side translation API
+- Real-time UI updates
+- RTL text direction support
+
+### Translation Workflow
+1. **Audio Recording** → Record with language preferences
+2. **Transcription** → AI-powered speech-to-text
+3. **Language Detection** → Automatic source language identification
+4. **Translation** → Context-aware AI translation
+5. **Presentation** → Side-by-side original and translated text
+
+## 🚀 API Enhancements
+
+### Recording Endpoint (`/record`)
+**Request Parameters:**
+```json
+{
+    "audio_data": "binary_audio_file",
+    "markers": "[timestamp_array]",
+    "target_language": "ar|en|fr|es",
+    "enable_translation": "true|false"
+}
+```
+
+**Response Format:**
+```json
+{
+    "success": true,
+    "original_text": "Original transcription",
+    "translated_text": "Translated text",
+    "file_path": "path/to/saved/file.json",
+    "markers": [timestamps],
+    "target_language": "ar",
+    "translation_enabled": true,
+    "translation_success": true,
+    "language_detected": "en"
+}
+```
+
+### Translation Endpoint (`/translate`)
+**Request:**
+```json
+{
+    "text": "Text to translate",
+    "target_language": "ar",
+    "source_language": "auto"
+}
+```
+
+**Response:**
+```json
+{
+    "success": true,
+    "original_text": "Original text",
+    "translated_text": "النص المترجم",
+    "source_language": "en",
+    "target_language": "ar"
+}
+```
+
+## 📱 Frontend Enhancements
+
+### JavaScript Features
+```javascript
+// Language Management
+async function loadTranslations(language)
+function applyTranslations()
+function changeLanguage()
+
+// Enhanced Recording
+function displayResults(result)
+function displayMarkers(markers)
+function showMessage(message, type)
+
+// Keyboard Shortcuts
+document.addEventListener('keydown', handleKeyboardShortcuts)
+```
+
+### CSS Improvements
+```css
+/* RTL Support */
+html[dir="rtl"] { direction: rtl; }
+
+/* Modern Design */
+:root {
+    --primary-color: #4A90E2;
+    --success-color: #50C878;
+    /* ... more color variables */
+}
+
+/* Responsive Design */
+@media (max-width: 768px) {
+    /* Mobile optimizations */
+}
+```
+
+## 🔒 Security & Performance
+
+### Security Measures
+- Input validation for all API endpoints
+- CORS configuration for cross-origin requests
+- Secure file handling with temporary files
+- API key protection in environment variables
+
+### Performance Optimizations
+- Parallel processing for audio and translation
+- Efficient memory management
+- Chunked audio processing
+- Client-side caching for translations
+
+## 📊 File Structure Changes
+
+```
+SyncMaster - Copy (2)/
+├── translator.py              # NEW: AI Translation engine
+├── audio_processor.py         # ENHANCED: With translation support
+├── recorder_server.py         # ENHANCED: Additional endpoints
+├── app.py                    # ENHANCED: Multi-language support
+├── templates/
+│   └── recorder.html         # ENHANCED: Multi-language UI
+├── README_AR.md              # NEW: Arabic documentation
+├── setup_enhanced.py         # NEW: Enhanced setup script
+├── start_enhanced.bat        # NEW: Quick start script
+├── requirements.txt          # UPDATED: Additional dependencies
+└── .env                      # UPDATED: Additional configuration
+```
+
+## 🎓 Educational Features
+
+### For International Students
+1. **Language Barrier Reduction**: Real-time translation of lectures
+2. **Better Comprehension**: Side-by-side original and translated text
+3. **Cultural Adaptation**: Interface in native language
+4. **Academic Context**: Specialized translation for educational content
+
+### For Arabic Students
+1. **Native Interface**: Complete Arabic UI
+2. **Technical Term Translation**: English technical terms with Arabic explanations
+3. **Reading Direction**: Proper RTL text display
+4. **Cultural Context**: Academic content adapted for Arabic speakers
+
+## 🔧 Installation & Setup
+
+### Enhanced Setup Process
+1. **Automated Installation**: `python setup_enhanced.py`
+2. **Dependency Management**: Automatic package installation
+3. **Configuration Validation**: Environment file checking
+4. **Service Management**: Automatic server startup
+
+### Quick Start Options
+- **Windows**: `start_enhanced.bat`
+- **Cross-platform**: `python setup_enhanced.py`
+- **Manual**: Individual component startup
+
+## 📈 Testing & Quality Assurance
+
+### Translation Quality
+- Academic content optimization
+- Technical term preservation
+- Context-aware translation
+- Fallback mechanisms
+
+### User Experience Testing
+- Multi-language interface testing
+- Mobile responsiveness
+- Accessibility compliance
+- Performance optimization
+
+## 🔮 Future Enhancements
+
+### Planned Features
+1. **Advanced Translation**: Subject-specific terminology
+2. **Collaboration Tools**: Shared study sessions
+3. **Learning Analytics**: Progress tracking
+4. **Platform Integration**: LMS connectivity
+5. **Offline Support**: Local processing capabilities
+
+### Technical Roadmap
+1. **Model Optimization**: Faster processing
+2. **Caching System**: Reduced API calls
+3. **Advanced UI**: More interactive features
+4. **Mobile App**: Native mobile application
+
+---
+
+## 📞 Technical Support
+
+### Debugging Features
+- Comprehensive logging system
+- Browser console integration
+- Error message localization
+- Performance monitoring
+
+### Troubleshooting Resources
+- Detailed error messages
+- Multi-language support documentation
+- Community forum integration
+- Technical FAQ
+
+---
+
+**This enhanced version of SyncMaster represents a significant advancement in making educational technology accessible to international students worldwide.**

TROUBLESHOOTING.md

@@ -0,0 +1,251 @@
+# 🛠️ دليل استكشاف الأخطاء - SyncMaster Enhanced
+# Troubleshooting Guide - SyncMaster Enhanced
+
+## 🔍 الأخطاء الشائعة وحلولها / Common Errors and Solutions
+
+### 1. خطأ الاتصال بالخادم / Server Connection Error
+```
+Error: Failed to fetch
+POST http://localhost:5001/record net::ERR_CONNECTION_REFUSED
+```
+
+**الأسباب المحتملة / Possible Causes:**
+- الخادم غير يعمل / Server not running
+- منفذ 5001 مستخدم من برنامج آخر / Port 5001 used by another application
+- جدار حماية يحجب الاتصال / Firewall blocking connection
+
+**الحلول / Solutions:**
+
+#### أ) تشغيل اختبار النظام / Run System Test:
+```bash
+python test_system.py
+```
+
+#### ب) تشغيل الخادم يدوياً / Start Server Manually:
+```bash
+# إيقاف جميع العمليات / Stop all processes
+taskkill /f /im python.exe
+
+# تشغيل الخادم / Start server
+python recorder_server.py
+```
+
+#### ج) استخدام البدء المتقدم / Use Debug Startup:
+```bash
+python start_debug.py
+```
+
+#### د) فحص المنافذ / Check Ports:
+```bash
+# Windows
+netstat -an | findstr :5001
+
+# Linux/Mac
+lsof -i :5001
+```
+
+### 2. مشكلة مفتاح API / API Key Issues
+```
+ERROR: GEMINI_API_KEY not found in environment variables
+```
+
+**الحل / Solution:**
+1. تأكد من وجود ملف `.env`:
+```bash
+# إنشاء ملف .env / Create .env file
+echo GEMINI_API_KEY=your_actual_api_key_here > .env
+```
+
+2. احصل على مفتاح API من:
+   - [Google AI Studio](https://makersuite.google.com/app/apikey)
+
+3. أضف المفتاح إلى `.env`:
+```
+GEMINI_API_KEY=AIzaSyAS7JtrXjlNjyuo3RG5z6rkwocCwFy1YuA
+```
+
+### 3. مشاكل الصوت / Audio Issues
+```
+UserWarning: PySoundFile failed. Trying audioread instead.
+```
+
+**الحلول / Solutions:**
+
+#### أ) تثبيت SoundFile مرة أخرى / Reinstall SoundFile:
+```bash
+pip uninstall soundfile
+pip install soundfile
+```
+
+#### ب) تثبيت FFmpeg (إذا لزم الأمر) / Install FFmpeg if needed:
+```bash
+# Windows (using chocolatey)
+choco install ffmpeg
+
+# Or download from: https://ffmpeg.org/download.html
+```
+
+#### ج) فحص تنسيق الملف / Check Audio Format:
+- استخدم WAV بدلاً من MP3
+- تأكد من جودة التسجيل
+
+### 4. مشاكل الترجمة / Translation Issues
+```
+WARNING: Gemini returned empty translation response
+```
+
+**الحلول / Solutions:**
+
+#### أ) فحص اتصال الإنترنت / Check Internet Connection:
+```bash
+ping google.com
+```
+
+#### ب) اختبار مفتاح API / Test API Key:
+```python
+python test_system.py
+```
+
+#### ج) تغيير النموذج / Change Model:
+- إذا فشل `gemini-2.5-flash`، جرب `gemini-1.5-flash`
+
+### 5. مشاكل الواجهة / UI Issues
+
+#### أ) الواجهة لا تحمّل / Interface Won't Load:
+```bash
+# تحقق من المنفذ / Check port
+python -c "import socket; s=socket.socket(); s.bind(('',8501)); print('Port 8501 available')"
+
+# تشغيل على منفذ مختلف / Run on different port
+streamlit run app.py --server.port 8502
+```
+
+#### ب) مشاكل اللغة العربية / Arabic Language Issues:
+- تأكد من دعم المتصفح للـ RTL
+- استخدم Chrome أو Firefox للأفضل
+
+### 6. مشاكل الأداء / Performance Issues
+
+#### أ) بطء في المعالجة / Slow Processing:
+- تحقق من سرعة الإنترنت
+- قلل حجم الملف الصوتي
+- استخدم جودة أقل للتسجيل
+
+#### ب) استهلاك ذاكرة عالي / High Memory Usage:
+```bash
+# إعادة تشغيل النظام / Restart system
+python start_debug.py
+```
+
+## 🔧 أدوات التشخيص / Diagnostic Tools
+
+### 1. اختبار شامل / Complete Test:
+```bash
+python test_system.py
+```
+
+### 2. فحص المنافذ / Port Check:
+```python
+python -c "
+import socket
+ports = [5001, 8501, 8502]
+for port in ports:
+    try:
+        s = socket.socket()
+        s.bind(('localhost', port))
+        s.close()
+        print(f'Port {port}: Available ✅')
+    except:
+        print(f'Port {port}: Busy ❌')
+"
+```
+
+### 3. فحص التبعيات / Dependencies Check:
+```bash
+pip list | grep -E "(streamlit|flask|librosa|soundfile|google-generativeai)"
+```
+
+### 4. فحص العمليات / Process Check:
+```bash
+# Windows
+tasklist | findstr python
+
+# Linux/Mac
+ps aux | grep python
+```
+
+## 📱 نصائح لحل المشاكل / Troubleshooting Tips
+
+### للطلاب الجدد / For New Users:
+1. **ابدأ بالاختبار الشامل / Start with system test**:
+   ```bash
+   python test_system.py
+   ```
+
+2. **استخدم البدء المتقدم / Use debug startup**:
+   ```bash
+   python start_debug.py
+   ```
+
+3. **تحقق من المتطلبات / Check requirements**:
+   - Python 3.8+
+   - مفتاح Gemini API صالح
+   - اتصال إنترنت مستقر
+
+### للطلاب المتقدمين / For Advanced Users:
+1. **مراجعة السجلات / Check logs**:
+   - افتح console المتصفح (F12)
+   - راجع سجلات الطرفية
+
+2. **تخصيص الإعدادات / Customize settings**:
+   - غير المنافذ في حالة التضارب
+   - عدّل إعدادات الصوت
+
+3. **التشخيص المتقدم / Advanced diagnostics**:
+   ```python
+   # اختبار الاتصال / Test connection
+   import requests
+   response = requests.get('http://localhost:5001/record')
+   print(response.status_code, response.text)
+   ```
+
+## 🆘 طلب المساعدة / Getting Help
+
+### معلومات مطلوبة / Required Information:
+1. نظام التشغيل / Operating System
+2. إصدار Python / Python Version
+3. نتائج `python test_system.py`
+4. رسائل الخطأ الكاملة / Complete error messages
+5. سجلات الطرفية / Terminal logs
+
+### خطوات الإبلاغ / Reporting Steps:
+1. شغّل الاختبار الشامل
+2. احفظ النتائج
+3. صوّر رسائل الخطأ
+4. اذكر الخطوات التي أدت للمشكلة
+
+---
+
+## 🎯 Quick Fix Commands / أوامر الإصلاح السريع
+
+```bash
+# إعادة تعيين كامل / Complete Reset
+taskkill /f /im python.exe
+python test_system.py
+python start_debug.py
+
+# إصلاح التبعيات / Fix Dependencies  
+pip install --upgrade -r requirements.txt
+
+# إصلاح المنافذ / Fix Ports
+python start_debug.py
+
+# اختبار الترجمة / Test Translation
+python -c "from translator import AITranslator; t=AITranslator(); print(t.translate_text('Hello', 'ar'))"
+```
+
+---
+
+**تذكر: معظم المشاكل تُحل بإعادة تشغيل النظام وتشغيل الاختبار الشامل! 🔄**
+
+**Remember: Most issues are solved by restarting and running the system test! 🔄**

ai_questions.py

@@ -0,0 +1,773 @@
+# ai_questions.py - AI-Powered Question Engine for SyncMaster
+
+import time
+import hashlib
+from datetime import datetime
+from typing import Dict, List, Optional, Tuple, Any
+from dataclasses import dataclass, field
+import streamlit as st
+
+@dataclass
+class QAPair:
+    """Represents a question-answer pair"""
+    question: str
+    answer: str
+    timestamp: datetime
+    question_type: str  # 'template' or 'custom'
+    response_time_ms: int
+    model_used: str = "Unknown"  # Which AI model was used
+
+@dataclass
+class QuestionSession:
+    """Represents a question session for a specific text segment"""
+    session_id: str
+    selected_text: str
+    segment_id: str
+    start_timestamp: int
+    ui_language: str
+    conversation: List[QAPair] = field(default_factory=list)
+    created_at: datetime = field(default_factory=datetime.now)
+
+@dataclass
+class TextSelection:
+    """Represents selected text from broadcast"""
+    text: str
+    segment_id: str
+    start_ms: int
+    end_ms: int
+    translations: Dict[str, str] = field(default_factory=dict)
+    selection_timestamp: int = field(default_factory=lambda: int(time.time() * 1000))
+
+class AIQuestionEngine:
+    """
+    AI-powered question engine for interactive learning
+    """
+    
+    def __init__(self, translator_instance=None):
+        self.translator = translator_instance
+        self.conversation_history: Dict[str, QuestionSession] = {}
+        self.model_usage_stats = {
+            'Gemini AI': 0,
+            'Groq AI': 0,
+            'OpenRouter AI': 0,
+            'Simple Response': 0
+        }
+        
+        # Question templates in multiple languages
+        self.question_templates = {
+            'ar': [
+                "اشرح هذا النص بالتفصيل",
+                "أعطني أمثلة عملية على هذا",
+                "ما معنى هذا المصطلح؟",
+                "كيف يُستخدم هذا في الواقع؟",
+                "ما أهمية هذا الموضوع؟",
+                "ما هي النقاط الرئيسية هنا؟",
+                "اربط هذا بمفاهيم أخرى",
+                "ما هي التطبيقات العملية؟"
+            ],
+            'en': [
+                "Explain this text in detail",
+                "Give me practical examples of this",
+                "What does this term mean?",
+                "How is this used in practice?",
+                "Why is this topic important?",
+                "What are the key points here?",
+                "Connect this to other concepts",
+                "What are the practical applications?"
+            ],
+            'fr': [
+                "Expliquez ce texte en détail",
+                "Donnez-moi des exemples pratiques",
+                "Que signifie ce terme?",
+                "Comment cela est-il utilisé en pratique?",
+                "Pourquoi ce sujet est-il important?",
+                "Quels sont les points clés ici?",
+                "Reliez cela à d'autres concepts",
+                "Quelles sont les applications pratiques?"
+            ],
+            'es': [
+                "Explica este texto en detalle",
+                "Dame ejemplos prácticos de esto",
+                "¿Qué significa este término?",
+                "¿Cómo se usa esto en la práctica?",
+                "¿Por qué es importante este tema?",
+                "¿Cuáles son los puntos clave aquí?",
+                "Conecta esto con otros conceptos",
+                "¿Cuáles son las aplicaciones prácticas?"
+            ],
+            'de': [
+                "Erkläre diesen Text im Detail",
+                "Gib mir praktische Beispiele dafür",
+                "Was bedeutet dieser Begriff?",
+                "Wie wird das in der Praxis verwendet?",
+                "Warum ist dieses Thema wichtig?",
+                "Was sind die wichtigsten Punkte hier?",
+                "Verbinde das mit anderen Konzepten",
+                "Was sind die praktischen Anwendungen?"
+            ],
+            'zh': [
+                "详细解释这段文字",
+                "给我一些实际例子",
+                "这个术语是什么意思？",
+                "这在实践中如何使用？",
+                "为什么这个话题很重要？",
+                "这里的要点是什么？",
+                "将此与其他概念联系起来",
+                "实际应用有哪些？"
+            ]
+        }
+        
+        # Response formatting templates
+        self.response_templates = {
+            'ar': {
+                'context_intro': "بناءً على النص المحدد:",
+                'explanation_intro': "الشرح:",
+                'examples_intro': "أمثلة:",
+                'importance_intro': "الأهمية:",
+                'applications_intro': "التطبيقات:",
+                'error_message': "عذراً، حدث خطأ في معالجة سؤالك. يرجى المحاولة مرة أخرى."
+            },
+            'en': {
+                'context_intro': "Based on the selected text:",
+                'explanation_intro': "Explanation:",
+                'examples_intro': "Examples:",
+                'importance_intro': "Importance:",
+                'applications_intro': "Applications:",
+                'error_message': "Sorry, there was an error processing your question. Please try again."
+            }
+        }
+    
+    def get_question_templates(self, ui_language: str = 'ar') -> List[str]:
+        """Get pre-defined question templates for the specified language"""
+        return self.question_templates.get(ui_language, self.question_templates['ar'])
+    
+    def create_session_id(self, selected_text: str, segment_id: str) -> str:
+        """Create a unique session ID for a text selection"""
+        content = f"{selected_text}_{segment_id}_{int(time.time())}"
+        return hashlib.md5(content.encode()).hexdigest()[:12]
+    
+    def process_question(self, 
+                        selected_text: str, 
+                        question: str, 
+                        segment_info: Dict[str, Any],
+                        ui_language: str = 'ar',
+                        session_id: Optional[str] = None,
+                        preferred_model: str = 'auto') -> Tuple[Optional[str], Optional[str], str]:
+        """
+        Process a user question about selected text
+        
+        Args:
+            selected_text: The text the user selected
+            question: The user's question
+            segment_info: Information about the broadcast segment
+            ui_language: UI language ('ar' or 'en')
+            session_id: Existing session ID or None for new session
+            
+        Returns:
+            Tuple of (answer, error_message, session_id)
+        """
+        
+        if not self.translator:
+            error_msg = self.response_templates[ui_language]['error_message']
+            return None, error_msg, session_id or ""
+        
+        try:
+            # Create or get session
+            if not session_id:
+                session_id = self.create_session_id(selected_text, segment_info.get('id', ''))
+                session = QuestionSession(
+                    session_id=session_id,
+                    selected_text=selected_text,
+                    segment_id=segment_info.get('id', ''),
+                    start_timestamp=segment_info.get('start_ms', 0),
+                    ui_language=ui_language
+                )
+                self.conversation_history[session_id] = session
+            else:
+                session = self.conversation_history.get(session_id)
+                if not session:
+                    # Session not found, create new one
+                    session = QuestionSession(
+                        session_id=session_id,
+                        selected_text=selected_text,
+                        segment_id=segment_info.get('id', ''),
+                        start_timestamp=segment_info.get('start_ms', 0),
+                        ui_language=ui_language
+                    )
+                    self.conversation_history[session_id] = session
+            
+            # Prepare context for AI
+            context = self._prepare_question_context(selected_text, question, session, ui_language)
+            
+            # Get AI response with preferred model
+            start_time = time.time()
+            ai_response, error, model_used = self.get_ai_response_with_model(context, ui_language, preferred_model)
+            response_time = int((time.time() - start_time) * 1000)
+            
+            if ai_response:
+                # Format response
+                formatted_response = self.format_ai_response(ai_response, ui_language)
+                
+                # Save to conversation history with model info
+                question_type = 'template' if question in self.get_question_templates(ui_language) else 'custom'
+                qa_pair = QAPair(
+                    question=question,
+                    answer=formatted_response,
+                    timestamp=datetime.now(),
+                    question_type=question_type,
+                    response_time_ms=response_time
+                )
+                # Add model info to the QA pair
+                qa_pair.model_used = model_used
+                session.conversation.append(qa_pair)
+                
+                return formatted_response, None, session_id, model_used
+            else:
+                error_msg = error or self.response_templates[ui_language]['error_message']
+                return None, error_msg, session_id, None
+                
+        except Exception as e:
+            error_msg = f"{self.response_templates[ui_language]['error_message']} ({str(e)})"
+            return None, error_msg, session_id or ""
+    
+    def _prepare_question_context(self, 
+                                 selected_text: str, 
+                                 question: str, 
+                                 session: QuestionSession,
+                                 ui_language: str) -> str:
+        """Prepare context for AI question processing"""
+        
+        templates = self.response_templates[ui_language]
+        
+        # Build context with conversation history
+        context_parts = []
+        
+        # Add selected text context
+        context_parts.append(f"{templates['context_intro']}")
+        context_parts.append(f'"{selected_text}"')
+        context_parts.append("")
+        
+        # Add conversation history if exists
+        if session.conversation:
+            context_parts.append("Previous conversation:")
+            for qa in session.conversation[-3:]:  # Last 3 Q&A pairs for context
+                context_parts.append(f"Q: {qa.question}")
+                context_parts.append(f"A: {qa.answer[:200]}...")  # Truncate long answers
+                context_parts.append("")
+        
+        # Add current question
+        context_parts.append(f"Current question: {question}")
+        context_parts.append("")
+        
+        # Add instructions based on language
+        language_instructions = {
+            'ar': """
+أجب على السؤال بناءً على النص المحدد. اجعل إجابتك:
+- واضحة ومفهومة
+- مرتبطة بالنص المحدد
+- تحتوي على أمثلة عملية إذا كان ذلك مناسباً
+- باللغة العربية الفصحى
+- منظمة ومنسقة بشكل جيد
+
+إذا كان السؤال يطلب شرحاً، قدم شرحاً مفصلاً.
+إذا كان يطلب أمثلة، قدم أمثلة واقعية ومفيدة.
+إذا كان يطلب التوضيح، اشرح المفاهيم بطريقة بسيطة.
+""",
+            'en': """
+Answer the question based on the selected text. Make your answer:
+- Clear and understandable
+- Related to the selected text
+- Include practical examples when appropriate
+- In English
+- Well-organized and formatted
+
+If the question asks for explanation, provide detailed explanation.
+If it asks for examples, provide real-world, helpful examples.
+If it asks for clarification, explain concepts in simple terms.
+""",
+            'fr': """
+Répondez à la question basée sur le texte sélectionné. Rendez votre réponse:
+- Claire et compréhensible
+- Liée au texte sélectionné
+- Incluez des exemples pratiques si approprié
+- En français
+- Bien organisée et formatée
+
+Si la question demande une explication, fournissez une explication détaillée.
+Si elle demande des exemples, fournissez des exemples réels et utiles.
+Si elle demande des clarifications, expliquez les concepts en termes simples.
+""",
+            'es': """
+Responde la pregunta basada en el texto seleccionado. Haz que tu respuesta sea:
+- Clara y comprensible
+- Relacionada con el texto seleccionado
+- Incluye ejemplos prácticos cuando sea apropiado
+- En español
+- Bien organizada y formateada
+
+Si la pregunta pide explicación, proporciona explicación detallada.
+Si pide ejemplos, proporciona ejemplos reales y útiles.
+Si pide aclaración, explica conceptos en términos simples.
+""",
+            'de': """
+Beantworte die Frage basierend auf dem ausgewählten Text. Mache deine Antwort:
+- Klar und verständlich
+- Bezogen auf den ausgewählten Text
+- Enthalte praktische Beispiele wenn angemessen
+- Auf Deutsch
+- Gut organisiert und formatiert
+
+Wenn die Frage nach Erklärung fragt, gib detaillierte Erklärung.
+Wenn sie nach Beispielen fragt, gib reale und hilfreiche Beispiele.
+Wenn sie nach Klarstellung fragt, erkläre Konzepte in einfachen Begriffen.
+""",
+            'zh': """
+根据选定的文本回答问题。让你的回答：
+- 清晰易懂
+- 与选定文本相关
+- 适当时包含实际例子
+- 用中文
+- 组织良好且格式化
+
+如果问题要求解释，提供详细解释。
+如果要求例子，提供真实有用的例子。
+如果要求澄清，用简单术语解释概念。
+"""
+        }
+        
+        instructions = language_instructions.get(ui_language, language_instructions['en'])
+        
+        context_parts.append(instructions)
+        
+        return "\n".join(context_parts)
+    
+    def _get_ai_response(self, context: str, ui_language: str) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+        """Get AI response using multiple AI services with fallback
+        
+        Returns:
+            Tuple of (response_text, error_message, model_used)
+        """
+        
+        # Model 1: Try Gemini first
+        try:
+            if hasattr(self.translator, 'model') and self.translator.model:
+                response = self.translator.model.generate_content(context)
+                if response and hasattr(response, 'text') and response.text:
+                    self.model_usage_stats['Gemini AI'] += 1
+                    return response.text.strip(), None, "Gemini AI"
+        except Exception as e:
+            error_msg = str(e)
+            print(f"Gemini AI failed: {error_msg}")  # Debug log
+            # Continue to next model instead of returning error immediately
+        
+        # Model 2: Try Groq
+        try:
+            if hasattr(self.translator, '_groq_complete'):
+                response, error = self.translator._groq_complete(context)
+                if response and response.strip():
+                    self.model_usage_stats['Groq AI'] += 1
+                    return response.strip(), None, "Groq AI"
+                print(f"Groq failed: {error}")  # Debug log
+        except Exception as e:
+            print(f"Groq exception: {str(e)}")  # Debug log
+        
+        # Model 3: Try OpenRouter
+        try:
+            if hasattr(self.translator, '_openrouter_complete'):
+                response, error = self.translator._openrouter_complete(context)
+                if response and response.strip():
+                    self.model_usage_stats['OpenRouter AI'] += 1
+                    return response.strip(), None, "OpenRouter AI"
+                print(f"OpenRouter failed: {error}")  # Debug log
+        except Exception as e:
+            print(f"OpenRouter exception: {str(e)}")  # Debug log
+        
+        # Fallback: Simple rule-based response
+        simple_response, _ = self._generate_simple_response(context, ui_language)
+        self.model_usage_stats['Simple Response'] += 1
+        return simple_response, None, "Simple Response (AI services unavailable)"
+    
+    def _try_fallback_services(self, context: str, ui_language: str) -> Tuple[Optional[str], Optional[str]]:
+        """Try fallback AI services when Gemini is unavailable"""
+        
+        # Try OpenRouter (free models)
+        if hasattr(self.translator, '_openrouter_complete'):
+            try:
+                response, error = self.translator._openrouter_complete(context)
+                if response:
+                    return response.strip(), None
+            except Exception:
+                pass
+        
+        # Try Groq (free tier)
+        if hasattr(self.translator, '_groq_complete'):
+            try:
+                response, error = self.translator._groq_complete(context)
+                if response:
+                    return response.strip(), None
+            except Exception:
+                pass
+        
+        # Fallback to simple rule-based responses
+        return self._generate_simple_response(context, ui_language)
+    
+    def _generate_simple_response(self, context: str, ui_language: str) -> Tuple[Optional[str], Optional[str]]:
+        """Generate simple rule-based response when AI services are unavailable"""
+        
+        # Extract the question from context
+        lines = context.split('\n')
+        question = ""
+        selected_text = ""
+        
+        for line in lines:
+            if line.startswith('Current question:'):
+                question = line.replace('Current question:', '').strip()
+            elif line.startswith('"') and line.endswith('"'):
+                selected_text = line.strip('"')
+        
+        if not question or not selected_text:
+            return None, "Could not process question"
+        
+        # Simple rule-based responses
+        if ui_language == 'ar':
+            responses = self._get_arabic_simple_responses(question, selected_text)
+        else:
+            responses = self._get_english_simple_responses(question, selected_text)
+        
+        return responses
+    
+    def _get_arabic_simple_responses(self, question: str, selected_text: str) -> Tuple[str, None]:
+        """Generate simple Arabic responses based on question patterns"""
+        
+        question_lower = question.lower()
+        
+        if any(word in question_lower for word in ['اشرح', 'شرح', 'وضح']):
+            response = f"""بناءً على النص المحدد:
+"{selected_text}"
+
+هذا النص يتحدث عن موضوع مهم يحتاج إلى فهم عميق. النقاط الرئيسية تشمل المفاهيم والأفكار المطروحة في النص.
+
+للحصول على شرح أكثر تفصيلاً، يُنصح بمراجعة مصادر إضافية أو طرح أسئلة أكثر تحديداً.
+
+ملاحظة: هذه إجابة مبسطة بسبب عدم توفر خدمة الذكاء الاصطناعي حالياً."""
+
+        elif any(word in question_lower for word in ['أمثلة', 'مثال', 'تطبيق']):
+            response = f"""أمثلة على النص المحدد:
+"{selected_text}"
+
+يمكن تطبيق هذا المفهوم في عدة مجالات:
+• في الحياة العملية
+• في الدراسة والتعلم
+• في المشاريع والأعمال
+
+للحصول على أمثلة أكثر تفصيلاً، يُنصح بالبحث في مصادر متخصصة.
+
+ملاحظة: هذه إجابة مبسطة بسبب عدم توفر خدمة الذكاء الاصطناعي حالياً."""
+
+        elif any(word in question_lower for word in ['معنى', 'تعريف', 'ما هو']):
+            response = f"""معنى النص المحدد:
+"{selected_text}"
+
+هذا النص يشير إلى مفهوم أو فكرة معينة تحتاج إلى تفسير. المعنى العام يتعلق بالموضوع المطروح في السياق.
+
+للحصول على تعريف أكثر دقة، يُنصح بمراجعة المصادر المتخصصة.
+
+ملاحظة: هذه إجابة مبسطة بسبب عدم توفر خدمة الذكاء الاصطناعي حالياً."""
+
+        else:
+            response = f"""بخصوص سؤالك حول:
+"{selected_text}"
+
+هذا موضوع مهم يستحق الدراسة والتفكير. النص المحدد يحتوي على معلومات قيمة يمكن الاستفادة منها.
+
+للحصول على إجابة أكثر تفصيلاً، يُنصح بـ:
+• مراجعة مصادر إضافية
+• طرح أسئلة أكثر تحديداً
+• البحث في المراجع المتخصصة
+
+ملاحظة: هذه إجابة مبسطة بسبب عدم توفر خدمة الذكاء الاصطناعي حالياً."""
+
+        return response, None
+    
+    def _get_english_simple_responses(self, question: str, selected_text: str) -> Tuple[str, None]:
+        """Generate simple English responses based on question patterns"""
+        
+        question_lower = question.lower()
+        
+        if any(word in question_lower for word in ['explain', 'clarify', 'describe']):
+            response = f"""Based on the selected text:
+"{selected_text}"
+
+This text discusses an important topic that requires deep understanding. The main points include the concepts and ideas presented in the text.
+
+For a more detailed explanation, it's recommended to consult additional sources or ask more specific questions.
+
+Note: This is a simplified response due to AI service being temporarily unavailable."""
+
+        elif any(word in question_lower for word in ['example', 'application', 'use']):
+            response = f"""Examples related to the selected text:
+"{selected_text}"
+
+This concept can be applied in several areas:
+• In practical life
+• In study and learning
+• In projects and work
+
+For more detailed examples, it's recommended to search specialized sources.
+
+Note: This is a simplified response due to AI service being temporarily unavailable."""
+
+        elif any(word in question_lower for word in ['mean', 'definition', 'what is']):
+            response = f"""Meaning of the selected text:
+"{selected_text}"
+
+This text refers to a specific concept or idea that needs interpretation. The general meaning relates to the topic presented in the context.
+
+For a more precise definition, it's recommended to consult specialized sources.
+
+Note: This is a simplified response due to AI service being temporarily unavailable."""
+
+        else:
+            response = f"""Regarding your question about:
+"{selected_text}"
+
+This is an important topic worth studying and thinking about. The selected text contains valuable information that can be beneficial.
+
+For a more detailed answer, it's recommended to:
+• Consult additional sources
+• Ask more specific questions
+• Search specialized references
+
+Note: This is a simplified response due to AI service being temporarily unavailable."""
+
+        return response, None
+    
+    def format_ai_response(self, response: str, ui_language: str) -> str:
+        """Format AI response for better display"""
+        
+        # Clean up response
+        response = response.strip()
+        
+        # Remove markdown artifacts
+        response = response.replace('**', '')
+        response = response.replace('```', '')
+        response = response.replace('`', '')
+        
+        # Remove extra whitespace
+        lines = [line.strip() for line in response.split('\n')]
+        response = '\n'.join(line for line in lines if line)
+        
+        return response
+    
+    def get_conversation_history(self, session_id: str) -> Optional[QuestionSession]:
+        """Get conversation history for a specific session"""
+        return self.conversation_history.get(session_id)
+    
+    def clear_conversation(self, session_id: str) -> bool:
+        """Clear conversation history for a specific session"""
+        if session_id in self.conversation_history:
+            del self.conversation_history[session_id]
+            return True
+        return False
+    
+    def get_all_sessions(self) -> Dict[str, QuestionSession]:
+        """Get all active question sessions"""
+        return self.conversation_history.copy()
+    
+    def get_model_usage_stats(self) -> Dict[str, int]:
+        """Get usage statistics for different AI models"""
+        return self.model_usage_stats.copy()
+    
+    def check_model_availability(self) -> Dict[str, Dict[str, Any]]:
+        """Check availability status of all AI models"""
+        models_status = {}
+        
+        # Check Gemini
+        try:
+            if hasattr(self.translator, 'model') and self.translator.model:
+                # Try a minimal test
+                test_response = self.translator.model.generate_content("Hi")
+                models_status['Gemini AI'] = {
+                    'status': 'available',
+                    'icon': '✅',
+                    'message': 'متاح' if st.session_state.get('language', 'ar') == 'ar' else 'Available',
+                    'color': 'green'
+                }
+            else:
+                models_status['Gemini AI'] = {
+                    'status': 'unavailable',
+                    'icon': '❌',
+                    'message': 'غير متاح' if st.session_state.get('language', 'ar') == 'ar' else 'Unavailable',
+                    'color': 'red'
+                }
+        except Exception as e:
+            error_str = str(e)
+            if "429" in error_str or "quota" in error_str.lower():
+                models_status['Gemini AI'] = {
+                    'status': 'quota_exceeded',
+                    'icon': '⚠️',
+                    'message': 'انتهت الحصة' if st.session_state.get('language', 'ar') == 'ar' else 'Quota exceeded',
+                    'color': 'orange'
+                }
+            else:
+                models_status['Gemini AI'] = {
+                    'status': 'error',
+                    'icon': '❌',
+                    'message': 'خطأ مؤقت' if st.session_state.get('language', 'ar') == 'ar' else 'Temporary error',
+                    'color': 'red'
+                }
+        
+        # Check Groq
+        try:
+            if hasattr(self.translator, '_groq_complete') and hasattr(self.translator, 'groq_api_key') and self.translator.groq_api_key:
+                models_status['Groq AI'] = {
+                    'status': 'available',
+                    'icon': '✅',
+                    'message': 'متاح' if st.session_state.get('language', 'ar') == 'ar' else 'Available',
+                    'color': 'green'
+                }
+            else:
+                models_status['Groq AI'] = {
+                    'status': 'not_configured',
+                    'icon': '⚙️',
+                    'message': 'غير مُعد' if st.session_state.get('language', 'ar') == 'ar' else 'Not configured',
+                    'color': 'gray'
+                }
+        except Exception:
+            models_status['Groq AI'] = {
+                'status': 'error',
+                'icon': '❌',
+                'message': 'خطأ' if st.session_state.get('language', 'ar') == 'ar' else 'Error',
+                'color': 'red'
+            }
+        
+        # Check OpenRouter
+        try:
+            if hasattr(self.translator, '_openrouter_complete') and hasattr(self.translator, 'openrouter_api_key') and self.translator.openrouter_api_key:
+                models_status['OpenRouter AI'] = {
+                    'status': 'available',
+                    'icon': '✅',
+                    'message': 'متاح' if st.session_state.get('language', 'ar') == 'ar' else 'Available',
+                    'color': 'green'
+                }
+            else:
+                models_status['OpenRouter AI'] = {
+                    'status': 'not_configured',
+                    'icon': '⚙️',
+                    'message': 'غير مُعد' if st.session_state.get('language', 'ar') == 'ar' else 'Not configured',
+                    'color': 'gray'
+                }
+        except Exception:
+            models_status['OpenRouter AI'] = {
+                'status': 'error',
+                'icon': '❌',
+                'message': 'خطأ' if st.session_state.get('language', 'ar') == 'ar' else 'Error',
+                'color': 'red'
+            }
+        
+        # Simple Response is always available
+        models_status['Simple Response'] = {
+            'status': 'available',
+            'icon': '🛡️',
+            'message': 'متاح دائماً' if st.session_state.get('language', 'ar') == 'ar' else 'Always available',
+            'color': 'blue'
+        }
+        
+        return models_status
+    
+    def get_ai_response_with_model(self, context: str, ui_language: str, preferred_model: str = 'auto') -> Tuple[Optional[str], Optional[str], Optional[str]]:
+        """Get AI response using a specific model or auto-selection"""
+        
+        if preferred_model == 'auto':
+            return self._get_ai_response(context, ui_language)
+        
+        # Try specific model first
+        if preferred_model == 'Gemini AI':
+            try:
+                if hasattr(self.translator, 'model') and self.translator.model:
+                    response = self.translator.model.generate_content(context)
+                    if response and hasattr(response, 'text') and response.text:
+                        self.model_usage_stats['Gemini AI'] += 1
+                        return response.text.strip(), None, "Gemini AI"
+            except Exception as e:
+                return None, f"Gemini AI error: {str(e)}", None
+        
+        elif preferred_model == 'Groq AI':
+            try:
+                if hasattr(self.translator, '_groq_complete'):
+                    response, error = self.translator._groq_complete(context)
+                    if response and response.strip():
+                        self.model_usage_stats['Groq AI'] += 1
+                        return response.strip(), None, "Groq AI"
+                    else:
+                        return None, f"Groq AI error: {error}", None
+            except Exception as e:
+                return None, f"Groq AI error: {str(e)}", None
+        
+        elif preferred_model == 'OpenRouter AI':
+            try:
+                if hasattr(self.translator, '_openrouter_complete'):
+                    response, error = self.translator._openrouter_complete(context)
+                    if response and response.strip():
+                        self.model_usage_stats['OpenRouter AI'] += 1
+                        return response.strip(), None, "OpenRouter AI"
+                    else:
+                        return None, f"OpenRouter AI error: {error}", None
+            except Exception as e:
+                return None, f"OpenRouter AI error: {str(e)}", None
+        
+        elif preferred_model == 'Simple Response':
+            simple_response, _ = self._generate_simple_response(context, ui_language)
+            self.model_usage_stats['Simple Response'] += 1
+            return simple_response, None, "Simple Response"
+        
+        # If preferred model fails, fall back to auto-selection
+        return self._get_ai_response(context, ui_language)
+    
+    def format_conversation_for_export(self, session_id: str, ui_language: str = 'ar') -> Optional[str]:
+        """Format conversation for export/copying"""
+        
+        session = self.conversation_history.get(session_id)
+        if not session:
+            return None
+        
+        export_lines = []
+        
+        # Header
+        if ui_language == 'ar':
+            export_lines.append("محادثة الذكاء الاصطناعي")
+            export_lines.append(f"النص المحدد: {session.selected_text}")
+            export_lines.append(f"التاريخ: {session.created_at.strftime('%Y-%m-%d %H:%M:%S')}")
+        else:
+            export_lines.append("AI Conversation")
+            export_lines.append(f"Selected Text: {session.selected_text}")
+            export_lines.append(f"Date: {session.created_at.strftime('%Y-%m-%d %H:%M:%S')}")
+        
+        export_lines.append("=" * 50)
+        export_lines.append("")
+        
+        # Q&A pairs
+        for i, qa in enumerate(session.conversation, 1):
+            if ui_language == 'ar':
+                export_lines.append(f"السؤال {i}: {qa.question}")
+                export_lines.append(f"الإجابة {i}: {qa.answer}")
+            else:
+                export_lines.append(f"Question {i}: {qa.question}")
+                export_lines.append(f"Answer {i}: {qa.answer}")
+            
+            export_lines.append("-" * 30)
+            export_lines.append("")
+        
+        return "\n".join(export_lines)
+
+# Global instance
+ai_question_engine = None
+
+def get_ai_question_engine():
+    """Get or create AI question engine instance"""
+    global ai_question_engine
+    if ai_question_engine is None:
+        from translator import get_translator
+        translator = get_translator()
+        ai_question_engine = AIQuestionEngine(translator)
+    return ai_question_engine

app.py

@@ -0,0 +1,1812 @@
+# app.py - Refactored to eliminate recorder_server.py dependency
+
+import streamlit as st
+import os
+import tempfile
+import json
+from pathlib import Path
+import time
+import traceback
+import streamlit.components.v1 as components
+import hashlib
+from datetime import datetime
+# from st_audiorec import st_audiorec  # Import the new recorder component - OLD
+# Reduce metrics/usage writes that can cause permission errors on hosted environments
+try:
+    st.set_option('browser.gatherUsageStats', False)
+except Exception:
+    pass
+
+# Robust component declaration: prefer local build, else fall back to pip package
+parent_dir = os.path.dirname(os.path.abspath(__file__))
+build_dir = os.path.join(parent_dir, "custom_components/st-audiorec/st_audiorec/frontend/build")
+
+def st_audiorec(key=None):
+    """Return audio recorder component value, trying local build first, then pip package fallback."""
+    try:
+        if os.path.isdir(build_dir):
+            _component_func = components.declare_component("st_audiorec", path=build_dir)
+            return _component_func(key=key, default=0)
+        # Fallback to pip-installed component if available
+        try:
+            from st_audiorec import st_audiorec as st_audiorec_pkg
+            return st_audiorec_pkg(key=key)
+        except Exception:
+            st.warning("Audio recorder component is unavailable on this deployment (missing local build and pip fallback).")
+            return None
+    except Exception:
+        # Final safety net
+        st.warning("Failed to initialize audio recorder component.")
+        return None
+
+# --- Critical Imports and Initial Checks ---
+AUDIO_PROCESSOR_CLASS = None
+IMPORT_ERROR_TRACEBACK = None
+try:
+    from audio_processor import AudioProcessor
+    AUDIO_PROCESSOR_CLASS = AudioProcessor
+except Exception:
+    IMPORT_ERROR_TRACEBACK = traceback.format_exc()
+
+from video_generator import VideoGenerator
+from mp3_embedder import MP3Embedder
+from utils import format_timestamp
+from translator import get_translator, UI_TRANSLATIONS
+from exporter import BroadcastExporter, ExportConfig
+from google_docs_config import google_docs_manager
+from ai_questions import get_ai_question_engine, TextSelection
+from style_fixes import apply_custom_styling, create_broadcast_bubble, create_white_container, create_processing_result_container
+import requests
+from dotenv import load_dotenv
+
+# --- API Key Check ---
+def check_api_key():
+    """Check for Gemini API key and display instructions if not found."""
+    load_dotenv()
+    if not os.getenv("GEMINI_API_KEY"):
+        st.error("🔴 FATAL ERROR: GEMINI_API_KEY is not set!")
+        st.info("To fix this, please follow these steps:")
+        st.markdown("""
+            1.  **Find the file named `.env.example`** in the `syncmaster2` directory.
+            2.  **Rename it to `.env`**.
+            3.  **Open the `.env` file** with a text editor.
+            4.  **Get your free API key** from [Google AI Studio](https://aistudio.google.com/app/apikey).
+            5.  **Paste your key** into the file, replacing `"PASTE_YOUR_GEMINI_API_KEY_HERE"`.
+            6.  **Save the file and restart the application.**
+        """)
+        return False
+    return True
+
+# --- Summary Helper (robust to cached translator without summarize_text) ---
+def generate_summary(text: str, target_language: str = 'ar'):
+    """Generate a concise summary in target_language, with graceful fallback.
+
+    If summarize_text is unavailable (cached instance), fall back to Arabic summary
+    then translate to the target language if needed.
+    """
+    tr = get_translator()
+    try:
+        if hasattr(tr, 'summarize_text') and callable(getattr(tr, 'summarize_text')):
+            s, err = tr.summarize_text(text or '', target_language=target_language)
+            if s:
+                return s, None
+        # Fallback path: Arabic summary first
+        s_ar, err_ar = tr.summarize_text_arabic(text or '')
+        if target_language and target_language != 'ar' and s_ar:
+            tx, err_tx = tr.translate_text(s_ar, target_language=target_language)
+            if tx:
+                return tx, None
+            return s_ar, err_tx
+        return s_ar, err_ar
+    except Exception as e:
+        return None, str(e)
+
+# --- Page Configuration ---
+st.set_page_config(
+    page_title="SyncMaster - AI Audio-Text Synchronization",
+    page_icon="🎵",
+    layout="wide"
+)
+
+# --- Browser Console Logging Utility ---
+def log_to_browser_console(messages):
+    """Injects JavaScript to log messages to the browser's console."""
+    if isinstance(messages, str):
+        messages = [messages]
+    escaped_messages = [json.dumps(str(msg)) for msg in messages]
+    js_code = f"""
+    <script>
+    (function() {{
+        const logs = [{', '.join(escaped_messages)}];
+        console.group("Backend Logs from SyncMaster");
+        logs.forEach(log => {{
+            const content = String(log);
+            if (content.includes('--- ERROR') || content.includes('--- FATAL')) {{
+                console.error(log);
+            }} else if (content.includes('--- WARNING')) {{
+                console.warn(log);
+            }} else if (content.includes('--- DEBUG')) {{
+                console.debug(log);
+            }} else {{
+                console.log(log);
+            }}
+        }});
+        console.groupEnd();
+    }})();
+    </script>
+    """
+    components.html(js_code, height=0, scrolling=False)
+
+# --- AI Models Reset Function ---
+def reset_ai_models():
+    """Reset all AI models and clear cache completely"""
+    
+    # Clear ALL session state keys that might contain cached AI instances
+    keys_to_clear = []
+    for key in list(st.session_state.keys()):
+        if any(term in key.lower() for term in ['translator', 'ai', 'question', 'model', 'engine', 'processing']):
+            keys_to_clear.append(key)
+    
+    for key in keys_to_clear:
+        del st.session_state[key]
+    
+    # Force reload environment variables
+    load_dotenv(override=True)
+    
+    # Clear Python module cache completely
+    import sys
+    import importlib
+    
+    modules_to_reload = ['translator', 'ai_questions', 'exporter']
+    for module_name in modules_to_reload:
+        if module_name in sys.modules:
+            try:
+                # Delete from sys.modules first
+                del sys.modules[module_name]
+            except:
+                pass
+    
+    # Clear any global instances
+    try:
+        import translator
+        if hasattr(translator, 'translator_instance'):
+            translator.translator_instance = None
+    except:
+        pass
+    
+    try:
+        import ai_questions
+        if hasattr(ai_questions, 'ai_question_engine'):
+            ai_questions.ai_question_engine = None
+    except:
+        pass
+
+# --- Session State Initialization ---
+def initialize_session_state():
+    """Initializes the session state variables if they don't exist."""
+    if 'step' not in st.session_state:
+        st.session_state.step = 1
+    if 'audio_data' not in st.session_state:
+        st.session_state.audio_data = None
+    if 'language' not in st.session_state:
+        st.session_state.language = 'en'
+    if 'enable_translation' not in st.session_state:
+        st.session_state.enable_translation = True
+    if 'target_language' not in st.session_state:
+        st.session_state.target_language = 'ar'
+    if 'transcription_data' not in st.session_state:
+        st.session_state.transcription_data = None
+    if 'edited_text' not in st.session_state:
+        st.session_state.edited_text = ""
+    if 'video_style' not in st.session_state:
+        st.session_state.video_style = {
+            'animation_style': 'Karaoke Style', 'text_color': '#FFFFFF',
+            'highlight_color': '#FFD700', 'background_color': '#000000',
+            'font_family': 'Arial', 'font_size': 48
+        }
+    if 'new_recording' not in st.session_state:
+        st.session_state.new_recording = None
+    # Transcript feed (prepend latest) and dedupe set
+    if 'transcript_feed' not in st.session_state:
+        st.session_state.transcript_feed = []  # list of {id, ts, text}
+    if 'transcript_ids' not in st.session_state:
+        st.session_state.transcript_ids = set()
+    # Incremental broadcast state
+    if 'broadcast_segments' not in st.session_state:
+        st.session_state.broadcast_segments = []  # [{id, recording_id, start_ms, end_ms, checksum, text}]
+    if 'lastFetchedEnd_ms' not in st.session_state:
+        st.session_state.lastFetchedEnd_ms = 0
+    # Broadcast translation language (separate from general UI translation target)
+    if 'broadcast_translation_lang' not in st.session_state:
+        # Default broadcast translation target to Arabic
+        st.session_state.broadcast_translation_lang = 'ar'
+    if 'summary_language' not in st.session_state:
+        # Default summary language to Arabic
+        st.session_state.summary_language = 'ar'
+    # Auto-generate Arabic summary toggle
+    if 'auto_generate_summary' not in st.session_state:
+        st.session_state.auto_generate_summary = True
+    # Export functionality state
+    if 'export_timestamp' not in st.session_state:
+        st.session_state.export_timestamp = None
+    if 'show_export_modal' not in st.session_state:
+        st.session_state.show_export_modal = False
+    if 'export_format' not in st.session_state:
+        st.session_state.export_format = 'word'
+    # AI Questions functionality state
+    if 'selected_text' not in st.session_state:
+        st.session_state.selected_text = None
+    if 'selected_segment_id' not in st.session_state:
+        st.session_state.selected_segment_id = None
+    if 'show_question_modal' not in st.session_state:
+        st.session_state.show_question_modal = False
+    if 'current_question_session' not in st.session_state:
+        st.session_state.current_question_session = None
+    if 'preferred_ai_model' not in st.session_state:
+        st.session_state.preferred_ai_model = 'auto'
+    if 'preferred_answer_language' not in st.session_state:
+        st.session_state.preferred_answer_language = 'auto'
+    # Background processing state
+    if 'processing_queue' not in st.session_state:
+        st.session_state.processing_queue = []
+    if 'processing_results' not in st.session_state:
+        st.session_state.processing_results = {}
+    if 'processing_status' not in st.session_state:
+        st.session_state.processing_status = {}
+
+# --- Background Audio Processing Function ---
+def queue_audio_processing(audio_bytes, original_filename="recorded_audio.wav"):
+    """Queue audio for background processing"""
+    import uuid
+    
+    # Generate unique ID for this processing task
+    task_id = str(uuid.uuid4())[:8]
+    
+    # Add to processing queue
+    task = {
+        'id': task_id,
+        'audio_bytes': audio_bytes,
+        'filename': original_filename,
+        'timestamp': time.time(),
+        'status': 'queued'
+    }
+    
+    st.session_state.processing_queue.append(task)
+    st.session_state.processing_status[task_id] = 'queued'
+    
+    # Show immediate feedback
+    st.info(f"🔄 {'تم إضافة التسجيل للمعالجة' if st.session_state.language == 'ar' else 'Audio queued for processing'} (ID: {task_id})")
+    
+    return task_id
+
+def process_queued_audio():
+    """Process queued audio in background"""
+    if not st.session_state.processing_queue:
+        return
+    
+    # Process first item in queue
+    task = st.session_state.processing_queue[0]
+    task_id = task['id']
+    
+    # Update status
+    st.session_state.processing_status[task_id] = 'processing'
+    task['status'] = 'processing'
+    
+    # Show processing status
+    with st.status(f"🔄 {'معالجة التسجيل' if st.session_state.language == 'ar' else 'Processing audio'} {task_id}...", expanded=False):
+        try:
+            # Process the audio
+            result = run_audio_processing_sync(task['audio_bytes'], task['filename'])
+            
+            if result:
+                # Store result
+                st.session_state.processing_results[task_id] = result
+                st.session_state.processing_status[task_id] = 'completed'
+                task['status'] = 'completed'
+                
+                st.success(f"✅ {'تم الانتهاء من المعالجة' if st.session_state.language == 'ar' else 'Processing completed'} {task_id}")
+            else:
+                st.session_state.processing_status[task_id] = 'failed'
+                task['status'] = 'failed'
+                st.error(f"❌ {'فشلت المعالجة' if st.session_state.language == 'ar' else 'Processing failed'} {task_id}")
+        
+        except Exception as e:
+            st.session_state.processing_status[task_id] = 'failed'
+            task['status'] = 'failed'
+            st.error(f"❌ {'خطأ في المعالجة' if st.session_state.language == 'ar' else 'Processing error'} {task_id}: {str(e)}")
+    
+    # Remove from queue
+    st.session_state.processing_queue.pop(0)
+
+# --- Centralized Audio Processing Function ---
+def run_audio_processing(audio_bytes, original_filename="recorded_audio.wav"):
+    """Main audio processing function with background support"""
+    
+    # Check if background processing is enabled
+    if st.session_state.get('background_processing', True):
+        return queue_audio_processing(audio_bytes, original_filename)
+    else:
+        return run_audio_processing_sync(audio_bytes, original_filename)
+
+def run_audio_processing_sync(audio_bytes, original_filename="recorded_audio.wav"):
+    """
+    A single, robust function to handle all audio processing.
+    Takes audio bytes as input and returns the processed data.
+    """
+    # This function is the classic, non-Custom path; ensure editor sections are enabled
+    st.session_state['_custom_active'] = False
+    if not audio_bytes:
+        st.error("No audio data provided to process.")
+        return
+
+    tmp_file_path = None
+    log_to_browser_console("--- INFO: Starting unified audio processing. ---")
+    
+    try:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=Path(original_filename).suffix) as tmp_file:
+            tmp_file.write(audio_bytes)
+            tmp_file_path = tmp_file.name
+        
+        processor = AUDIO_PROCESSOR_CLASS()
+        result_data = None
+        full_text = ""
+        word_timestamps = []
+
+        # Determine which processing path to take
+        if st.session_state.enable_translation:
+            with st.spinner("⏳ Performing AI Transcription & Translation... please wait."):
+                result_data, processor_logs = processor.get_word_timestamps_with_translation(
+                    tmp_file_path,
+                    st.session_state.target_language,
+                )
+
+            log_to_browser_console(processor_logs)
+
+            if not result_data or not result_data.get("original_text"):
+                st.warning(
+                    "Could not generate transcription with translation. Check browser console (F12) for logs."
+                )
+                return
+
+            st.session_state.transcription_data = {
+                "text": result_data["original_text"],
+                "translated_text": result_data["translated_text"],
+                "word_timestamps": result_data["word_timestamps"],
+                "audio_bytes": audio_bytes,
+                "original_suffix": Path(original_filename).suffix,
+                "translation_success": result_data.get("translation_success", False),
+                "detected_language": result_data.get("language_detected", "unknown"),
+            }
+            # Update transcript feed (prepend, dedupe by digest)
+            try:
+                digest = hashlib.md5(audio_bytes).hexdigest()
+            except Exception:
+                digest = f"snap-{int(time.time()*1000)}"
+            if digest not in st.session_state.transcript_ids:
+                st.session_state.transcript_ids.add(digest)
+                st.session_state.transcript_feed.insert(
+                    0,
+                    {
+                        "id": digest,
+                        "ts": int(time.time() * 1000),
+                        "text": result_data["original_text"],
+                    },
+                )
+            # Rebuild edited_text with newest first
+            st.session_state.edited_text = "\n\n".join(
+                [s["text"] for s in st.session_state.transcript_feed]
+            )
+
+        else:  # Standard processing without translation
+            with st.spinner("⏳ Performing AI Transcription... please wait."):
+                word_timestamps, processor_logs = processor.get_word_timestamps(
+                    tmp_file_path
+                )
+
+            log_to_browser_console(processor_logs)
+
+            if not word_timestamps:
+                st.warning(
+                    "Could not generate timestamps. Check browser console (F12) for logs."
+                )
+                return
+
+            full_text = " ".join([d["word"] for d in word_timestamps])
+            st.session_state.transcription_data = {
+                "text": full_text,
+                "word_timestamps": word_timestamps,
+                "audio_bytes": audio_bytes,
+                "original_suffix": Path(original_filename).suffix,
+                "translation_success": False,
+            }
+            # Update transcript feed (prepend, dedupe by digest)
+            try:
+                digest = hashlib.md5(audio_bytes).hexdigest()
+            except Exception:
+                digest = f"snap-{int(time.time()*1000)}"
+            if digest not in st.session_state.transcript_ids:
+                st.session_state.transcript_ids.add(digest)
+                st.session_state.transcript_feed.insert(
+                    0, {"id": digest, "ts": int(time.time() * 1000), "text": full_text}
+                )
+            # Rebuild edited_text with newest first
+            st.session_state.edited_text = "\n\n".join(
+                [s["text"] for s in st.session_state.transcript_feed]
+            )
+
+        st.session_state.step = 1  # Keep it on the same step
+        
+        # Return result for background processing
+        return {
+            'original_text': result_data.get("original_text") if result_data else full_text,
+            'translated_text': result_data.get("translated_text") if result_data else None,
+            'detected_language': result_data.get("language_detected") if result_data else "unknown",
+            'translation_success': result_data.get("translation_success", False) if result_data else False,
+            'word_timestamps': result_data.get("word_timestamps") if result_data else word_timestamps
+        }
+    
+    except Exception as e:
+        st.error("An unexpected error occurred during audio processing!")
+        st.exception(e)
+        log_to_browser_console(f"--- FATAL ERROR in run_audio_processing: {traceback.format_exc()} ---")
+        return None
+    finally:
+        if tmp_file_path and os.path.exists(tmp_file_path):
+            os.unlink(tmp_file_path)
+
+
+# --- Main Application Logic ---
+def main():
+    # Apply custom styling first
+    apply_custom_styling()
+    
+    # Force reload environment variables
+    load_dotenv(override=True)
+    
+    # Clear AI models cache on first run or if there's an issue
+    if 'app_initialized' not in st.session_state:
+        reset_ai_models()
+        st.session_state.app_initialized = True
+    
+    initialize_session_state()
+    
+    st.markdown("""
+    <style>
+    .main .block-container { animation: fadeIn 0.2s ease-in-out; }
+    @keyframes fadeIn { from { opacity: 0; } to { opacity: 1; } }
+    .block-container { padding-top: 1rem; }
+    </style>
+    """, unsafe_allow_html=True)
+    
+    with st.sidebar:
+        st.markdown("## 🌐 Language Settings")
+        language_options = {'English': 'en', 'العربية': 'ar'}
+        selected_lang_display = st.selectbox(
+            "Interface Language",
+            options=list(language_options.keys()),
+            index=0 if st.session_state.language == 'en' else 1
+        )
+        st.session_state.language = language_options[selected_lang_display]
+        
+        st.markdown("## 🔤 Translation Settings")
+        st.session_state.enable_translation = st.checkbox(
+            "Enable AI Translation" if st.session_state.language == 'en' else "تفعيل الترجمة بالذكاء الاصطناعي",
+            value=st.session_state.enable_translation,
+            help="Automatically translate transcribed text" if st.session_state.language == 'en' else "ترجمة النص تلقائياً"
+        )
+        
+        if st.session_state.enable_translation:
+            target_lang_options = {
+                'Arabic (العربية)': 'ar', 'English': 'en', 'French (Français)': 'fr', 'Spanish (Español)': 'es'
+            }
+            selected_target = st.selectbox(
+                "Target Language" if st.session_state.language == 'en' else "اللغة المستهدفة",
+                options=list(target_lang_options.keys()), index=0
+            )
+            st.session_state.target_language = target_lang_options[selected_target]
+        # Auto summary toggle
+        st.session_state.auto_generate_summary = st.checkbox(
+            "Auto-generate Arabic summary" if st.session_state.language == 'en' else "توليد الملخص العربي تلقائياً",
+            value=st.session_state.auto_generate_summary
+        )
+        
+        # Google Account Status
+        st.markdown("## 🔐 Google Account")
+        if google_docs_manager.is_authenticated():
+            st.success("✅ متصل" if st.session_state.language == 'ar' else "✅ Connected")
+        else:
+            st.info("🔒 غير متصل" if st.session_state.language == 'ar' else "🔒 Not connected")
+        
+        # AI Questions Status
+        st.markdown("## 🤖 AI Questions")
+        
+        # Show preferred model
+        if st.session_state.preferred_ai_model != 'auto':
+            st.info(f"🎯 {'النموذج المفضل' if st.session_state.language == 'ar' else 'Preferred Model'}: {st.session_state.preferred_ai_model}")
+        else:
+            st.info("🔄 " + ("تلقائي" if st.session_state.language == 'ar' else "Auto selection"))
+        
+        # Model reset button
+        if st.button("🔄 " + ("إعادة تعيين النماذج" if st.session_state.language == 'ar' else "Reset AI Models"), help="إعادة تحميل نماذج الذكاء الاصطناعي" if st.session_state.language == 'ar' else "Reload AI models"):
+            reset_ai_models()
+            st.success("✅ " + ("تم إعادة تعيين النماذج" if st.session_state.language == 'ar' else "AI models reset successfully"))
+            st.rerun()
+        
+        # Show preferred answer language
+        answer_lang = st.session_state.get('preferred_answer_language', 'auto')
+        if answer_lang != 'auto':
+            lang_names = {'ar': '🇸🇦 العربية', 'en': '🇺🇸 English', 'fr': '🇫🇷 Français', 'es': '🇪🇸 Español', 'de': '🇩🇪 Deutsch', 'zh': '🇨🇳 中文'}
+            lang_display = lang_names.get(answer_lang, answer_lang)
+            st.info(f"🌐 {'لغة الإجابة' if st.session_state.language == 'ar' else 'Answer Language'}: {lang_display}")
+        else:
+            current_ui_lang = "🇸🇦 العربية" if st.session_state.language == 'ar' else "🇺🇸 English"
+            st.info(f"🌐 {'لغة الإجابة' if st.session_state.language == 'ar' else 'Answer Language'}: {current_ui_lang} ({'تلقائي' if st.session_state.language == 'ar' else 'Auto'})")
+        
+        # Test AI services availability
+        translator = get_translator()
+        services_status = {}
+        
+        # Test Gemini
+        try:
+            if hasattr(translator, 'model') and translator.model:
+                test_response = translator.model.generate_content("Test")
+                services_status['Gemini'] = "✅"
+            else:
+                services_status['Gemini'] = "❌"
+        except Exception as e:
+            error_str = str(e)
+            if "429" in error_str or "quota" in error_str.lower():
+                services_status['Gemini'] = "⚠️"
+            else:
+                services_status['Gemini'] = "❌"
+        
+        # Test Groq
+        try:
+            if hasattr(translator, '_groq_complete') and translator.groq_api_key:
+                services_status['Groq'] = "✅"
+            else:
+                services_status['Groq'] = "❌"
+        except Exception:
+            services_status['Groq'] = "❌"
+        
+        # Test OpenRouter
+        try:
+            if hasattr(translator, '_openrouter_complete') and translator.openrouter_api_key:
+                services_status['OpenRouter'] = "✅"
+            else:
+                services_status['OpenRouter'] = "❌"
+        except Exception:
+            services_status['OpenRouter'] = "❌"
+        
+        # Display services status
+        st.markdown("**" + ("حالة النماذج" if st.session_state.language == 'ar' else "Models Status") + ":**")
+        for service, status in services_status.items():
+            if status == "✅":
+                st.success(f"{status} {service}")
+            elif status == "⚠️":
+                st.warning(f"{status} {service} (حد يومي)" if st.session_state.language == 'ar' else f"{status} {service} (quota)")
+            else:
+                st.error(f"{status} {service}")
+        
+        # Overall status
+        available_count = sum(1 for status in services_status.values() if status == "✅")
+        if available_count > 0:
+            st.info(f"🤖 {available_count}/3 " + ("نماذج متاحة" if st.session_state.language == 'ar' else "models available"))
+        else:
+            st.warning("⚠️ جميع النماذج غير متاحة" if st.session_state.language == 'ar' else "⚠️ All models unavailable")
+        
+        # Show conversation status and usage stats
+        question_engine = get_ai_question_engine()
+        usage_stats = question_engine.get_model_usage_stats()
+        total_questions = sum(usage_stats.values())
+        
+        if st.session_state.current_question_session:
+            session = question_engine.get_conversation_history(st.session_state.current_question_session)
+            if session and session.conversation:
+                st.info(f"💬 {len(session.conversation)} " + ("أسئلة نشطة" if st.session_state.language == 'ar' else "active questions"))
+            else:
+                st.info("🤖 جاهز للأسئلة" if st.session_state.language == 'ar' else "🤖 Ready for questions")
+        else:
+            st.info("🤖 جاهز للأسئلة" if st.session_state.language == 'ar' else "🤖 Ready for questions")
+        
+        # Show usage statistics
+        if total_questions > 0:
+            with st.expander("📊 إحصائيات الاستخدام" if st.session_state.language == 'ar' else "📊 Usage Statistics"):
+                st.write(f"**{'إجمالي الأسئلة' if st.session_state.language == 'ar' else 'Total Questions'}: {total_questions}**")
+                for model, count in usage_stats.items():
+                    if count > 0:
+                        percentage = (count / total_questions) * 100
+                        st.write(f"• {model}: {count} ({percentage:.1f}%)")
+        else:
+            st.caption("📊 لا توجد إحصائيات بعد" if st.session_state.language == 'ar' else "📊 No statistics yet")
+        
+        # Quick model switcher
+        st.markdown("**" + ("تبديل سريع للنموذج" if st.session_state.language == 'ar' else "Quick Model Switch") + "**")
+        
+        question_engine = get_ai_question_engine()
+        models_status = question_engine.check_model_availability()
+        
+        # Create buttons for each available model
+        cols = st.columns(2)
+        model_names = ['auto', 'Gemini AI', 'Groq AI', 'OpenRouter AI']
+        
+        for i, model in enumerate(model_names):
+            with cols[i % 2]:
+                if model == 'auto':
+                    button_text = "🔄 تلقائي" if st.session_state.language == 'ar' else "🔄 Auto"
+                    is_current = st.session_state.preferred_ai_model == 'auto'
+                else:
+                    status_info = models_status.get(model, {})
+                    icon = status_info.get('icon', '❓')
+                    button_text = f"{icon} {model.split()[0]}"  # Show first word + icon
+                    is_current = st.session_state.preferred_ai_model == model
+                
+                button_type = "primary" if is_current else "secondary"
+                
+                if st.button(button_text, key=f"switch_{model}", type=button_type, use_container_width=True):
+                    st.session_state.preferred_ai_model = model
+                    st.rerun()
+        
+        # Quick language switcher
+        st.markdown("**" + ("تبديل سريع للغة" if st.session_state.language == 'ar' else "Quick Language Switch") + "**")
+        
+        language_buttons = {
+            'auto': "🔄 تلقائي" if st.session_state.language == 'ar' else "🔄 Auto",
+            'ar': "🇸🇦 عربي",
+            'en': "🇺🇸 EN",
+            'fr': "🇫🇷 FR",
+            'es': "🇪🇸 ES"
+        }
+        
+        cols_lang = st.columns(3)
+        for i, (lang_code, button_text) in enumerate(language_buttons.items()):
+            with cols_lang[i % 3]:
+                is_current_lang = st.session_state.get('preferred_answer_language', 'auto') == lang_code
+                button_type_lang = "primary" if is_current_lang else "secondary"
+                
+                if st.button(button_text, key=f"switch_lang_{lang_code}", type=button_type_lang, use_container_width=True):
+                    st.session_state.preferred_answer_language = lang_code
+                    st.rerun()
+        
+        # Processing status
+        if st.session_state.processing_queue or st.session_state.processing_results:
+            st.markdown("## 🔄 " + ("حالة المعالجة" if st.session_state.language == 'ar' else "Processing Status"))
+            
+            # Queue status
+            if st.session_state.processing_queue:
+                queue_count = len(st.session_state.processing_queue)
+                st.warning(f"⏳ {queue_count} " + ("في الانتظار" if st.session_state.language == 'ar' else "in queue"))
+            
+            # Results count
+            if st.session_state.processing_results:
+                results_count = len(st.session_state.processing_results)
+                st.success(f"✅ {results_count} " + ("مكتمل" if st.session_state.language == 'ar' else "completed"))
+            
+            # Clear all button
+            if st.button("🗑️ " + ("مسح الكل" if st.session_state.language == 'ar' else "Clear All")):
+                st.session_state.processing_queue = []
+                st.session_state.processing_results = {}
+                st.session_state.processing_status = {}
+                st.rerun()
+    
+    st.title("🎵 SyncMaster")
+    if st.session_state.language == 'ar':
+        st.markdown("### منصة المزامنة الذكية بين الصوت والنص")
+    else:
+        st.markdown("### The Intelligent Audio-Text Synchronization Platform")
+    
+    # Simplified interface - removed step indicators as requested
+        # Global settings for long recording retention and custom snapshot duration
+    with st.expander("⚙️ Recording Settings (Snapshots)", expanded=False):
+        st.session_state.setdefault('retention_minutes', 30)
+        # 0 means: use full buffer by default for Custom
+        st.session_state.setdefault('custom_snapshot_seconds', 0)
+        # Auto-Custom interval seconds (for frontend auto trigger)
+        st.session_state.setdefault('auto_custom_interval_sec', 10)
+        # Auto-start incremental snapshots when recording begins
+        st.session_state.setdefault('auto_start_custom', False)
+        st.session_state.retention_minutes = st.number_input("Retention window (minutes)", min_value=5, max_value=240, value=st.session_state.retention_minutes)
+        st.session_state.custom_snapshot_seconds = st.number_input("Custom snapshot (seconds; 0 = full buffer)", min_value=0, max_value=3600, value=st.session_state.custom_snapshot_seconds)
+        st.session_state.auto_custom_interval_sec = st.number_input("Auto Custom interval (seconds)", min_value=1, max_value=3600, value=st.session_state.auto_custom_interval_sec, help="How often to auto-trigger the same Custom action while recording.")
+        st.session_state.auto_start_custom = st.checkbox("Auto-start incremental snapshots on record", value=st.session_state.auto_start_custom, help="Start sending Custom intervals automatically as soon as you start recording.")
+        # Inject globals into the page for the component to pick up
+        components.html(f"""
+        <script>
+            window.ST_AREC_RETENTION_MINUTES = {int(st.session_state.retention_minutes)};
+            window.ST_AREC_CUSTOM_SNAPSHOT_SECONDS = {int(st.session_state.custom_snapshot_seconds)};
+            window.ST_AREC_LAST_FETCHED_END_MS = {int(st.session_state.get('lastFetchedEnd_ms', 0))};
+            window.ST_AREC_CUSTOM_AUTO_INTERVAL_SECONDS = {int(st.session_state.get('auto_custom_interval_sec', 10))};
+            window.ST_AREC_AUTO_START = {str(bool(st.session_state.get('auto_start_custom', True))).lower()};
+            console.log('Recorder config', window.ST_AREC_RETENTION_MINUTES, window.ST_AREC_CUSTOM_SNAPSHOT_SECONDS);
+        </script>
+        """, height=0)
+
+    if AUDIO_PROCESSOR_CLASS is None:
+        st.error("Fatal Error: The application could not start correctly.")
+        st.subheader("An error occurred while trying to import `AudioProcessor`:")
+        st.code(IMPORT_ERROR_TRACEBACK, language="python")
+        st.stop()
+    
+    step_1_upload_and_process()
+    
+    # Process background queue
+    if st.session_state.get('background_processing', True) and st.session_state.processing_queue:
+        process_queued_audio()
+    
+    # Show processing results optionally
+    if st.session_state.get('show_processing_results', False):
+        show_processing_results()
+    elif st.session_state.processing_results:
+        # Show a button to view results if there are any
+        if st.button("📝 " + ("عرض نتائج المعالجة" if st.session_state.language == 'ar' else "Show Processing Results") + f" ({len(st.session_state.processing_results)})", type="secondary"):
+            st.session_state.show_processing_results = True
+            st.rerun()
+    
+    # Note: step_2_review_and_customize removed as requested
+    # Results are now shown in show_processing_results() function
+    
+    # AI Question modal (show outside of other components)
+    if st.session_state.show_question_modal:
+        show_question_modal()
+    
+    # Export modal (show outside of other components)
+    if st.session_state.show_export_modal:
+        show_export_modal()
+
+# --- Show Processing Results ---
+def show_processing_results():
+    """Show processing results in the same page"""
+    
+    if not st.session_state.processing_results:
+        return
+    
+    st.markdown("---")
+    
+    # Header with results count and close button
+    col_header, col_close = st.columns([4, 1])
+    
+    with col_header:
+        results_count = len(st.session_state.processing_results)
+        st.subheader(f"📝 {'نتائج المعالجة' if st.session_state.language == 'ar' else 'Processing Results'} ({results_count})")
+    
+    with col_close:
+        if st.button("❌ " + ("إخفاء" if st.session_state.language == 'ar' else "Hide"), key="hide_results"):
+            st.session_state.show_processing_results = False
+            st.rerun()
+    
+    if results_count > 1:
+        # Show all results in one view option
+        show_all = st.checkbox(
+            "عرض جميع النتائج مجمعة" if st.session_state.language == 'ar' else "Show all results combined",
+            help="عرض جميع النصوص والترجمات في مكان واحد" if st.session_state.language == 'ar' else "Display all texts and translations in one place"
+        )
+        
+        if show_all:
+            # Combined view
+            st.markdown("### " + ("النصوص الأصلية مجمعة" if st.session_state.language == 'ar' else "Combined Original Texts"))
+            combined_original = "\n\n".join([result.get('original_text', '') for result in st.session_state.processing_results.values() if result.get('original_text')])
+            if combined_original:
+                st.write(combined_original)
+                
+                if st.button("📋 " + ("نسخ جميع النصوص" if st.session_state.language == 'ar' else "Copy All Texts")):
+                    st.code(combined_original, language=None)
+            
+            st.markdown("### " + ("الترجمات مجمعة" if st.session_state.language == 'ar' else "Combined Translations"))
+            combined_translation = "\n\n".join([result.get('translated_text', '') for result in st.session_state.processing_results.values() if result.get('translated_text')])
+            if combined_translation:
+                st.write(combined_translation)
+                
+                if st.button("📋 " + ("نسخ جميع الترجمات" if st.session_state.language == 'ar' else "Copy All Translations")):
+                    st.code(combined_translation, language=None)
+            
+            st.markdown("---")
+    
+    # Show results for each completed processing
+    for task_id, result in st.session_state.processing_results.items():
+        with st.expander(f"🎵 {'التسجيل' if st.session_state.language == 'ar' else 'Recording'} {task_id}", expanded=True):
+            
+            # Original text in white container
+            if result.get('original_text'):
+                original_title = "النص الأصلي" if st.session_state.language == 'ar' else "Original Text"
+                original_container = create_white_container(original_title, result['original_text'], "📝")
+                st.markdown(original_container, unsafe_allow_html=True)
+            
+            # Translation in white container
+            if result.get('translated_text'):
+                translation_title = "الترجمة" if st.session_state.language == 'ar' else "Translation"
+                translation_container = create_white_container(translation_title, result['translated_text'], "🌐")
+                st.markdown(translation_container, unsafe_allow_html=True)
+            
+            # Language info
+            if result.get('detected_language'):
+                st.caption(f"🌐 {'اللغة المكتشفة' if st.session_state.language == 'ar' else 'Detected language'}: {result['detected_language']}")
+            
+            # Action buttons
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                if st.button(f"📋 {'نسخ النص' if st.session_state.language == 'ar' else 'Copy Text'}", key=f"copy_original_{task_id}"):
+                    st.code(result.get('original_text', ''), language=None)
+                    st.success("✅ " + ("تم تنسيق النص للنسخ" if st.session_state.language == 'ar' else "Text formatted for copying"))
+            
+            with col2:
+                if result.get('translated_text') and st.button(f"📋 {'نسخ الترجمة' if st.session_state.language == 'ar' else 'Copy Translation'}", key=f"copy_translation_{task_id}"):
+                    st.code(result.get('translated_text', ''), language=None)
+                    st.success("✅ " + ("تم تنسيق الترجمة للنسخ" if st.session_state.language == 'ar' else "Translation formatted for copying"))
+            
+            with col3:
+                if st.button(f"🗑️ {'حذف' if st.session_state.language == 'ar' else 'Delete'}", key=f"delete_{task_id}"):
+                    del st.session_state.processing_results[task_id]
+                    if task_id in st.session_state.processing_status:
+                        del st.session_state.processing_status[task_id]
+                    st.rerun()
+
+# --- Step 1: Upload and Process ---
+def step_1_upload_and_process():
+    st.header("🎵 " + ("مصدر الصوت" if st.session_state.language == 'ar' else "Audio Source"))
+    
+    upload_tab, record_tab = st.tabs(["📤 Upload a File", "🎙️ Record Audio"])
+
+    with upload_tab:
+        st.subheader("Upload an existing audio file")
+        uploaded_file = st.file_uploader("Choose an audio file", type=['mp3', 'wav', 'm4a'], help="Supported formats: MP3, WAV, M4A")
+        if uploaded_file:
+            st.session_state.audio_data = uploaded_file.getvalue()
+            st.success(f"File ready for processing: {uploaded_file.name}")
+            st.audio(st.session_state.audio_data)
+            if st.button("🚀 Start AI Processing", type="primary", use_container_width=True):
+                run_audio_processing(st.session_state.audio_data, uploaded_file.name)
+        if st.session_state.audio_data:
+            if st.button("🔄 Use a Different File"):
+                reset_session()
+                st.rerun()
+
+    with record_tab:
+        st.subheader("Record audio directly from your microphone")
+        
+        # Recording instructions
+        # Recording instructions with improved controls
+        if st.session_state.language == 'ar':
+            st.info("🎙️ **تحكم بسيط في التسجيل:**\n- اضغط الميكروفون لبدء التسجيل\n- اضغط مرة أخرى للتوقف\n- استخدم الأزرار أدناه للتحكم الإضافي")
+        else:
+            st.info("🎙️ **Simple Recording Controls:**\n- Click microphone to start recording\n- Click again to stop\n- Use buttons below for additional control")
+        
+        # Recording control buttons
+        col_record_info, col_record_controls = st.columns([2, 1])
+        
+        with col_record_info:
+            # This will show recording status
+            pass
+        
+        with col_record_controls:
+            # Recording control buttons in a more compact layout
+            col_pause, col_resume = st.columns(2)
+            
+            with col_pause:
+                if st.button("⏸️ " + ("إيقاف مؤقت" if st.session_state.language == 'ar' else "Pause"), 
+                           help="إيقاف مؤقت للتسجيل" if st.session_state.language == 'ar' else "Pause recording",
+                           use_container_width=True):
+                    st.info("💡 " + ("استخدم زر الميكروفون للإيقاف المؤقت" if st.session_state.language == 'ar' else "Use microphone button to pause"))
+            
+            with col_resume:
+                if st.button("▶️ " + ("استئناف" if st.session_state.language == 'ar' else "Resume"), 
+                           help="استئناف التسجيل" if st.session_state.language == 'ar' else "Resume recording",
+                           use_container_width=True):
+                    st.info("💡 " + ("استخدم زر الميكروفون للاستئناف" if st.session_state.language == 'ar' else "Use microphone button to resume"))
+        
+        # Recording status
+        recording_status_placeholder = st.empty()
+        
+        # Use the audio recorder component
+        wav_audio_data = st_audiorec()
+        
+        # Show recording status and controls
+        if wav_audio_data:
+            # Check if wav_audio_data is bytes or dict
+            if isinstance(wav_audio_data, bytes):
+                # Simple bytes data - show audio player
+                recording_status_placeholder.success("🎵 " + ("تسجيل جاهز للمعالجة" if st.session_state.language == 'ar' else "Recording ready for processing"))
+                
+                # Recording controls
+                col_play, col_clear = st.columns(2)
+                
+                with col_play:
+                    st.audio(wav_audio_data, format='audio/wav')
+                
+                with col_clear:
+                    if st.button("🗑️ " + ("مسح التسجيل" if st.session_state.language == 'ar' else "Clear Recording")):
+                        st.rerun()
+            
+            elif isinstance(wav_audio_data, dict):
+                # Dict data - handle interval processing
+                recording_status_placeholder.info("🔄 " + ("معالجة المقاطع..." if st.session_state.language == 'ar' else "Processing intervals..."))
+
+        # Google Docs Export and Logout Buttons
+        col_export, col_logout = st.columns([3, 1])
+        
+        with col_export:
+            export_button_text = "📤 تصدير إلى Google Docs" if st.session_state.language == 'ar' else "📤 Export to Google Docs"
+            if st.button(export_button_text, type="primary", use_container_width=True):
+                export_to_google_docs_directly()
+        
+        with col_logout:
+            # Check if user is authenticated
+            if google_docs_manager.is_authenticated():
+                logout_text = "🚪 خروج" if st.session_state.language == 'ar' else "🚪 Logout"
+                if st.button(logout_text, use_container_width=True, help="تسجيل الخروج من Google" if st.session_state.language == 'ar' else "Logout from Google"):
+                    logout_from_google()
+            else:
+                # Show login status
+                login_status = "غير متصل" if st.session_state.language == 'ar' else "Not logged in"
+                st.caption(f"🔒 {login_status}")
+        
+        # Processing settings
+        st.markdown("**" + ("إعدادات المعالجة" if st.session_state.language == 'ar' else "Processing Settings") + "**")
+        
+        # Auto-process toggle (changed default to False for better UX)
+        st.session_state.setdefault('auto_process_snapshots', False)
+        auto_process = st.checkbox(
+            "معالجة تلقائية للمقاطع" if st.session_state.language == 'ar' else "Auto-process snapshots", 
+            key='auto_process_snapshots', 
+            help="عند التفعيل، يتم معالجة المقاطع تلقائياً أثناء التسجيل" if st.session_state.language == 'ar' else "When enabled, snapshots are processed automatically during recording"
+        )
+        
+        # Background processing toggle
+        st.session_state.setdefault('background_processing', True)
+        background_mode = st.checkbox(
+            "معالجة في الخلفية" if st.session_state.language == 'ar' else "Background processing",
+            key='background_processing',
+            value=True,
+            help="يسمح بالاستمرار في استخدام التطبيق أثناء المعالجة" if st.session_state.language == 'ar' else "Allows continued use of the app during processing"
+        )
+
+        if wav_audio_data:
+            # Two possible payload shapes: raw bytes array (legacy) or interval payload dict
+            if isinstance(wav_audio_data, dict) and wav_audio_data.get('type') in ('interval_wav', 'no_new'):
+                payload = wav_audio_data
+                # Mark Custom interval flow active so Step 2 editor/style can be hidden
+                st.session_state['_custom_active'] = True
+                if payload['type'] == 'no_new':
+                    st.info("No new audio chunks yet.")
+                elif payload['type'] == 'interval_wav':
+                    # Extract interval audio
+                    b = bytes(payload['bytes'])
+                    sr = int(payload.get('sr', 16000))
+                    start_ms = int(payload['start_ms'])
+                    end_ms = int(payload['end_ms'])
+                    # Dedupe/trim logic
+                    if end_ms <= start_ms:
+                        st.warning("The received interval is empty.")
+                    else:
+                        # Prevent overlap with prior segment
+                        last_end = st.session_state.lastFetchedEnd_ms or 0
+                        eff_start_ms = max(start_ms, last_end)
+                        if eff_start_ms < end_ms:
+                            # If there is overlap, trim the audio bytes accordingly (assumes WAV PCM16 mono header 44 bytes)
+                            try:
+                                delta_ms = eff_start_ms - start_ms
+                                if delta_ms > 0:
+                                    if len(b) >= 44 and b[0:4] == b'RIFF' and b[8:12] == b'WAVE':
+                                        bytes_per_sample = 2  # PCM16 mono
+                                        drop_samples = int(sr * (delta_ms / 1000.0))
+                                        drop_bytes = drop_samples * bytes_per_sample
+                                        data_size = int.from_bytes(b[40:44], 'little') if len(b) >= 44 else len(b) - 44
+                                        pcm = b[44:]
+                                        if drop_bytes < len(pcm):
+                                            pcm_trim = pcm[drop_bytes:]
+                                        else:
+                                            pcm_trim = b''
+                                        new_data_size = len(pcm_trim)
+                                        # Rebuild header sizes
+                                        header = bytearray(b[:44])
+                                        # ChunkSize at offset 4 = 36 + Subchunk2Size
+                                        (36 + new_data_size).to_bytes(4, 'little')
+                                        header[4:8] = (36 + new_data_size).to_bytes(4, 'little')
+                                        # Subchunk2Size at offset 40
+                                        header[40:44] = new_data_size.to_bytes(4, 'little')
+                                        b = bytes(header) + pcm_trim
+                                    else:
+                                        # Not a recognizable WAV header; keep as-is
+                                        pass
+                            except Exception as _:
+                                pass
+                            # Compute checksum
+                            digest = hashlib.md5(b).hexdigest()
+                            # Skip if identical checksum and same window
+                            exists = any(s.get('checksum') == digest and s.get('start_ms') == eff_start_ms and s.get('end_ms') == end_ms for s in st.session_state.broadcast_segments)
+                            if not exists:
+                                # Show spinner during extraction so the user sees a waiting icon until text appears
+                                with st.spinner("⏳ Extracting text from interval..."):
+                                    # Run standard pipeline to get text (no translation to keep it light)
+                                    # Reuse run_audio_processing internals via a temp path
+                                    with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as tf:
+                                        tf.write(b)
+                                        tmp_path = tf.name
+                                    try:
+                                        processor = AUDIO_PROCESSOR_CLASS()
+                                        word_timestamps, processor_logs, model_used = processor.get_word_timestamps(tmp_path)
+                                        full_text = " ".join([d['word'] for d in word_timestamps]) if word_timestamps else ""
+                                        # Fallback: if timestamps extraction yielded no words, try plain transcription
+                                        if not full_text:
+                                            plain_text, err, fallback_model = processor.transcribe_audio(tmp_path)
+                                            if plain_text:
+                                                full_text = plain_text.strip()
+                                                model_used = fallback_model
+                                    finally:
+                                        if os.path.exists(tmp_path): os.unlink(tmp_path)
+
+                                # Append segment immediately with only the original text
+                                seg = {
+                                    'id': digest,
+                                    'recording_id': payload.get('session_id', 'local'),
+                                    'start_ms': eff_start_ms,
+                                    'end_ms': end_ms,
+                                    'checksum': digest,
+                                    'text': full_text,
+                                    'translations': {},
+                                    'transcription_model': model_used,
+                                }
+                                st.session_state.broadcast_segments.append(seg)
+                                st.session_state.broadcast_segments.sort(key=lambda s: s['start_ms'])
+                                st.session_state.lastFetchedEnd_ms = end_ms
+                                if full_text:
+                                    if digest not in st.session_state.transcript_ids:
+                                        st.session_state.transcript_ids.add(digest)
+                                        st.session_state.transcript_feed.insert(
+                                            0,
+                                            {
+                                                "id": digest,
+                                                "ts": int(time.time() * 1000),
+                                                "text": full_text,
+                                            },
+                                        )
+                                        st.session_state.edited_text = "\n\n".join(
+                                            [s["text"] for s in st.session_state.transcript_feed]
+                                        )
+                                st.success(f"Added new segment: {eff_start_ms/1000:.2f}s → {end_ms/1000:.2f}s")
+
+                                # Now, asynchronously update translation and summary after segment is added
+                                def update_translation_and_summary():
+                                    try:
+                                        if full_text and st.session_state.get('enable_translation', True):
+                                            translator = get_translator()
+                                            sel_lang = st.session_state.get('broadcast_translation_lang', 'ar')
+                                            tx, _ = translator.translate_text(full_text, target_language=sel_lang)
+                                            if tx:
+                                                seg['translations'][sel_lang] = tx
+                                    except Exception:
+                                        pass
+                                    # Update summary
+                                    if st.session_state.get('auto_generate_summary', True):
+                                        try:
+                                            source_text = " \n".join([s.get('text', '') for s in st.session_state.broadcast_segments if s.get('text')])
+                                            if source_text.strip():
+                                                summary, _ = generate_summary(source_text, target_language=st.session_state.get('summary_language', 'ar'))
+                                                if summary:
+                                                    st.session_state.arabic_explanation = summary
+                                        except Exception:
+                                            pass
+                                import threading
+                                threading.Thread(target=update_translation_and_summary, daemon=True).start()
+                            else:
+                                st.info("Duplicate segment ignored.")
+                        else:
+                            st.info("No new parts after the last point.")
+            else:
+                # Legacy: treat as full wav bytes
+                bytes_data = bytes(wav_audio_data)
+                # This is not the Custom interval mode
+                st.session_state['_custom_active'] = False
+                st.session_state.audio_data = bytes_data
+                st.audio(bytes_data)
+                digest = hashlib.md5(bytes_data).hexdigest()
+                last_digest = st.session_state.get('_last_component_digest')
+                if st.session_state.auto_process_snapshots and digest != last_digest:
+                    st.session_state['_last_component_digest'] = digest
+                    task_id = run_audio_processing(bytes_data, "snapshot.wav")
+                    if task_id:
+                        st.success(f"🔄 {'تم إضافة المقطع للمعالجة' if st.session_state.language == 'ar' else 'Snapshot queued for processing'}")
+                else:
+                    # Simple single button for processing
+                    if st.button("📝 " + ("استخراج النص" if st.session_state.language == 'ar' else "Extract Text"), type="primary", use_container_width=True):
+                        st.session_state['_last_component_digest'] = digest
+                        task_id = run_audio_processing(bytes_data, "recorded_audio.wav")
+                        if task_id:
+                            st.success(f"✅ {'تم إضافة التسجيل للمعالجة' if st.session_state.language == 'ar' else 'Audio queued for processing'}")
+
+        # Simplified: removed external live slice server UI to avoid complexity
+
+    # Always show Broadcast view in Step 1 as well (regardless of transcription_data)
+    with st.expander("📻 Broadcast (latest first)", expanded=True):
+        # Language selector for broadcast translations
+        try:
+                translator = get_translator()
+                langs = translator.get_supported_languages()
+                codes = list(langs.keys())
+                labels = ["detect language — Arabic (العربية)"] + [f"{code} — {langs[code]}" for code in codes]
+                current = st.session_state.get('broadcast_translation_lang', 'ar')
+                # If not set, default to 'detect'
+                if current not in codes and current != 'detect':
+                    current = 'detect'
+                default_index = 0 if current == 'detect' else (codes.index(current) + 1 if current in codes else 1)
+                sel_label = st.selectbox("Broadcast translation language", labels, index=default_index)
+                if sel_label.startswith("detect language"):
+                    sel_code = 'detect'
+                else:
+                    sel_code = sel_label.split(' — ')[0]
+                st.session_state.broadcast_translation_lang = sel_code
+        except Exception:
+            sel_code = st.session_state.get('broadcast_translation_lang', 'ar')
+        
+        if st.session_state.broadcast_segments:
+            for s in sorted(st.session_state.broadcast_segments, key=lambda s: s['start_ms'], reverse=True):
+                # Create unique segment ID
+                segment_id = s.get('id', f"seg_{s['start_ms']}_{s['end_ms']}")
+                
+                # Original text with selection capability
+                original_text = s.get('text', '')
+                if original_text:
+                    # Check if this segment is selected
+                    is_selected = (st.session_state.selected_segment_id == segment_id)
+                    
+                    # Create timestamp for bubble
+                    timestamp = f"{s['start_ms']/1000:.1f}s → {s['end_ms']/1000:.1f}s"
+                    
+                    # Create columns for bubble and ask button
+                    col_bubble, col_ask = st.columns([5, 1])
+                    
+                    with col_bubble:
+                        # Display text as chat bubble
+                        bubble_html = create_broadcast_bubble(original_text, timestamp, is_selected)
+                        st.markdown(bubble_html, unsafe_allow_html=True)
+                        
+                        if is_selected:
+                            st.success("🔍 " + ("هذا النص محدد للأسئلة" if st.session_state.language == 'ar' else "This text is selected for questions"))
+                    
+                    with col_ask:
+                        # Ask AI button
+                        ask_button_text = "🤖 اسأل" if st.session_state.language == 'ar' else "🤖 Ask"
+                        button_type = "primary" if not is_selected else "secondary"
+                        if st.button(ask_button_text, key=f"ask_{segment_id}", type=button_type, use_container_width=True, help="اسأل الذكاء الاصطناعي عن هذا النص" if st.session_state.language == 'ar' else "Ask AI about this text"):
+                            # Select this text and open question modal
+                            st.session_state.selected_text = original_text
+                            st.session_state.selected_segment_id = segment_id
+                            st.session_state.show_question_modal = True
+                            st.rerun()
+                
+                # Show model used for transcription
+                model_note = s.get('transcription_model', None)
+                if model_note:
+                    st.caption(f"Model used: {model_note}")
+                
+                # Ensure and show translation in selected language
+                if s.get('text') and st.session_state.get('enable_translation', True):
+                    if 'translations' not in s or not isinstance(s.get('translations'), dict):
+                        s['translations'] = {}
+                    # Detect language and translate if 'detect' is selected
+                    if sel_code == 'detect':
+                        # Use detected language from segment if available, else fallback to 'ar'
+                        detected_lang = s.get('detected_language', None)
+                        target_lang = 'ar'  # Always translate to Arabic in detect mode
+                        if target_lang not in s['translations']:
+                            try:
+                                tx, _ = get_translator().translate_text(s.get('text', ''), target_language=target_lang)
+                                if tx:
+                                    s['translations'][target_lang] = tx
+                            except Exception:
+                                pass
+                        if s['translations'].get(target_lang):
+                            st.caption(f"Translation (AR):")
+                            st.write(s['translations'][target_lang])
+                    else:
+                        if sel_code not in s['translations']:
+                            try:
+                                tx, _ = get_translator().translate_text(s.get('text', ''), target_language=sel_code)
+                                if tx:
+                                    s['translations'][sel_code] = tx
+                            except Exception:
+                                pass
+                        if s['translations'].get(sel_code):
+                            st.caption(f"Translation ({sel_code.upper()}):")
+                            st.write(s['translations'][sel_code])
+                st.divider()
+        else:
+            st.caption("No segments yet. Use the Custom button while recording.")
+        
+
+
+# --- Google Logout Function ---
+def logout_from_google():
+    """Logout from Google account"""
+    try:
+        success = google_docs_manager.logout()
+        
+        if success:
+            st.success("تم تسجيل الخروج بنجاح!" if st.session_state.language == 'ar' else "Successfully logged out!")
+            st.info("يمكنك الآن تسجيل الدخول بحساب آخر" if st.session_state.language == 'ar' else "You can now login with a different account")
+            # Force rerun to update UI
+            time.sleep(1)
+            st.rerun()
+        else:
+            st.error("خطأ في تسجيل الخروج" if st.session_state.language == 'ar' else "Error during logout")
+    
+    except Exception as e:
+        st.error(f"خطأ غير متوقع: {str(e)}" if st.session_state.language == 'ar' else f"Unexpected error: {str(e)}")
+
+# --- Direct Google Docs Export Function ---
+def export_to_google_docs_directly():
+    """Export broadcast segments directly to Google Docs without conditions"""
+    
+    try:
+        # Get current segments (all segments, not filtered by timestamp)
+        segments = st.session_state.broadcast_segments or []
+        
+        # Show progress
+        with st.spinner("جاري ��لتصدير إلى Google Docs..." if st.session_state.language == 'ar' else "Exporting to Google Docs..."):
+            # Export directly
+            doc_url, error = google_docs_manager.export_broadcast_to_docs(
+                segments, 
+                ui_language=st.session_state.language
+            )
+        
+        if doc_url and not error:
+            st.success("تم إنشاء المستند بنجاح!" if st.session_state.language == 'ar' else "Document created successfully!")
+            
+            # Show clickable link
+            if st.session_state.language == 'ar':
+                st.markdown(f"🔗 [فتح المستند في Google Docs]({doc_url})")
+                st.info("💡 نصيحة: اضغط على الرابط أعلاه لفتح المستند في تبويب جديد")
+            else:
+                st.markdown(f"🔗 [Open Document in Google Docs]({doc_url})")
+                st.info("💡 Tip: Click the link above to open the document in a new tab")
+            
+            # Also show the URL for copying
+            st.code(doc_url, language=None)
+            
+            # Show current user info
+            if google_docs_manager.is_authenticated():
+                st.caption("✅ متصل بحساب Google" if st.session_state.language == 'ar' else "✅ Connected to Google account")
+            
+        else:
+            error_msg = error or "Unknown error occurred"
+            st.error(f"خطأ في التصدير: {error_msg}" if st.session_state.language == 'ar' else f"Export error: {error_msg}")
+            
+            # Show setup instructions if credentials are missing
+            if "credentials" in error_msg.lower() or "authentication" in error_msg.lower():
+                st.info("📋 يرجى مراجعة ملف GOOGLE_SETUP.md لإعداد Google Docs" if st.session_state.language == 'ar' else "📋 Please check GOOGLE_SETUP.md for Google Docs setup instructions")
+    
+    except Exception as e:
+        st.error(f"خطأ غير متوقع: {str(e)}" if st.session_state.language == 'ar' else f"Unexpected error: {str(e)}")
+
+# --- AI Question Modal Function ---
+def show_question_modal():
+    """Display AI question modal for selected text"""
+    
+    if not st.session_state.selected_text:
+        st.session_state.show_question_modal = False
+        return
+    
+    # Get AI question engine
+    question_engine = get_ai_question_engine()
+    
+    # Modal header
+    st.subheader("🤖 اسأل الذكاء الاصطناعي" if st.session_state.language == 'ar' else "🤖 Ask AI")
+    
+    # Show selected text
+    with st.expander("النص المحدد" if st.session_state.language == 'ar' else "Selected Text", expanded=True):
+        st.write(f"📝 {st.session_state.selected_text}")
+    
+    # Show conversation history if exists
+    if st.session_state.current_question_session:
+        session = question_engine.get_conversation_history(st.session_state.current_question_session)
+        if session and session.conversation:
+            with st.expander(f"💬 تاريخ المحادثة ({len(session.conversation)} أسئلة)" if st.session_state.language == 'ar' else f"💬 Conversation History ({len(session.conversation)} questions)", expanded=False):
+                for i, qa in enumerate(session.conversation, 1):
+                    st.markdown(f"**{i}. {qa.question}**")
+                    st.write(qa.answer)
+                    
+                    # Show timing and model info
+                    model_info = getattr(qa, 'model_used', 'Unknown')
+                    model_color = "green" if "Gemini" in model_info else "orange" if "Groq" in model_info or "OpenRouter" in model_info else "red"
+                    
+                    caption_text = f"⏱️ {qa.timestamp.strftime('%H:%M:%S')} - {qa.response_time_ms}ms"
+                    model_text = f"🔧 {model_info}"
+                    
+                    st.caption(caption_text)
+                    st.markdown(f"<small style='color: {model_color}'>{model_text}</small>", unsafe_allow_html=True)
+                    
+                    if i < len(session.conversation):
+                        st.divider()
+    
+    # Model selection (moved to top)
+    st.markdown("**" + ("اختيار النموذج" if st.session_state.language == 'ar' else "Model Selection") + "**")
+    
+    # Get model availability
+    models_status = question_engine.check_model_availability()
+    
+    # Create model options with status indicators
+    model_options = {}
+    for model_name, status_info in models_status.items():
+        display_name = f"{status_info['icon']} {model_name} - {status_info['message']}"
+        model_options[display_name] = model_name
+    
+    # Add auto option
+    auto_text = "🔄 تلقائي (أفضل نموذج متاح)" if st.session_state.language == 'ar' else "🔄 Auto (Best available model)"
+    model_options = {auto_text: 'auto', **model_options}
+    
+    # Find current selection index
+    current_model = st.session_state.get('preferred_ai_model', 'auto')
+    current_index = 0
+    for i, (display_name, model_name) in enumerate(model_options.items()):
+        if model_name == current_model:
+            current_index = i
+            break
+    
+    # Model selector
+    selected_model_display = st.selectbox(
+        "النموذج المفضل" if st.session_state.language == 'ar' else "Preferred Model",
+        options=list(model_options.keys()),
+        index=current_index,
+        help="اختر النموذج المفضل للإجابة" if st.session_state.language == 'ar' else "Choose preferred model for answering"
+    )
+    
+    selected_model = model_options[selected_model_display]
+    st.session_state.preferred_ai_model = selected_model
+    
+    # Show model status details
+    if selected_model != 'auto':
+        status_info = models_status[selected_model]
+        if status_info['status'] != 'available':
+            if status_info['status'] == 'quota_exceeded':
+                st.warning("⚠️ هذا النموذج استنفد حصته اليومية" if st.session_state.language == 'ar' else "⚠️ This model has exceeded its daily quota")
+            elif status_info['status'] == 'not_configured':
+                st.info("ℹ️ هذا النموذج غير مُعد - سيتم استخدام البديل" if st.session_state.language == 'ar' else "ℹ️ This model is not configured - fallback will be used")
+            else:
+                st.error("❌ هذا النموذج غير متاح حالياً" if st.session_state.language == 'ar' else "❌ This model is currently unavailable")
+    
+    # Language selection for answers
+    st.markdown("**" + ("لغة الإجابة" if st.session_state.language == 'ar' else "Answer Language") + "**")
+    
+    # Language options
+    language_options = {
+        "🔄 تلقائي (حسب لغة الواجهة)" if st.session_state.language == 'ar' else "🔄 Auto (Interface language)": 'auto',
+        "🇸🇦 العربية": 'ar',
+        "🇺🇸 English": 'en',
+        "🇫🇷 Français": 'fr',
+        "🇪🇸 Español": 'es',
+        "🇩🇪 Deutsch": 'de',
+        "🇨🇳 中文": 'zh'
+    }
+    
+    # Find current language selection
+    current_lang = st.session_state.get('preferred_answer_language', 'auto')
+    current_lang_index = 0
+    for i, (display_name, lang_code) in enumerate(language_options.items()):
+        if lang_code == current_lang:
+            current_lang_index = i
+            break
+    
+    # Language selector
+    selected_language_display = st.selectbox(
+        "لغة الإجابة المفضلة" if st.session_state.language == 'ar' else "Preferred Answer Language",
+        options=list(language_options.keys()),
+        index=current_lang_index,
+        help="اختر اللغة التي تريد الحصول على الإجابة بها" if st.session_state.language == 'ar' else "Choose the language for AI responses"
+    )
+    
+    selected_answer_language = language_options[selected_language_display]
+    st.session_state.preferred_answer_language = selected_answer_language
+    
+    # Show language info
+    if selected_answer_language == 'auto':
+        current_ui_lang = "العربية" if st.session_state.language == 'ar' else "English"
+        st.caption(f"ℹ️ سيتم استخدام لغة الواجهة الحالية: {current_ui_lang}" if st.session_state.language == 'ar' else f"ℹ️ Will use current interface language: {current_ui_lang}")
+    else:
+        lang_names = {'ar': 'العربية', 'en': 'English', 'fr': 'Français', 'es': 'Español', 'de': 'Deutsch', 'zh': '中文'}
+        selected_lang_name = lang_names.get(selected_answer_language, selected_answer_language)
+        st.caption(f"ℹ️ الإجابات ستكون باللغة: {selected_lang_name}" if st.session_state.language == 'ar' else f"ℹ️ Answers will be in: {selected_lang_name}")
+    
+    # Question templates
+    st.markdown("**" + ("قوالب الأسئلة السريعة" if st.session_state.language == 'ar' else "Quick Question Templates") + "**")
+    
+    templates = question_engine.get_question_templates(st.session_state.language)
+    
+    # Display templates as buttons in columns
+    cols = st.columns(2)
+    for i, template in enumerate(templates[:6]):  # Show first 6 templates
+        with cols[i % 2]:
+            if st.button(template, key=f"template_{i}", use_container_width=True):
+                # Process template question
+                process_ai_question(template, is_template=True, preferred_model=selected_model, answer_language=selected_answer_language)
+                return
+    
+    # Custom question input
+    st.markdown("**" + ("أو اكتب سؤالك الخاص" if st.session_state.language == 'ar' else "Or Write Your Own Question") + "**")
+    
+    custom_question = st.text_area(
+        "سؤالك" if st.session_state.language == 'ar' else "Your Question",
+        placeholder="اكتب سؤالك هنا..." if st.session_state.language == 'ar' else "Type your question here...",
+        height=100
+    )
+    
+    # Action buttons
+    col_ask, col_cancel = st.columns(2)
+    
+    with col_ask:
+        if st.button("🚀 اسأل" if st.session_state.language == 'ar' else "🚀 Ask", type="primary", disabled=not custom_question.strip()):
+            if custom_question.strip():
+                process_ai_question(custom_question.strip(), is_template=False, preferred_model=selected_model, answer_language=selected_answer_language)
+                return
+    
+    with col_cancel:
+        if st.button("❌ إلغاء" if st.session_state.language == 'ar' else "❌ Cancel"):
+            st.session_state.show_question_modal = False
+            st.session_state.selected_text = None
+            st.session_state.selected_segment_id = None
+            st.rerun()
+
+def process_ai_question(question: str, is_template: bool = False, preferred_model: str = 'auto', answer_language: str = 'auto'):
+    """Process AI question and show response"""
+    
+    question_engine = get_ai_question_engine()
+    
+    # Prepare segment info
+    segment_info = {
+        'id': st.session_state.selected_segment_id,
+        'start_ms': 0,  # We'll get this from the actual segment if needed
+        'end_ms': 0
+    }
+    
+    # Show processing indicator
+    with st.spinner("جاري معالجة سؤالك..." if st.session_state.language == 'ar' else "Processing your question..."):
+        # Determine answer language
+        if answer_language == 'auto':
+            answer_lang = st.session_state.language
+        else:
+            answer_lang = answer_language
+        
+        # Process question
+        result = question_engine.process_question(
+            selected_text=st.session_state.selected_text,
+            question=question,
+            segment_info=segment_info,
+            ui_language=answer_lang,  # Use selected answer language
+            session_id=st.session_state.current_question_session,
+            preferred_model=preferred_model
+        )
+        
+        # Handle different return formats for backward compatibility
+        if len(result) == 4:
+            answer, error, session_id, model_used = result
+        else:
+            answer, error, session_id = result
+            model_used = "Unknown"
+    
+    # Update session ID
+    st.session_state.current_question_session = session_id
+    
+    if answer:
+        # Check response type and model fallback
+        is_simple_response = "ملاحظة: هذه إجابة مبسطة" in answer or "Note: This is a simplified response" in answer
+        preferred_model = st.session_state.get('preferred_ai_model', 'auto')
+        model_fallback = preferred_model != 'auto' and preferred_model != model_used
+        
+        if is_simple_response:
+            st.warning("⚠️ خدمة الذكاء الاصطناعي غير متاحة حالياً - إجابة مبسطة" if st.session_state.language == 'ar' else "⚠️ AI service temporarily unavailable - simplified response")
+        elif model_fallback:
+            st.info(f"ℹ️ النموذج المفضل ({preferred_model}) غير متاح - تم استخدام {model_used}" if st.session_state.language == 'ar' else f"ℹ️ Preferred model ({preferred_model}) unavailable - used {model_used}")
+        else:
+            st.success("تم الحصول على الإجابة!" if st.session_state.language == 'ar' else "Got the answer!")
+        
+        # Display Q&A
+        st.markdown("### " + ("السؤال" if st.session_state.language == 'ar' else "Question"))
+        st.write(f"❓ {question}")
+        
+        st.markdown("### " + ("الإجابة" if st.session_state.language == 'ar' else "Answer"))
+        st.write(f"🤖 {answer}")
+        
+        # Show which model was used with enhanced styling
+        if model_used:
+            # Get model status for better display
+            question_engine = get_ai_question_engine()
+            models_status = question_engine.check_model_availability()
+            
+            model_info = models_status.get(model_used, {})
+            icon = model_info.get('icon', '🤖')
+            color = model_info.get('color', 'gray')
+            
+            # Show if user's preferred model was used or fallback occurred
+            preferred_model = st.session_state.get('preferred_ai_model', 'auto')
+            if preferred_model != 'auto' and preferred_model != model_used:
+                fallback_msg = " (تم التبديل للبديل)" if st.session_state.language == 'ar' else " (fallback used)"
+                color = "orange"
+            else:
+                fallback_msg = ""
+            
+            model_display = f"{icon} {model_used}{fallback_msg}"
+            
+            # Show answer language info
+            answer_lang = st.session_state.get('preferred_answer_language', 'auto')
+            if answer_lang == 'auto':
+                lang_display = "تلقائي" if st.session_state.language == 'ar' else "Auto"
+                lang_flag = "🔄"
+            else:
+                lang_flags = {'ar': '🇸🇦', 'en': '🇺🇸', 'fr': '🇫🇷', 'es': '🇪🇸', 'de': '🇩🇪', 'zh': '🇨🇳'}
+                lang_names = {'ar': 'العربية', 'en': 'English', 'fr': 'Français', 'es': 'Español', 'de': 'Deutsch', 'zh': '中文'}
+                lang_flag = lang_flags.get(answer_lang, '🌐')
+                lang_display = lang_names.get(answer_lang, answer_lang)
+            
+            info_text = f"🔧 {'النموذج' if st.session_state.language == 'ar' else 'Model'}: {model_display} | 🌐 {'اللغة' if st.session_state.language == 'ar' else 'Language'}: {lang_flag} {lang_display}"
+            
+            st.markdown(f"<div style='background-color: rgba(0,0,0,0.1); padding: 8px; border-radius: 5px; margin: 5px 0;'><small style='color: {color}'>{info_text}</small></div>", unsafe_allow_html=True)
+        
+        # Show additional help for simple responses
+        if is_simple_response:
+            with st.expander("💡 نصائح للحصول على إجابات أفضل" if st.session_state.language == 'ar' else "💡 Tips for better answers"):
+                if st.session_state.language == 'ar':
+                    st.markdown("""
+                    **لماذا الإجابة مبسطة؟**
+                    - تم استنفاد الحد اليومي لخدمة Gemini AI المجانية (50 طلب/يوم)
+                    - النظام يستخدم إجابات مبسطة كبديل مؤقت
+                    
+                    **للحصول على إجابات أفضل:**
+                    - حاول مرة أخرى غداً (يتم تجديد الحد اليومي)
+                    - اطرح أسئلة أكثر تحديداً
+                    - ابحث في مصادر إضافية للموضوع
+                    """)
+                else:
+                    st.markdown("""
+                    **Why is the answer simplified?**
+                    - Daily limit for free Gemini AI service exceeded (50 requests/day)
+                    - System is using simplified responses as temporary fallback
+                    
+                    **For better answers:**
+                    - Try again tomorrow (daily limit resets)
+                    - Ask more specific questions
+                    - Search additional sources for the topic
+                    """)
+        
+        
+        # Action buttons for the response
+        col_copy, col_follow, col_close = st.columns(3)
+        
+        with col_copy:
+            if st.button("📋 نسخ" if st.session_state.language == 'ar' else "📋 Copy"):
+                # Format for copying
+                copy_text = f"السؤال: {question}\nالإجابة: {answer}" if st.session_state.language == 'ar' else f"Question: {question}\nAnswer: {answer}"
+                st.code(copy_text, language=None)
+                st.success("تم تنسيق النص للنسخ أعلاه" if st.session_state.language == 'ar' else "Text formatted for copying above")
+        
+        with col_follow:
+            if st.button("➕ سؤال متابعة" if st.session_state.language == 'ar' else "➕ Follow-up"):
+                # Keep modal open for follow-up question
+                st.rerun()
+        
+        with col_close:
+            if st.button("✅ إغلاق" if st.session_state.language == 'ar' else "✅ Close"):
+                st.session_state.show_question_modal = False
+                st.session_state.selected_text = None
+                st.session_state.selected_segment_id = None
+                st.rerun()
+    
+    else:
+        # Show error
+        st.error(f"خطأ: {error}" if st.session_state.language == 'ar' else f"Error: {error}")
+        
+        # Retry and close buttons
+        col_retry, col_close = st.columns(2)
+        
+        with col_retry:
+            if st.button("🔄 إعادة المحاولة" if st.session_state.language == 'ar' else "🔄 Retry"):
+                process_ai_question(question, is_template)
+                return
+        
+        with col_close:
+            if st.button("❌ إغلاق" if st.session_state.language == 'ar' else "❌ Close"):
+                st.session_state.show_question_modal = False
+                st.session_state.selected_text = None
+                st.session_state.selected_segment_id = None
+                st.rerun()
+
+# --- Export Modal Function ---
+def show_export_modal():
+    """Display export modal with preview and options"""
+    
+    # Initialize Google Docs auth
+    if 'google_auth' not in st.session_state:
+        st.session_state.google_auth = GoogleDocsAuth()
+    
+    google_auth = st.session_state.google_auth
+    
+    # Filter segments from export timestamp
+    if not st.session_state.export_timestamp or not st.session_state.broadcast_segments:
+        st.session_state.show_export_modal = False
+        return
+    
+    # Get segments after export timestamp
+    filtered_segments = []
+    for segment in st.session_state.broadcast_segments:
+        if segment.get('start_ms', 0) >= st.session_state.export_timestamp:
+            filtered_segments.append(segment)
+    
+    # Sort by start time (oldest first for export)
+    filtered_segments.sort(key=lambda s: s.get('start_ms', 0))
+    
+    if not filtered_segments:
+        st.warning("لا توجد مقاطع جديدة للتصدير منذ الضغط على الزر" if st.session_state.language == 'ar' else "No new segments to export since button press")
+        if st.button("إغلاق" if st.session_state.language == 'ar' else "Close"):
+            st.session_state.show_export_modal = False
+            st.rerun()
+        return
+    
+    # Export preview
+    st.subheader("📋 معاينة التصدير" if st.session_state.language == 'ar' else "📋 Export Preview")
+    
+    export_time = datetime.fromtimestamp(st.session_state.export_timestamp / 1000)
+    st.info(f"{'المقاطع من وقت' if st.session_state.language == 'ar' else 'Segments from'}: {export_time.strftime('%H:%M:%S')}")
+    st.info(f"{'عدد المقاطع' if st.session_state.language == 'ar' else 'Number of segments'}: {len(filtered_segments)}")
+    
+    # Show preview of segments
+    with st.expander("معاينة المحتوى" if st.session_state.language == 'ar' else "Content Preview", expanded=False):
+        for i, segment in enumerate(filtered_segments[:3]):  # Show first 3 segments
+            start_time = segment.get('start_ms', 0) / 1000
+            end_time = segment.get('end_ms', 0) / 1000
+            st.markdown(f"**[{start_time:.2f}s → {end_time:.2f}s]**")
+            st.write(segment.get('text', '')[:100] + "..." if len(segment.get('text', '')) > 100 else segment.get('text', ''))
+            if i < 2 and i < len(filtered_segments) - 1:
+                st.divider()
+        
+        if len(filtered_segments) > 3:
+            st.caption(f"... {'و' if st.session_state.language == 'ar' else 'and'} {len(filtered_segments) - 3} {'مقاطع أخرى' if st.session_state.language == 'ar' else 'more segments'}")
+    
+    # Export options
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        format_options = {
+            "📄 Word Document": "word",
+            "📝 Google Docs": "google_docs"
+        }
+        selected_format = st.selectbox(
+            "تنسيق التصدير" if st.session_state.language == 'ar' else "Export Format",
+            options=list(format_options.keys()),
+            index=0
+        )
+        st.session_state.export_format = format_options[selected_format]
+    
+    with col2:
+        include_summary = st.checkbox(
+            "تضمين الملخص" if st.session_state.language == 'ar' else "Include Summary",
+            value=True
+        )
+    
+    # Google Docs authentication section
+    if st.session_state.export_format == 'google_docs':
+        st.markdown("---")
+        if google_auth.is_authenticated():
+            st.success("✅ " + ("متصل بـ Google Docs" if st.session_state.language == 'ar' else "Connected to Google Docs"))
+            col_logout, col_info = st.columns([1, 2])
+            with col_logout:
+                if st.button("🚪 " + ("تسجيل خروج" if st.session_state.language == 'ar' else "Logout")):
+                    google_auth.logout()
+                    st.rerun()
+            with col_info:
+                st.caption("سيتم إنشاء المستند في حسابك على Google" if st.session_state.language == 'ar' else "Document will be created in your Google account")
+        else:
+            st.warning("🔐 " + ("يجب تسجيل الدخول إلى Google Docs أولاً" if st.session_state.language == 'ar' else "Please authenticate with Google Docs first"))
+            
+            # Handle OAuth callback
+            auth_code = st.query_params.get("code")
+            if auth_code:
+                success, message = google_auth.handle_auth_callback(auth_code)
+                if success:
+                    st.success(message)
+                    # Clear the code from URL
+                    st.query_params.clear()
+                    st.rerun()
+                else:
+                    st.error(message)
+            
+            # Show authentication button
+            auth_url, error = google_auth.get_auth_url()
+            if auth_url:
+                st.markdown(f"""
+                <a href="{auth_url}" target="_blank">
+                    <button style="background-color: #4285f4; color: white; padding: 10px 20px; border: none; border-radius: 5px; cursor: pointer;">
+                        🔗 {"تسجيل الدخول إلى Google" if st.session_state.language == 'ar' else "Sign in with Google"}
+                    </button>
+                </a>
+                """, unsafe_allow_html=True)
+                st.caption("سيتم فتح نافذة جديدة للمصادقة" if st.session_state.language == 'ar' else "A new window will open for authentication")
+            else:
+                st.error(f"خطأ في إعداد Google API: {error}" if st.session_state.language == 'ar' else f"Google API setup error: {error}")
+                st.info("يرجى إعداد GOOGLE_CLIENT_ID و GOOGLE_CLIENT_SECRET في متغيرات البيئة" if st.session_state.language == 'ar' else "Please set GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET environment variables")
+    
+    # Export buttons
+    col_export, col_cancel = st.columns(2)
+    
+    with col_export:
+        # Disable export button if Google Docs is selected but not authenticated
+        export_disabled = (st.session_state.export_format == 'google_docs' and not google_auth.is_authenticated())
+        export_button_text = "🚀 تصدير" if st.session_state.language == 'ar' else "🚀 Export"
+        
+        if st.button(export_button_text, type="primary", disabled=export_disabled):
+            perform_export(filtered_segments, include_summary, google_auth)
+    
+    with col_cancel:
+        if st.button("❌ إلغاء" if st.session_state.language == 'ar' else "❌ Cancel"):
+            st.session_state.show_export_modal = False
+            st.rerun()
+
+# --- Export Execution Function ---
+def perform_export(segments, include_summary=True, google_auth=None):
+    """Perform the actual export operation"""
+    
+    try:
+        # Initialize exporter
+        translator = get_translator()
+        exporter = BroadcastExporter(translator)
+        
+        # Create export configuration
+        config = ExportConfig(
+            export_timestamp=st.session_state.export_timestamp,
+            format_type=st.session_state.export_format,
+            include_summary=include_summary,
+            ui_language=st.session_state.language,
+            target_language=st.session_state.get('broadcast_translation_lang', 'ar')
+        )
+        
+        # Prepare export content
+        content = exporter.prepare_export_content(segments, config)
+        
+        # Show progress
+        with st.spinner("جاري التصدير..." if st.session_state.language == 'ar' else "Exporting..."):
+            # Perform export with fallback
+            result, error = exporter.export_with_fallback(content, config, google_auth)
+        
+        if result and not error:
+            if config.format_type == 'word':
+                # Provide download link for Word document
+                with open(result, 'rb') as file:
+                    st.download_button(
+                        label="📥 تحميل الملف" if st.session_state.language == 'ar' else "📥 Download File",
+                        data=file.read(),
+                        file_name=os.path.basename(result),
+                        mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+                    )
+                st.success("تم إنشاء الملف بنجاح!" if st.session_state.language == 'ar' else "File created successfully!")
+            else:
+                # Google Docs URL
+                st.success("تم إنشاء المستند بنجاح!" if st.session_state.language == 'ar' else "Document created successfully!")
+                st.markdown(f"[فتح في Google Docs]({result})" if st.session_state.language == 'ar' else f"[Open in Google Docs]({result})")
+        else:
+            st.error(f"خطأ في التصدير: {error}" if st.session_state.language == 'ar' else f"Export error: {error}")
+    
+    except Exception as e:
+        st.error(f"خطأ غير متوقع: {str(e)}" if st.session_state.language == 'ar' else f"Unexpected error: {str(e)}")
+    
+    # Close modal after export attempt
+    if st.button("إغلاق" if st.session_state.language == 'ar' else "Close"):
+        st.session_state.show_export_modal = False
+        st.rerun()
+
+# Note: external live slice helper removed to keep the app simple and fully local
+
+# --- Step 2: Review and Customize (REMOVED) ---
+# This section was removed as requested by user to simplify the interface
+# Results are now shown directly in show_processing_results() function
+
+def reset_session():
+    """Resets the session state by clearing specific keys and re-initializing."""
+    log_to_browser_console("--- INFO: Resetting session state. ---")
+    keys_to_clear = ['step', 'audio_data', 'transcription_data', 'edited_text', 'video_style', 'new_recording']
+    for key in keys_to_clear:
+        if key in st.session_state:
+            del st.session_state[key]
+    initialize_session_state()
+
+# --- Entry Point ---
+if __name__ == "__main__":
+    if check_api_key():
+        initialize_session_state()
+        main()

app_config.py

@@ -0,0 +1,59 @@
+"""
+Configuration Module for SyncMaster
+إعدادات التطبيق الأساسية
+"""
+
+import os
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+class AppConfig:
+    """Configuration class for SyncMaster application"""
+    
+    # Server settings
+    STREAMLIT_PORT = int(os.getenv('STREAMLIT_PORT', 5050))
+    RECORDER_PORT = int(os.getenv('RECORDER_PORT', 5001))
+    
+    # Development vs Production
+    IS_PRODUCTION = os.getenv('SPACE_ID') is not None or os.getenv('RAILWAY_ENVIRONMENT') is not None
+    
+    # Host settings
+    if IS_PRODUCTION:
+        STREAMLIT_HOST = "0.0.0.0"
+        RECORDER_HOST = "0.0.0.0"
+    else:
+        STREAMLIT_HOST = "localhost"
+        RECORDER_HOST = "localhost"
+    
+    # Integration settings
+    USE_INTEGRATED_SERVER = IS_PRODUCTION or os.getenv('USE_INTEGRATED_SERVER', 'true').lower() == 'true'
+    
+    # Logging
+    LOG_LEVEL = os.getenv('LOG_LEVEL', 'INFO')
+    
+    @classmethod
+    def get_streamlit_url(cls):
+        """Get the Streamlit application URL"""
+        return f"http://{cls.STREAMLIT_HOST}:{cls.STREAMLIT_PORT}"
+    
+    @classmethod
+    def get_recorder_url(cls):
+        """Get the recorder server URL"""
+        return f"http://{cls.RECORDER_HOST}:{cls.RECORDER_PORT}"
+    
+    @classmethod
+    def log_config(cls):
+        """Log current configuration"""
+        logging.info("📋 SyncMaster Configuration:")
+        logging.info(f"   • Production Mode: {cls.IS_PRODUCTION}")
+        logging.info(f"   • Integrated Server: {cls.USE_INTEGRATED_SERVER}")
+        logging.info(f"   • Streamlit: {cls.get_streamlit_url()}")
+        logging.info(f"   • Recorder: {cls.get_recorder_url()}")
+
+# Initialize configuration
+config = AppConfig()
+
+if __name__ == "__main__":
+    config.log_config()

app_launcher.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""
+App Launcher - يشغل التطبيق مع الخادم المدمج
+"""
+
+import os
+import sys
+
+# Add current directory to path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# Force start integrated server
+print("🚀 Starting integrated recorder server...")
+try:
+    from integrated_server import integrated_server
+    
+    # Force start the server
+    if not integrated_server.is_running:
+        result = integrated_server.start_recorder_server()
+        if result:
+            print("✅ Recorder server started successfully")
+        else:
+            print("⚠️ Warning: Could not start recorder server")
+    else:
+        print("✅ Recorder server already running")
+        
+except Exception as e:
+    print(f"❌ Error starting recorder server: {e}")
+
+print("📱 Loading main application...")
+
+# Execute the app.py content directly
+if __name__ == "__main__":
+    # If running directly, execute app.py
+    exec(open('app.py').read())
+else:
+    # If imported by Streamlit, import and execute
+    try:
+        exec(open('app.py').read())
+        print("✅ Application loaded successfully")
+    except Exception as e:
+        print(f"❌ Error loading application: {e}")
+        raise

audio_processor.py

@@ -0,0 +1,391 @@
+# audio_processor.py - Enhanced with AI Translation Support
+
+import os
+from dotenv import load_dotenv
+import tempfile
+from typing import List, Dict, Optional, Tuple
+import json
+import traceback
+
+# --- DEFINITIVE NUMBA FIX ---
+# This MUST be done BEFORE importing librosa
+os.environ["NUMBA_CACHE_DIR"] = "/tmp"
+
+# Now, import librosa safely
+import librosa
+# --- END OF FIX ---
+
+import google.generativeai as genai
+from translator import AITranslator
+import requests
+from google.api_core import exceptions as google_exceptions
+
+class AudioProcessor:
+    def __init__(self):
+        self.translator = None
+        self.init_error = None
+        self._initialize_translator()
+
+    def _initialize_translator(self):
+        """Initialize AI translator for multi-language support"""
+        try:
+            self.translator = AITranslator()
+            if self.translator.init_error:
+                print(f"--- WARNING: Translator has initialization error: {self.translator.init_error} ---")
+        except Exception as e:
+            print(f"--- WARNING: Translator initialization failed: {str(e)} ---")
+            self.translator = None
+    
+    def transcribe_audio(self, audio_file_path: str) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+        """
+        Transcribes audio. Returns (text, error_message).
+        Uses Gemini first (if available), then falls back to Groq Whisper.
+        """
+        if not os.path.exists(audio_file_path):
+            return None, f"--- ERROR: Audio file for transcription not found at: {audio_file_path} ---", None
+
+        # Try Gemini first if available
+        gemini_err = None
+        try:
+            if self.translator and self.translator.model:
+                audio_file = genai.upload_file(path=audio_file_path)
+                prompt = (
+                    "You are an ASR system. Transcribe the audio accurately. "
+                    "Auto-detect the spoken language and return ONLY the verbatim transcript in that same language. "
+                    "Do not translate. Do not add labels or timestamps."
+                )
+                response = self.translator.model.generate_content([prompt, audio_file])
+                if response and hasattr(response, 'text') and response.text:
+                    return response.text.strip(), None, "Gemini"
+                else:
+                    gemini_err = "--- WARNING: Gemini returned an empty response for transcription. ---"
+        except google_exceptions.ResourceExhausted:
+            gemini_err = "--- QUOTA ERROR: You have exceeded the daily free usage limit for the AI service. Please wait for your quota to reset (usually within 24 hours) or upgrade your Google AI plan. ---"
+        except Exception:
+            gemini_err = f"--- FATAL ERROR during Gemini transcription: {traceback.format_exc()} ---"
+
+        # Fallback: Groq Whisper
+        text, groq_err = self._transcribe_with_groq(audio_file_path)
+        if text:
+            return text, None, "Groq Whisper"
+
+        # If all failed
+        combined_err = groq_err or gemini_err or "--- ERROR: No transcription provider available. ---"
+        return None, combined_err, None
+
+    def _transcribe_with_groq(self, audio_file_path: str) -> Tuple[Optional[str], Optional[str]]:
+        """Transcribe using Groq Whisper-compatible endpoint. Returns (text, error)."""
+        try:
+            load_dotenv()
+            groq_key = os.getenv("GROQ_API_KEY")
+            if not groq_key:
+                return None, "--- ERROR: GROQ_API_KEY not set. ---"
+            model = os.getenv("GROQ_WHISPER_MODEL", "whisper-large-v3")
+            url = "https://api.groq.com/openai/v1/audio/transcriptions"
+            headers = {"Authorization": f"Bearer {groq_key}"}
+            # Guess mime type by extension
+            filename = os.path.basename(audio_file_path)
+            mime = "audio/wav"
+            if filename.lower().endswith(".mp3"):
+                mime = "audio/mpeg"
+            elif filename.lower().endswith(".m4a"):
+                mime = "audio/mp4"
+            data = {
+                "model": model,
+                "response_format": "json",
+            }
+            with open(audio_file_path, "rb") as f:
+                files = {"file": (filename, f, mime)}
+                resp = requests.post(url, headers=headers, files=files, data=data, timeout=60)
+            if not resp.ok:
+                try:
+                    err = resp.json()
+                except Exception:
+                    err = {"error": resp.text}
+                return None, f"--- ERROR: Groq transcription error {resp.status_code}: {err} ---"
+            out = resp.json()
+            text = out.get("text")
+            if not text:
+                return None, "--- ERROR: Groq transcription returned no text. ---"
+            return text.strip(), None
+        except Exception:
+            return None, f"--- FATAL ERROR during Groq transcription: {traceback.format_exc()} ---"
+
+    def get_audio_duration(self, audio_file_path: str) -> Tuple[Optional[float], Optional[str]]:
+        """
+        Gets audio duration. Returns (duration, error_message).
+        """
+        try:
+            if not os.path.exists(audio_file_path):
+                return None, f"--- ERROR: Audio file for duration not found at: {audio_file_path} ---"
+            
+            duration = librosa.get_duration(path=audio_file_path)
+            if duration is None or duration < 0.1:
+                return None, f"--- ERROR: librosa returned an invalid duration: {duration}s ---"
+            return duration, None
+        except Exception as e:
+            error_msg = f"--- FATAL ERROR getting audio duration with librosa: {traceback.format_exc()} ---"
+            return None, error_msg
+    
+    def get_word_timestamps(self, audio_file_path: str) -> Tuple[List[Dict], List[str], Optional[str]]:
+        """
+        Generates timestamps. Returns (timestamps, log_messages).
+        """
+        logs = ["--- INFO: Starting get_word_timestamps... ---"]
+        
+        transcription, error, model_used = self.transcribe_audio(audio_file_path)
+        if error:
+            logs.append(error)
+            return [], logs, model_used
+        logs.append(f"--- DEBUG: Transcription successful. Text: '{transcription[:50]}...'")
+
+        audio_duration, error = self.get_audio_duration(audio_file_path)
+        if error:
+            logs.append(error)
+            return [], logs, model_used
+        logs.append(f"--- DEBUG: Audio duration successful. Duration: {audio_duration:.2f}s")
+        
+        words = transcription.split()
+        if not words:
+            logs.append("--- WARNING: Transcription resulted in zero words. ---")
+            return [], logs, model_used
+
+        logs.append(f"--- INFO: Distributing {len(words)} words across the duration. ---")
+        word_timestamps = []
+        total_words = len(words)
+        usable_duration = max(0, audio_duration - 1.0)
+
+        for i, word in enumerate(words):
+            start_time = 0.5 + (i * (usable_duration / total_words))
+            end_time = 0.5 + ((i + 1) * (usable_duration / total_words))
+            word_timestamps.append({'word': word.strip(), 'start': round(start_time, 3), 'end': round(end_time, 3)})
+
+        logs.append(f"--- SUCCESS: Generated {len(word_timestamps)} word timestamps. ---")
+        return word_timestamps, logs, model_used
+    
+    def get_word_timestamps_with_translation(self, audio_file_path: str, target_language: str = 'ar') -> Tuple[Dict, List[str]]:
+        """
+        Enhanced function that provides both transcription and translation
+        
+        Args:
+            audio_file_path: Path to audio file
+            target_language: Target language for translation ('ar' for Arabic)
+        
+        Returns:
+            Tuple of (result_dict, log_messages)
+            result_dict contains: {
+                'original_text': str,
+                'translated_text': str,
+                'word_timestamps': List[Dict],
+                'translated_timestamps': List[Dict],
+                'language_detected': str,
+                'target_language': str
+            }
+        """
+        logs = ["--- INFO: Starting enhanced transcription with translation... ---"]
+        
+        # Get original transcription and timestamps
+        word_timestamps, transcription_logs, model_used = self.get_word_timestamps(audio_file_path)
+        logs.extend(transcription_logs)
+
+        if not word_timestamps:
+            # Fallback: try plain transcription (Gemini → Groq) then synthesize timestamps
+            logs.append("--- INFO: Falling back to plain transcription because timestamps are empty. ---")
+            plain_text, err, model_used_fallback = self.transcribe_audio(audio_file_path)
+            if model_used_fallback:
+                model_used = model_used_fallback
+            if not plain_text:
+                logs.append(err or "--- ERROR: Plain transcription fallback failed ---")
+                return {}, logs
+            logs.append(f"--- SUCCESS: Plain transcription fallback succeeded. Model: {model_used}")
+            # Synthesize naive word-level timestamps across duration
+            try:
+                duration, derr = self.get_audio_duration(audio_file_path)
+                if derr:
+                    logs.append(derr)
+                    duration = 0.0
+                words = plain_text.split()
+                if not words:
+                    logs.append("--- WARNING: Fallback transcription produced zero words. ---")
+                    return {}, logs
+                if duration and duration > 0.1:
+                    usable_duration = max(0, duration - 1.0)
+                    start_offset = 0.5
+                else:
+                    # If duration not available, assume ~0.4s per word
+                    usable_duration = 0.4 * max(1, len(words))
+                    start_offset = 0.0
+                word_timestamps = []
+                total_words = len(words)
+                for i, w in enumerate(words):
+                    start_time = start_offset + (i * (usable_duration / total_words))
+                    end_time = start_offset + ((i + 1) * (usable_duration / total_words))
+                    word_timestamps.append({'word': w.strip(), 'start': round(start_time, 3), 'end': round(end_time, 3)})
+                logs.append(f"--- INFO: Synthesized {len(word_timestamps)} timestamps from fallback transcript. ---")
+            except Exception:
+                logs.append(f"--- FATAL ERROR synthesizing timestamps: {traceback.format_exc()} ---")
+                return {}, logs
+
+        # Extract original text
+        original_text = " ".join([d['word'] for d in word_timestamps])
+        logs.append(f"--- INFO: Original transcription: '{original_text[:50]}...' ---")
+
+        # Initialize result dictionary
+        result = {
+            'original_text': original_text,
+            'translated_text': '',
+            'word_timestamps': word_timestamps,
+            'translated_timestamps': [],
+            'language_detected': 'unknown',
+            'target_language': target_language,
+            'translation_success': False,
+            'transcription_model': model_used
+        }
+        
+        # Check if translator is available
+        if not self.translator:
+            logs.append("--- WARNING: Translator not available, returning original text only ---")
+            result['translated_text'] = original_text
+            return result, logs
+        
+        try:
+            # Translate the text
+            translated_text, translation_error = self.translator.translate_text(
+                original_text, 
+                target_language=target_language
+            )
+            
+            if translated_text:
+                result['translated_text'] = translated_text
+                result['translation_success'] = True
+                logs.append(f"--- SUCCESS: Translation completed: '{translated_text[:50]}...' ---")
+                
+                # Create translated timestamps by mapping words
+                translated_timestamps = self._create_translated_timestamps(
+                    word_timestamps, 
+                    original_text, 
+                    translated_text
+                )
+                result['translated_timestamps'] = translated_timestamps
+                logs.append(f"--- INFO: Created {len(translated_timestamps)} translated timestamps ---")
+                
+            else:
+                logs.append(f"--- ERROR: Translation failed: {translation_error} ---")
+                result['translated_text'] = original_text  # Fallback to original
+                result['translated_timestamps'] = word_timestamps  # Use original timestamps
+                
+        except Exception as e:
+            error_msg = f"--- FATAL ERROR during translation process: {traceback.format_exc()} ---"
+            logs.append(error_msg)
+            result['translated_text'] = original_text  # Fallback
+            result['translated_timestamps'] = word_timestamps
+        
+        return result, logs
+    
+    def _create_translated_timestamps(self, original_timestamps: List[Dict], original_text: str, translated_text: str) -> List[Dict]:
+        """
+        Create timestamps for translated text by proportional mapping
+        
+        Args:
+            original_timestamps: Original word timestamps
+            original_text: Original transcribed text
+            translated_text: Translated text
+        
+        Returns:
+            List of translated word timestamps
+        """
+        try:
+            translated_words = translated_text.split()
+            if not translated_words:
+                return []
+            
+            # Get total duration from original timestamps
+            if not original_timestamps:
+                return []
+            
+            start_time = original_timestamps[0]['start']
+            end_time = original_timestamps[-1]['end']
+            total_duration = end_time - start_time
+            
+            # Create proportional timestamps for translated words
+            translated_timestamps = []
+            word_count = len(translated_words)
+            
+            for i, word in enumerate(translated_words):
+                # Calculate proportional timing
+                word_start = start_time + (i * total_duration / word_count)
+                word_end = start_time + ((i + 1) * total_duration / word_count)
+                
+                translated_timestamps.append({
+                    'word': word.strip(),
+                    'start': round(word_start, 3),
+                    'end': round(word_end, 3)
+                })
+            
+            return translated_timestamps
+            
+        except Exception as e:
+            print(f"--- ERROR creating translated timestamps: {str(e)} ---")
+            return []
+    
+    def batch_translate_transcription(self, audio_file_path: str, target_languages: List[str]) -> Tuple[Dict, List[str]]:
+        """
+        Transcribe audio and translate to multiple languages
+        
+        Args:
+            audio_file_path: Path to audio file
+            target_languages: List of target language codes
+        
+        Returns:
+            Tuple of (results_dict, log_messages)
+        """
+        logs = ["--- INFO: Starting batch translation process... ---"]
+        
+        # Get original transcription
+        word_timestamps, transcription_logs = self.get_word_timestamps(audio_file_path)
+        logs.extend(transcription_logs)
+        
+        if not word_timestamps:
+            return {}, logs
+        
+        original_text = " ".join([d['word'] for d in word_timestamps])
+        
+        # Initialize results
+        results = {
+            'original': {
+                'text': original_text,
+                'timestamps': word_timestamps,
+                'language': 'detected'
+            },
+            'translations': {}
+        }
+        
+        # Translate to each target language
+        if self.translator:
+            for lang_code in target_languages:
+                try:
+                    translated_text, error = self.translator.translate_text(original_text, lang_code)
+                    if translated_text:
+                        translated_timestamps = self._create_translated_timestamps(
+                            word_timestamps, original_text, translated_text
+                        )
+                        results['translations'][lang_code] = {
+                            'text': translated_text,
+                            'timestamps': translated_timestamps,
+                            'success': True
+                        }
+                        logs.append(f"--- SUCCESS: Translation to {lang_code} completed ---")
+                    else:
+                        results['translations'][lang_code] = {
+                            'text': original_text,
+                            'timestamps': word_timestamps,
+                            'success': False,
+                            'error': error
+                        }
+                        logs.append(f"--- ERROR: Translation to {lang_code} failed: {error} ---")
+                except Exception as e:
+                    logs.append(f"--- FATAL ERROR translating to {lang_code}: {str(e)} ---")
+        else:
+            logs.append("--- WARNING: Translator not available for batch translation ---")
+        
+        return results, logs

check_credentials.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+# check_credentials.py - أداة فحص ملف بيانات الاعتماد
+
+import os
+import json
+
+def check_credentials():
+    """فحص ملف credentials.json والتأكد من صحته"""
+    
+    print("🔍 فحص ملف بيانات الاعتماد...")
+    print("=" * 50)
+    
+    # فحص وجود الملف
+    if not os.path.exists('credentials.json'):
+        print("❌ ملف credentials.json غير موجود!")
+        print("💡 تأكد من وضع الملف في نفس مجلد app.py")
+        return False
+    
+    print("✅ ملف credentials.json موجود")
+    
+    # فحص محتوى الملف
+    try:
+        with open('credentials.json', 'r') as f:
+            creds = json.load(f)
+        
+        print("✅ الملف يحتوي على JSON صحيح")
+        
+        # فحص البنية
+        if 'installed' not in creds:
+            print("❌ الملف لا يحتوي على قسم 'installed'")
+            return False
+        
+        installed = creds['installed']
+        
+        # فحص الحقول المطلوبة
+        required_fields = ['client_id', 'client_secret', 'auth_uri', 'token_uri']
+        missing_fields = []
+        
+        for field in required_fields:
+            if field not in installed:
+                missing_fields.append(field)
+        
+        if missing_fields:
+            print(f"❌ الحقول المفقودة: {', '.join(missing_fields)}")
+            return False
+        
+        # فحص إذا كانت البيانات وهمية
+        client_id = installed.get('client_id', '')
+        client_secret = installed.get('client_secret', '')
+        
+        if client_id.startswith('YOUR_CLIENT_ID'):
+            print("❌ client_id لا يزال يحتوي على القيمة الافتراضية!")
+            print("💡 يجب استبدال الملف بملف حقيقي من Google Cloud Console")
+            return False
+        
+        if client_secret.startswith('YOUR_CLIENT_SECRET'):
+            print("❌ client_secret لا يزال يحتوي على القيمة الافتراضية!")
+            print("💡 يجب استبدال الملف بملف حقيقي من Google Cloud Console")
+            return False
+        
+        print("✅ جميع الحقول المطلوبة موجودة")
+        print(f"✅ Client ID: {client_id[:20]}...")
+        print(f"✅ Project ID: {installed.get('project_id', 'غير محدد')}")
+        
+        return True
+        
+    except json.JSONDecodeError:
+        print("❌ الملف لا يحتوي على JSON صحيح!")
+        return False
+    except Exception as e:
+        print(f"❌ خطأ في قراءة الملف: {e}")
+        return False
+
+def check_token():
+    """فحص ملف token.json إذا كان موجوداً"""
+    
+    print("\n🔍 فحص ملف المصادقة...")
+    print("=" * 50)
+    
+    if os.path.exists('token.json'):
+        print("✅ ملف token.json موجود")
+        try:
+            with open('token.json', 'r') as f:
+                token = json.load(f)
+            
+            if 'token' in token:
+                print("✅ يحتوي على رمز مصادقة")
+            
+            if 'refresh_token' in token:
+                print("✅ يحتوي على رمز التحديث")
+            
+            if 'expiry' in token:
+                print(f"⏰ تاريخ انتهاء الصلاحية: {token['expiry']}")
+            
+        except Exception as e:
+            print(f"⚠️ مشكلة في ملف token.json: {e}")
+            print("💡 يمكنك حذف الملف وإعادة المصادقة")
+    else:
+        print("ℹ️ ملف token.json غير موجود (طبيعي في أول استخدام)")
+
+def main():
+    print("🚀 أداة فحص بيانات الاعتماد لـ Google Docs")
+    print("=" * 60)
+    
+    creds_ok = check_credentials()
+    check_token()
+    
+    print("\n" + "=" * 60)
+    
+    if creds_ok:
+        print("🎉 ملف بيانات الاعتماد صحيح!")
+        print("💡 يمكنك الآن استخدام زر التصدير")
+    else:
+        print("❌ يجب إصلاح ملف بيانات الاعتماد أولاً")
+        print("📋 راجع ملف GOOGLE_SETUP_SIMPLE.md للحصول على التعليمات")
+
+if __name__ == "__main__":
+    main()

comprehensive_test.py

@@ -0,0 +1,225 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+اختبار شامل للتحقق من إصلاح جميع المشاكل
+"""
+
+import requests
+import json
+import time
+
+def test_server_health():
+    """اختبار صحة الخادم"""
+    print("🏥 اختبار صحة الخادم...")
+    
+    try:
+        response = requests.get('http://localhost:5001/record', timeout=5)
+        if response.status_code == 200:
+            data = response.json()
+            print(f"✅ الخادم يعمل: {data.get('message')}")
+            return True
+        else:
+            print(f"❌ مشكلة في الخادم: {response.status_code}")
+            return False
+    except Exception as e:
+        print(f"❌ لا يمكن الوصول للخادم: {e}")
+        return False
+
+def test_cors_headers():
+    """اختبار CORS headers"""
+    print("\n🔧 اختبار CORS headers...")
+    
+    try:
+        # اختبار OPTIONS request
+        response = requests.options('http://localhost:5001/summarize', timeout=5)
+        
+        print(f"Status Code: {response.status_code}")
+        
+        # فحص CORS headers
+        cors_origin = response.headers.get('Access-Control-Allow-Origin')
+        cors_methods = response.headers.get('Access-Control-Allow-Methods')
+        cors_headers = response.headers.get('Access-Control-Allow-Headers')
+        
+        print(f"CORS Origin: '{cors_origin}'")
+        print(f"CORS Methods: '{cors_methods}'")
+        print(f"CORS Headers: '{cors_headers}'")
+        
+        # التحقق من عدم وجود قيم مكررة
+        if cors_origin and ',' in cors_origin and cors_origin.count('*') > 1:
+            print("❌ مشكلة: CORS Origin يحتوي على قيم مكررة!")
+            return False
+        elif cors_origin == '*':
+            print("✅ CORS Origin صحيح")
+            return True
+        else:
+            print(f"⚠️ CORS Origin غير متوقع: {cors_origin}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ خطأ في اختبار CORS: {e}")
+        return False
+
+def test_summarization():
+    """اختبار وظيفة التلخيص"""
+    print("\n🤖 اختبار وظيفة التلخيص...")
+    
+    test_data = {
+        "text": "Hello, how are you? What are you doing today? Tell me about your work and your plans.",
+        "language": "arabic",
+        "type": "full"
+    }
+    
+    try:
+        response = requests.post(
+            'http://localhost:5001/summarize',
+            json=test_data,
+            headers={'Content-Type': 'application/json'},
+            timeout=30
+        )
+        
+        print(f"Status Code: {response.status_code}")
+        
+        if response.status_code == 200:
+            data = response.json()
+            if data.get('success'):
+                print("✅ التلخيص نجح!")
+                summary = data.get('summary', '')
+                print(f"الملخص: {summary[:100]}...")
+                return True
+            else:
+                print(f"❌ فشل التلخيص: {data.get('error')}")
+                return False
+        else:
+            print(f"❌ خطأ HTTP: {response.status_code}")
+            print(f"الرد: {response.text}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ خطأ في اختبار التلخيص: {e}")
+        return False
+
+def test_javascript_syntax():
+    """اختبار صيغة JavaScript"""
+    print("\n📝 اختبار صيغة JavaScript...")
+    
+    try:
+        with open('templates/recorder.html', 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        # فحص بسيط للأقواس
+        js_start = content.find('<script>')
+        js_end = content.find('</script>')
+        
+        if js_start == -1 or js_end == -1:
+            print("❌ لا يمكن العثور على JavaScript")
+            return False
+        
+        js_content = content[js_start:js_end]
+        
+        # عد الأقواس
+        open_braces = js_content.count('{')
+        close_braces = js_content.count('}')
+        
+        print(f"أقواس فتح: {open_braces}")
+        print(f"أقواس إغلاق: {close_braces}")
+        
+        if open_braces == close_braces:
+            print("✅ الأقواس متوازنة")
+            
+            # فحص للكلمات المفتاحية الأساسية
+            if 'function' in js_content and 'async function' in js_content:
+                print("✅ الدوال موجودة")
+                return True
+            else:
+                print("⚠️ لا يمكن العثور على الدوال")
+                return False
+        else:
+            print(f"❌ الأقواس غير متوازنة! الفرق: {open_braces - close_braces}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ خطأ في فحص JavaScript: {e}")
+        return False
+
+def test_translation_endpoints():
+    """اختبار endpoints الترجمة"""
+    print("\n🌐 اختبار endpoints الترجمة...")
+    
+    try:
+        # اختبار قائمة اللغات
+        response = requests.get('http://localhost:5001/languages', timeout=5)
+        if response.status_code == 200:
+            print("✅ endpoint اللغات يعمل")
+        else:
+            print(f"⚠️ مشكلة في endpoint اللغات: {response.status_code}")
+        
+        # اختبار UI translations
+        response = requests.get('http://localhost:5001/ui-translations/en', timeout=5)
+        if response.status_code == 200:
+            print("✅ endpoint UI translations يعمل")
+        else:
+            print(f"⚠️ مشكلة في endpoint UI translations: {response.status_code}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ خطأ في اختبار endpoints الترجمة: {e}")
+        return False
+
+def comprehensive_test():
+    """اختبار شامل لجميع الوظائف"""
+    print("🚀 بدء الاختبار الشامل")
+    print("=" * 60)
+    
+    tests = [
+        ("صحة الخادم", test_server_health),
+        ("CORS Headers", test_cors_headers),
+        ("وظيفة التلخيص", test_summarization),
+        ("صيغة JavaScript", test_javascript_syntax),
+        ("endpoints الترجمة", test_translation_endpoints)
+    ]
+    
+    results = []
+    
+    for test_name, test_func in tests:
+        print(f"\n🧪 اختبار: {test_name}")
+        print("-" * 40)
+        
+        try:
+            result = test_func()
+            results.append((test_name, result))
+            
+            if result:
+                print(f"✅ {test_name}: نجح")
+            else:
+                print(f"❌ {test_name}: فشل")
+                
+        except Exception as e:
+            print(f"❌ {test_name}: خطأ - {e}")
+            results.append((test_name, False))
+    
+    # النتائج النهائية
+    print("\n" + "=" * 60)
+    print("📊 ملخص نتائج الاختبار:")
+    print("=" * 60)
+    
+    passed = 0
+    total = len(results)
+    
+    for test_name, result in results:
+        status = "✅ نجح" if result else "❌ فشل"
+        print(f"  {test_name}: {status}")
+        if result:
+            passed += 1
+    
+    print(f"\nالنتيجة النهائية: {passed}/{total} اختبارات نجحت")
+    
+    if passed == total:
+        print("🎉 جميع الاختبارات نجحت! النظام يعمل بشكل مثالي")
+        return True
+    else:
+        print(f"⚠️ {total - passed} اختبارات فشلت - هناك مشاكل تحتاج إصلاح")
+        return False
+
+if __name__ == "__main__":
+    comprehensive_test()

credentials.json

@@ -0,0 +1,16 @@
+{
+  "web": {
+    "client_id": "739771741359-gk2mkvimn063a2msd6hmkkksn17iamre.apps.googleusercontent.com",
+    "project_id": "syncmaster-export",
+    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+    "token_uri": "https://oauth2.googleapis.com/token",
+    "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+    "client_secret": "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",
+    "redirect_uris": [
+      "http://localhost:8502",
+      "http://localhost:8502/",
+      "http://127.0.0.1:8502",
+      "http://127.0.0.1:8502/"
+    ]
+  }
+}

custom_components/st-audiorec/.streamlit/config.toml

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8eec7cce049f088766524596c7dd6229756df0d6331c8cfab099df7d2ebc9d5d
+size 662

custom_components/st-audiorec/LICENCE

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:784d3a6fdb08d429f5de43125e9962e780d34cdf9b5f14b681c9a2d8e905bfec
+size 1080

custom_components/st-audiorec/README.md

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:54716e3eaf4e6047fb50d99176bd2c6b24124b978af2eb30e44a8c6a74cdb9c0
+size 1993

custom_components/st-audiorec/demo.py

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:efbe93ef9297821f3a1e1f1bdf0f75fb4a4351b154439d01d9ea0cbd49b996b8
+size 2430

custom_components/st-audiorec/setup.py

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:492fd555416f2807df31dc43e10b9d3cd8d5c18636c586c7f37988e1d8b854c1
+size 786

custom_components/st-audiorec/st_audiorec/__init__.py

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f714847f1f4a2490e5dd80bc1eeb7b6fcb7850a3e682b491a28dd30fead486c
+size 1622

custom_components/st-audiorec/st_audiorec/frontend/.prettierrc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3375a44313ae0b6753868a7ae00dc03f618b0c23785b15980482e6b9457ca0f8
+size 72

custom_components/st-audiorec/st_audiorec/frontend/build/asset-manifest.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d923ea03d2475f02335299c4a15a1ca84291e9cbbcd558e6abdb318abe5ccc6f
+size 859

custom_components/st-audiorec/st_audiorec/frontend/build/bootstrap.min.css

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f396767523d7b7ce621d90aae93cbbd7a516275898efd19020be38aa5ae85d5c
+size 206913

custom_components/st-audiorec/st_audiorec/frontend/build/index.html

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e007dc7fb036886292b996d076d57c6eb6eedf32b8e2c5489ad9f6d29d59f088
+size 2175

custom_components/st-audiorec/st_audiorec/frontend/build/precache-manifest.30096e2fd9f149157a833e729e772f72.js

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e318206d88822468d480fd4047df1439dd2dadb500d846636314b39afabb8af4
+size 564

custom_components/st-audiorec/st_audiorec/frontend/build/service-worker.js

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8243bfeb139d7acdf475a748daa48068cde6e5d62a4c2242326e3d6bbfbc6d78
+size 1183

custom_components/st-audiorec/st_audiorec/frontend/build/static/js/2.ca2bba73.chunk.js

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8810a6d23c8292fa11953f5c2c762e6bd658f11316f12879d0a6d4e05f7df5a1
+size 465885

custom_components/st-audiorec/st_audiorec/frontend/build/static/js/2.ca2bba73.chunk.js.LICENSE.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:83bbf722e5b20cfb2920ac1c234ffa5ccde3baa9d8d5a87b4cc90f81ef649a47
+size 1653

custom_components/st-audiorec/st_audiorec/frontend/build/static/js/2.ca2bba73.chunk.js.map

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:25cecefabe1287205f5f99bfd33159566c8d97bc56dadba39d70fcaf160c7998
+size 1634044

custom_components/st-audiorec/st_audiorec/frontend/build/static/js/main.85742990.chunk.js

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:28cf7e640dbe5e67fdde3e5e4eea1d9053901a0612be430efdd2968509feb279
+size 13457

custom_components/st-audiorec/st_audiorec/frontend/build/static/js/main.85742990.chunk.js.map

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b9c4877643f7494e0fea5996bc57d8667c1258cb58311d1d530a957303ffd698
+size 38454