fix

app.py

@@ -1,4 +1,4 @@
-# app.py - Final, Corrected, and Heavily Logged Version
+# app.py - Refactored to eliminate recorder_server.py dependency
 
 import streamlit as st
 import os
@@ -8,28 +8,7 @@ from pathlib import Path
 import time
 import traceback
 import streamlit.components.v1 as components
-
-# --- Integrated Server Import ---
-import threading
-
-# Global variable to track server status
-recorder_server_status = {"started": False, "error": None}
-
-def start_recorder_async():
-    """Start recorder server in background thread"""
-    try:
-        from integrated_server import ensure_recorder_server, stop_all_servers
-        result = ensure_recorder_server()
-        recorder_server_status["started"] = result
-        # Make stop_all_servers available globally
-        globals()['stop_all_servers'] = stop_all_servers
-    except Exception as e:
-        recorder_server_status["error"] = str(e)
-        print(f"Warning: Could not start integrated recorder server: {e}")
-
-# Start recorder server in background to avoid blocking UI
-recorder_thread = threading.Thread(target=start_recorder_async, daemon=True)
-recorder_thread.start()
+from st_audiorec import st_audiorec  # Import the new recorder component
 
 # --- Critical Imports and Initial Checks ---
 AUDIO_PROCESSOR_CLASS = None
@@ -42,8 +21,27 @@ except Exception:
 
 from video_generator import VideoGenerator
 from mp3_embedder import MP3Embedder
-from utils import format_timestamp, validate_audio_file, get_audio_info
-from translator import get_translator, get_translation, UI_TRANSLATIONS
+from utils import format_timestamp
+from translator import get_translator, UI_TRANSLATIONS
+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
 
 # --- Page Configuration ---
 st.set_page_config(
@@ -86,8 +84,8 @@ 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_file' not in st.session_state:
-        st.session_state.audio_file = None
+    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:
@@ -104,12 +102,96 @@ def initialize_session_state():
             '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
+
+# --- Centralized Audio Processing Function ---
+def run_audio_processing(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.
+    """
+    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')
+            }
+            st.session_state.edited_text = result_data['original_text']
+
+        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
+            }
+            st.session_state.edited_text = full_text
+
+        st.session_state.step = 2
+        st.success("🎉 AI processing complete! Please review the results.")
+        
+    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()} ---")
+    finally:
+        if tmp_file_path and os.path.exists(tmp_file_path):
+            os.unlink(tmp_file_path)
+
+    time.sleep(1)
+    st.rerun()
+
 
 # --- Main Application Logic ---
 def main():
     initialize_session_state()
     
-    # Apply fast loading optimizations
     st.markdown("""
     <style>
     .stSpinner { display: none !important; }
@@ -119,11 +201,6 @@ def main():
     </style>
     """, unsafe_allow_html=True)
     
-    # Check recorder server status (non-blocking)
-    if recorder_server_status.get("error"):
-        st.warning(f"⚠️ Recorder server issue: {recorder_server_status['error']}")
-    
-    # Language Selection in sidebar
     with st.sidebar:
         st.markdown("## 🌐 Language Settings")
         language_options = {'English': 'en', 'العربية': 'ar'}
@@ -134,7 +211,6 @@ def main():
         )
         st.session_state.language = language_options[selected_lang_display]
         
-        # Translation Settings
         st.markdown("## 🔤 Translation Settings")
         st.session_state.enable_translation = st.checkbox(
             "Enable AI Translation" if st.session_state.language == 'en' else "تفعيل الترجمة بالذكاء الاصطناعي",
@@ -144,48 +220,27 @@ def main():
         
         if st.session_state.enable_translation:
             target_lang_options = {
-                'Arabic (العربية)': 'ar',
-                'English': 'en', 
-                'French (Français)': 'fr',
-                'Spanish (Español)': 'es'
+                '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
+                options=list(target_lang_options.keys()), index=0
             )
             st.session_state.target_language = target_lang_options[selected_target]
     
-    # Get translations for current language
-    current_translations = UI_TRANSLATIONS.get(st.session_state.language, UI_TRANSLATIONS['en'])
-    
-    # Main title with translation support
     st.title("🎵 SyncMaster")
     if st.session_state.language == 'ar':
         st.markdown("### منصة المزامنة الذكية بين الصوت والنص")
-        st.markdown("حول ملفاتك الصوتية إلى ملفات MP3 متوافقة مع الأجهزة المحمولة مع كلمات متزامنة ومقاطع فيديو MP4 متحركة.")
     else:
         st.markdown("### The Intelligent Audio-Text Synchronization Platform")
-        st.markdown("Transform your audio files into mobile-compatible MP3s with synchronized lyrics and animated MP4 videos.")
     
     col1, col2, col3 = st.columns(3)
-    
     with col1:
-        if st.session_state.step >= 1:
-            st.success("Step 1: Upload & Process")
-        else:
-            st.info("Step 1: Upload & Process")
+        st.markdown(f"**{'✅' if st.session_state.step >= 1 else '1️⃣'} Step 1: Upload & Process**")
     with col2:
-        if st.session_state.step >= 2:
-            st.success("Step 2: Review & Customize")
-        else:
-            st.info("Step 2: Review & Customize")
+        st.markdown(f"**{'✅' if st.session_state.step >= 2 else '2️⃣'} Step 2: Review & Customize**")
     with col3:
-        if st.session_state.step >= 3:
-            st.success("Step 3: Export")
-        else:
-            st.info("Step 3: Export")
-            
+        st.markdown(f"**{'✅' if st.session_state.step >= 3 else '3️⃣'} Step 3: Export**")
     st.divider()
 
     if AUDIO_PROCESSOR_CLASS is None:
@@ -211,167 +266,28 @@ def step_1_upload_and_process():
         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_file = uploaded_file
-            st.success(f"File uploaded: {uploaded_file.name}")
-            st.audio(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):
-                process_audio()
-        if st.session_state.audio_file:
-            if st.button("🔄 Upload Different File"):
+                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")
-        st.info("Use the recorder below. After processing, copy the resulting file path and paste it here.")
-        
-        # Show the recorder component
-        show_recorder_page()
+        st.info("Click the microphone icon to start recording. Click the stop icon when you are finished. Processing will begin automatically.")
         
-        st.divider()
-
-        # Input for the file path
-        result_file_path = st.text_input("Paste the result file path here:")
-
-        if st.button("Process Recorded Audio", use_container_width=True):
-            if result_file_path and os.path.exists(result_file_path):
-                process_recorded_audio(result_file_path)
-            else:
-                st.error("Please provide a valid file path.")
-
-def show_recorder_page():
-    """Renders the HTML for the recorder page."""
-    try:
-        with open('templates/recorder.html', 'r', encoding='utf-8') as f:
-            html_string = f.read()
-        components.html(html_string, height=650, scrolling=True)
-    except FileNotFoundError:
-        st.error("Could not find the recorder HTML file. Please ensure 'templates/recorder.html' exists.")
-
-def process_recorded_audio(file_path):
-    """Processes the audio data from the recorded file."""
-    log_to_browser_console("--- INFO: Starting recorded audio processing. ---")
-    try:
-        with open(file_path, 'r') as f:
-            data = json.load(f)
-        log_to_browser_console(f"--- DEBUG: Loaded data from {file_path}. ---")
-
-        # Convert hex back to bytes
-        data['audio_bytes'] = bytes.fromhex(data['audio_bytes'])
-        log_to_browser_console("--- DEBUG: Converted hex audio data to bytes. ---")
-
-        st.session_state.transcription_data = data
-        st.session_state.edited_text = data['text']
-        st.session_state.step = 2
-        st.success("🎉 Recording processed successfully! Please review the results.")
-        log_to_browser_console("--- SUCCESS: Recording processed and session updated. ---")
-        
-    except Exception as e:
-        st.error(f"An error occurred while processing the recorded audio: {e}")
-        log_to_browser_console(f"--- FATAL ERROR in process_recorded_audio: {traceback.format_exc()} ---")
-    finally:
-        if os.path.exists(file_path):
-            os.unlink(file_path)
-            log_to_browser_console(f"--- DEBUG: Cleaned up temp file: {file_path}")
-    
-    time.sleep(1)
-    st.rerun()
-
-def process_audio():
-    if not st.session_state.audio_file:
-        st.error("No audio file found.")
-        return
-    
-    tmp_file_path = None
-    log_to_browser_console("--- INFO: Starting enhanced audio processing with translation. ---")
-    try:
-        with tempfile.NamedTemporaryFile(delete=False, suffix=Path(st.session_state.audio_file.name).suffix) as tmp_file:
-            st.session_state.audio_file.seek(0)
-            tmp_file.write(st.session_state.audio_file.getvalue())
-            tmp_file_path = tmp_file.name
-        
-        processor = AUDIO_PROCESSOR_CLASS()
-
-        # Enhanced processing with translation support
-        if st.session_state.enable_translation:
-            with st.spinner("🎤 Performing AI processing (Transcription, Timestamps & Translation)..."):
-                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 the browser console (F12) for detailed error logs.")
-                return
-            
-            # Store enhanced results
-            word_timestamps = result_data['word_timestamps']
-            full_text = result_data['original_text']
-            translated_text = result_data['translated_text']
-            translation_success = result_data.get('translation_success', False)
-            detected_language = result_data.get('language_detected', 'unknown')
-            
-            # Show translation results
-            if translation_success and translated_text != full_text:
-                st.success(f"🌐 Translation completed successfully! Detected language: {detected_language}")
-                
-                col1, col2 = st.columns(2)
-                with col1:
-                    st.subheader("Original Text")
-                    st.text_area("Original Transcription", value=full_text, height=150, disabled=True)
-                
-                with col2:
-                    st.subheader(f"Translation ({st.session_state.target_language.upper()})")
-                    st.text_area("Translated Text", value=translated_text, height=150, disabled=True)
-                
-                # Store both versions
-                st.session_state.translated_text = translated_text
-                st.session_state.translation_success = True
-            else:
-                st.info("Translation was requested but may not have been successful.")
-                st.session_state.translation_success = False
-        
-        else:
-            # Standard processing without translation
-            with st.spinner("🎤 Performing AI processing (Transcription & Timestamps)..."):
-                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 the browser console (F12) for detailed error logs.")
-                return
-            
-            full_text = " ".join([d['word'] for d in word_timestamps])
-            st.session_state.translation_success = False
-
-        st.session_state.audio_file.seek(0)
-        audio_bytes = st.session_state.audio_file.read()
-
-        st.session_state.transcription_data = {
-            'text': full_text, # Use the text we derived
-            'word_timestamps': word_timestamps,
-            'audio_bytes': audio_bytes,
-            'original_suffix': Path(st.session_state.audio_file.name).suffix
-        }
-        st.session_state.edited_text = full_text
-        st.session_state.step = 2
-        st.success("🎉 AI processing complete! Please review the results.")
-        
-    except Exception as e:
-        st.error("An unexpected error occurred in the main processing flow!")
-        st.exception(e)
-        log_to_browser_console(f"--- FATAL ERROR in app.py's process_audio: {traceback.format_exc()} ---")
-    finally:
-        if tmp_file_path and os.path.exists(tmp_file_path):
-            os.unlink(tmp_file_path)
-
-    time.sleep(1)
-    st.rerun()
-
+        # Use the audio recorder component
+        wav_audio_data = st_audiorec()
 
+        # If a new recording is made, process it automatically
+        if wav_audio_data is not None and st.session_state.new_recording != wav_audio_data:
+            st.session_state.new_recording = wav_audio_data
+            # Immediately process the new recording
+            run_audio_processing(st.session_state.new_recording, "recorded_audio.wav")
 
 # --- Step 2: Review and Customize ---
 def step_2_review_and_customize():
@@ -381,9 +297,22 @@ def step_2_review_and_customize():
         if st.button("← Back to Step 1"):
             st.session_state.step = 1; st.rerun()
         return
+
+    # Display translation results if available
+    if st.session_state.transcription_data.get('translation_success', False):
+        st.success(f"🌐 Translation completed! Detected language: {st.session_state.transcription_data.get('detected_language', 'N/A')}")
+        col1, col2 = st.columns(2)
+        with col1:
+            st.subheader("Original Text")
+            st.text_area("Original Transcription", value=st.session_state.transcription_data['text'], height=150, disabled=True)
+        with col2:
+            st.subheader(f"Translation ({st.session_state.target_language.upper()})")
+            st.text_area("Translated Text", value=st.session_state.transcription_data['translated_text'], height=150, disabled=True)
+    
     col1, col2 = st.columns([3, 2])
     with col1:
         st.subheader("📝 Text Editor")
+        st.info("Edit the original transcribed text below. This text will be used for the final export.")
         edited_text = st.text_area("Transcribed Text", value=st.session_state.edited_text, height=300)
         st.session_state.edited_text = edited_text
     with col2:
@@ -427,26 +356,23 @@ def step_3_export():
         if st.button("🔄 Start Over"):
             reset_session(); st.rerun()
 
-# --- MP3 Export Function (with robust stateless logic and logging) ---
+# --- MP3 Export Function ---
 def export_mp3():
     audio_path_for_export = None
     log_to_browser_console("--- INFO: Starting MP3 export process. ---")
     try:
-        with st.spinner("Embedding lyrics..."):
+        with st.spinner("⏳ Exporting MP3... Please wait, this may take a moment."):
             suffix = st.session_state.transcription_data['original_suffix']
             audio_bytes = st.session_state.transcription_data['audio_bytes']
-            log_to_browser_console(f"--- DEBUG: Retrieved {len(audio_bytes) / 1024:.2f} KB of audio data from session_state.")
-
+            
             with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp_audio_file:
                 tmp_audio_file.write(audio_bytes)
                 audio_path_for_export = tmp_audio_file.name
-            log_to_browser_console(f"--- DEBUG: Temp file for export created at: {audio_path_for_export}")
 
             embedder = MP3Embedder()
             word_timestamps = st.session_state.transcription_data['word_timestamps']
-            log_to_browser_console(f"--- DEBUG: Passing {len(word_timestamps)} timestamps to embedder.")
             
-            output_filename = f"synced_{Path(st.session_state.audio_file.name).stem}.mp3"
+            output_filename = f"synced_{Path(st.session_state.transcription_data.get('original_filename', 'audio')).stem}.mp3"
             
             output_path, log_messages = embedder.embed_sylt_lyrics(
                 audio_path_for_export, word_timestamps, 
@@ -461,9 +387,6 @@ def export_mp3():
             st.audio(audio_bytes_to_download, format='audio/mp3')
 
             verification = embedder.verify_sylt_embedding(output_path)
-            log_to_browser_console(f"--- DEBUG: Verification result: {json.dumps(verification)}")
-            st.json(verification)
-            
             if verification.get('has_sylt'):
                 st.success(f"Successfully embedded {verification.get('sylt_entries', 0)} words!")
             else:
@@ -473,7 +396,6 @@ def export_mp3():
                                output_filename, "audio/mpeg", use_container_width=True)
         else:
             st.error("Failed to create the final MP3 file.")
-            log_to_browser_console(f"--- ERROR: Final output file not found at expected path: {output_path}")
             
     except Exception as e:
         st.error(f"An unexpected error occurred during MP3 export: {e}")
@@ -481,16 +403,17 @@ def export_mp3():
     finally:
         if audio_path_for_export and os.path.exists(audio_path_for_export):
             os.unlink(audio_path_for_export)
-            log_to_browser_console(f"--- DEBUG: Cleaned up temp export file: {audio_path_for_export}")
 
 # --- Placeholder and Utility Functions ---
 def export_mp4():
+    with st.spinner("⏳ Preparing video export..."):
+        time.sleep(1) # Simulate work to provide feedback
     st.info("MP4 export functionality is not yet implemented.")
 
 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_file', 'transcription_data', 'edited_text', 'video_style']
+    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]
@@ -498,31 +421,6 @@ def reset_session():
 
 # --- Entry Point ---
 if __name__ == "__main__":
-    # Compatibility Patches for older Streamlit versions
-    import inspect as _st_inspect
-    if "type" not in _st_inspect.signature(st.button).parameters:
-        _orig_button = st.button
-        def _patched_button(label, *args, **kwargs):
-            kwargs.pop("type", None); kwargs.pop("use_container_width", None)
-            return _orig_button(label, *args, **kwargs)
-        st.button = _patched_button
-    if hasattr(st, "download_button"):
-        import inspect as _dl_inspect
-        _dl_sig = _dl_inspect.signature(st.download_button)
-        if "use_container_width" not in _dl_sig.parameters:
-            _orig_download_button = st.download_button
-            def _patched_download_button(label, data, *args, **kwargs):
-                kwargs.pop("use_container_width", None)
-                return _orig_download_button(label, data, *args, **kwargs)
-            st.download_button = _patched_download_button
-
-    # Setup cleanup handler
-    import atexit
-    try:
-        from integrated_server import stop_all_servers
-        atexit.register(stop_all_servers)
-    except ImportError:
-        pass
-
-    initialize_session_state()
-    main()
+    if check_api_key():
+        initialize_session_state()
+        main()

audio_processor.py

@@ -17,26 +17,14 @@ import librosa
 
 import google.generativeai as genai
 from translator import AITranslator
+from google.api_core import exceptions as google_exceptions
 
 class AudioProcessor:
     def __init__(self):
-        self.client = None
         self.translator = None
         self.init_error = None
-        self._initialize_gemini()
         self._initialize_translator()
-    
-    def _initialize_gemini(self):
-        try:
-            load_dotenv()
-            api_key = os.getenv("GEMINI_API_KEY")
-            if not api_key:
-                raise ValueError("GEMINI_API_KEY not found in environment variables.")
-            self.client = genai.Client(api_key=api_key)
-        except Exception as e:
-            self.init_error = f"--- FATAL ERROR during Gemini Init: {str(e)} ---"
-            self.client = None
-    
+
     def _initialize_translator(self):
         """Initialize AI translator for multi-language support"""
         try:
@@ -51,31 +39,26 @@ class AudioProcessor:
         """
         Transcribes audio. Returns (text, error_message).
         """
-        if self.init_error:
-            return None, self.init_error
-        if not self.client:
-            return None, "--- ERROR: Gemini client is not available. ---"
+        if not self.translator or not self.translator.model:
+            return None, "--- ERROR: Translator model is not available for transcription. ---"
         
         try:
             if not os.path.exists(audio_file_path):
                 return None, f"--- ERROR: Audio file for transcription not found at: {audio_file_path} ---"
             
-            with open(audio_file_path, 'rb') as f:
-                audio_bytes = f.read()
+            audio_file = genai.upload_file(path=audio_file_path)
             
-            file_ext = os.path.splitext(audio_file_path)[1].lower()
-            mime_type = {'mp3': 'audio/mpeg', 'wav': 'audio/wav', 'm4a': 'audio/mp4'}.get(file_ext, 'audio/mpeg')
+            prompt = "Transcribe this audio file accurately. Provide only the text content."
+            response = self.translator.model.generate_content([prompt, audio_file])
 
-            response = self.client.models.generate_content(
-                model="gemini-2.5-flash",
-                contents=[genai.Part.from_bytes(data=audio_bytes, mime_type=mime_type), "Transcribe this audio."]
-            )
-            
-            if response and response.text:
+            if response and hasattr(response, 'text') and response.text:
                 return response.text.strip(), None
             else:
                 return None, "--- WARNING: Gemini returned an empty response for transcription. ---"
                 
+        except google_exceptions.ResourceExhausted:
+            error_msg = "--- 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. ---"
+            return None, error_msg
         except Exception as e:
             error_msg = f"--- FATAL ERROR during transcription: {traceback.format_exc()} ---"
             return None, error_msg
@@ -330,4 +313,4 @@ class AudioProcessor:
         else:
             logs.append("--- WARNING: Translator not available for batch translation ---")
         
-        return results, logs
+        return results, logs

integrated_server.py

@@ -1,235 +0,0 @@
-"""
-Integrated Server Module
-يدمج خادم Flask للتسجيل مع تطبيق Streamlit
-"""
-
-import threading
-import time
-import logging
-import sys
-import subprocess
-import os
-import socket
-from pathlib import Path
-
-# Import configuration
-try:
-    from app_config import config
-except ImportError:
-    # Fallback configuration
-    class FallbackConfig:
-        RECORDER_PORT = 5001
-        RECORDER_HOST = "localhost"
-        USE_INTEGRATED_SERVER = True
-    config = FallbackConfig()
-
-# Configure logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-
-def is_port_in_use(port):
-    """Check if a port is already in use"""
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        try:
-            s.bind(('localhost', port))
-            return False
-        except socket.error:
-            return True
-
-class IntegratedServer:
-    def __init__(self):
-        self.flask_process = None
-        self.flask_thread = None
-        self.is_running = False
-        self.port = config.RECORDER_PORT
-        self.host = config.RECORDER_HOST
-        
-    def start_recorder_server_thread(self):
-        """Start the recorder server in a separate thread"""
-        try:
-            # Check if port is already in use
-            if is_port_in_use(self.port):
-                logging.info(f"✅ Port {self.port} already in use, assuming recorder server is running")
-                self.is_running = True
-                return True
-            
-            # Import Flask app from recorder_server
-            from recorder_server import app
-            
-            # Configure Flask to run without debug mode
-            app.config['DEBUG'] = False
-            app.config['TESTING'] = False
-            
-            # Run Flask app in thread
-            def run_flask():
-                try:
-                    app.run(
-                        host=self.host,
-                        port=self.port,
-                        debug=False,
-                        use_reloader=False,
-                        threaded=True
-                    )
-                except Exception as e:
-                    logging.error(f"Error running Flask server: {e}")
-            
-            self.flask_thread = threading.Thread(target=run_flask, daemon=True)
-            self.flask_thread.start()
-            
-            # Wait for server to start with shorter intervals
-            max_retries = 15
-            for i in range(max_retries):
-                time.sleep(0.5)  # Reduced from 1 second to 0.5 seconds
-                if self.is_server_responding():
-                    self.is_running = True
-                    logging.info(f"✅ Recorder server started successfully on port {self.port}")
-                    return True
-                if i < 5:  # Only log first few attempts to reduce noise
-                    logging.info(f"⏳ Waiting for recorder server to start... ({i+1}/{max_retries})")
-            
-            logging.warning("⚠️ Recorder server thread started but not responding")
-            return False
-                
-        except Exception as e:
-            logging.error(f"❌ Failed to start recorder server thread: {e}")
-            return False
-    
-    def start_recorder_server_process(self):
-        """Start the recorder server as a separate process (fallback method)"""
-        try:
-            # Check if port is already in use
-            if is_port_in_use(self.port):
-                logging.info(f"✅ Port {self.port} already in use, assuming recorder server is running")
-                self.is_running = True
-                return True
-            
-            # Start recorder server as subprocess
-            self.flask_process = subprocess.Popen(
-                [sys.executable, 'recorder_server.py'],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                cwd=os.getcwd()
-            )
-            
-            # Wait for server to start with shorter intervals
-            max_retries = 20
-            for i in range(max_retries):
-                time.sleep(0.5)  # Reduced from 1 second to 0.5 seconds
-                
-                # Check if process is still running
-                if self.flask_process.poll() is not None:
-                    logging.error("❌ Recorder server process terminated")
-                    return False
-                
-                # Check if server is responding
-                if self.is_server_responding():
-                    self.is_running = True
-                    logging.info(f"✅ Recorder server started successfully as subprocess on port {self.port}")
-                    return True
-                    
-                if i < 5:  # Only log first few attempts
-                    logging.info(f"⏳ Waiting for recorder server to respond... ({i+1}/{max_retries})")
-            
-            logging.warning("⚠️ Recorder server process started but not responding")
-            return False
-                
-        except Exception as e:
-            logging.error(f"❌ Failed to start recorder server process: {e}")
-            return False
-    
-    def start_recorder_server(self):
-        """Start recorder server using the best available method"""
-        logging.info("🚀 Starting integrated recorder server...")
-        
-        # If already running, don't start again
-        if self.is_running and self.is_server_responding():
-            logging.info("✅ Recorder server already running and responding")
-            return True
-        
-        # Try thread method first (cleaner for integration)
-        if self.start_recorder_server_thread():
-            logging.info("✅ Recorder server started using thread method")
-            return True
-        
-        # Fallback to process method
-        logging.info("⚠️ Thread method failed, trying process method...")
-        if self.start_recorder_server_process():
-            logging.info("✅ Recorder server started using process method")
-            return True
-        
-        logging.error("❌ Failed to start recorder server using any method")
-        return False
-    
-    def stop_recorder_server(self):
-        """Stop the recorder server"""
-        try:
-            if self.flask_process and self.flask_process.poll() is None:
-                self.flask_process.terminate()
-                try:
-                    self.flask_process.wait(timeout=5)
-                    logging.info("✅ Recorder server process terminated")
-                except subprocess.TimeoutExpired:
-                    self.flask_process.kill()
-                    logging.info("⚠️ Recorder server process killed")
-            
-            self.is_running = False
-            
-        except Exception as e:
-            logging.error(f"❌ Error stopping recorder server: {e}")
-    
-    def is_server_responding(self):
-        """Check if the recorder server is responding"""
-        try:
-            import requests
-            # Very fast check - reduce timeout further
-            response = requests.get(f'http://{self.host}:{self.port}/record', timeout=0.5)
-            return response.status_code == 200
-        except:
-            return False
-    
-    def is_server_running(self):
-        """Check if the recorder server is running"""
-        return self.is_running and self.is_server_responding()
-
-# Global instance
-integrated_server = IntegratedServer()
-
-def ensure_recorder_server():
-    """Ensure recorder server is running, start if not"""
-    try:
-        # Quick check first - if server responds immediately, no delay
-        if integrated_server.is_server_responding():
-            logging.info("✅ Recorder server already running")
-            integrated_server.is_running = True
-            return True
-        
-        # Only start if not detected
-        logging.info("🔄 Recorder server not detected, starting...")
-        result = integrated_server.start_recorder_server()
-        return result
-    except Exception as e:
-        logging.error(f"❌ Error in ensure_recorder_server: {e}")
-        return False
-
-def stop_all_servers():
-    """Stop all integrated servers"""
-    integrated_server.stop_recorder_server()
-
-# Auto-start when module is imported (but not in main)
-if __name__ != "__main__":
-    # Only auto-start if not running as main module and not already started
-    try:
-        if not integrated_server.is_running:
-            ensure_recorder_server()
-    except Exception as e:
-        logging.error(f"❌ Error during auto-start: {e}")
-
-if __name__ == "__main__":
-    # Test the integrated server
-    print("Testing Integrated Server...")
-    success = ensure_recorder_server()
-    if success:
-        print("✅ Server test successful")
-        time.sleep(2)
-        stop_all_servers()
-    else:
-        print("❌ Server test failed")

recorder_server.py

@@ -1,452 +0,0 @@
-from flask import Flask, request, jsonify
-import os
-import tempfile
-from pathlib import Path
-from audio_processor import AudioProcessor
-import logging
-import json
-import traceback
-from flask_cors import CORS
-import soundfile as sf
-import librosa
-from translator import get_translator, get_translation
-from database import NotesDatabase
-from summarizer import LectureSummarizer
-
-app = Flask(__name__)
-# إعداد CORS بشكل صحيح لتجنب تكرار headers
-CORS(app, 
-     origins="*",
-     methods=['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
-     allow_headers=['Content-Type', 'Authorization']
-)
-
-# Configure logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-
-# Initialize database and summarizer
-db = NotesDatabase()
-summarizer = LectureSummarizer()
-
-@app.route('/record', methods=['GET', 'POST', 'OPTIONS'])
-def record():
-    if request.method == 'OPTIONS':
-        # Handle CORS preflight request - flask-cors ستتولى headers
-        return '', 204
-
-    if request.method == 'GET':
-        logging.info("--- RECORD ENDPOINT: Health check request received. ---")
-        return jsonify({'status': 'ok', 'message': 'Recorder server is running.'})
-
-    logging.info("--- RECORD ENDPOINT: POST request received. ---")
-    logging.info(f"Request Headers: {request.headers}")
-    
-    if 'audio_data' not in request.files:
-        logging.error("--- RECORD ENDPOINT: 'audio_data' not in request files. ---")
-        return jsonify({'success': False, 'error': 'No audio file found'})
-
-    audio_file = request.files['audio_data']
-    markers = json.loads(request.form.get('markers', '[]'))
-    target_language = request.form.get('target_language', 'ar')  # Default to Arabic
-    enable_translation = request.form.get('enable_translation', 'true').lower() == 'true'
-    
-    print(f"🔍 RECORD ENDPOINT DEBUG:")
-    print(f"- enable_translation: {enable_translation}")
-    print(f"- target_language: {target_language}")
-    
-    logging.info(f"--- RECORD ENDPOINT: Received file: {audio_file.filename} ---")
-    logging.info(f"--- RECORD ENDPOINT: Target language: {target_language} ---")
-    logging.info(f"--- RECORD ENDPOINT: Translation enabled: {enable_translation} ---")
-    
-    if markers:
-        logging.info(f"--- RECORD ENDPOINT: Received {len(markers)} markers: {markers} ---")
-    
-    tmp_file_path = None
-    try:
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
-            audio_file.save(tmp_file.name)
-            tmp_file_path = tmp_file.name
-        logging.info(f"--- RECORD ENDPOINT: Audio saved to temporary file: {tmp_file_path} ---")
-
-        # --- File Standardization Step ---
-        try:
-            logging.info(f"--- RECORD ENDPOINT: Standardizing audio file: {tmp_file_path} ---")
-            y, sr = librosa.load(tmp_file_path, sr=None, mono=True)
-            sf.write(tmp_file_path, y, sr)
-            logging.info(f"--- RECORD ENDPOINT: Audio file successfully standardized. ---")
-        except Exception as e:
-            logging.warning(f"--- RECORD ENDPOINT: Could not standardize audio file, proceeding with original. Error: {e} ---")
-        # --- End Standardization ---
-
-        processor = AudioProcessor()
-        
-        # Choose processing method based on translation requirement
-        if enable_translation:
-            logging.info("--- RECORD ENDPOINT: Calling enhanced processor with translation ---")
-            result_data, processor_logs = processor.get_word_timestamps_with_translation(
-                tmp_file_path, target_language
-            )
-            
-            for log_msg in processor_logs:
-                logging.info(f"--- AUDIO_PROCESSOR LOG: {log_msg} ---")
-
-            if not result_data or not result_data.get('original_text'):
-                logging.error("--- RECORD ENDPOINT: Failed to generate transcription with translation. ---")
-                return jsonify({
-                    'success': False, 
-                    'error': 'Could not generate transcription with translation.', 
-                    'logs': processor_logs
-                })
-
-            # Prepare enhanced response with translation
-            full_text = result_data['original_text']
-            translated_text = result_data['translated_text']
-            word_timestamps = result_data['word_timestamps']
-            translated_timestamps = result_data.get('translated_timestamps', [])
-            
-            logging.info(f"--- RECORD ENDPOINT: Original text: '{full_text[:100]}...'")
-            logging.info(f"--- RECORD ENDPOINT: Translated text: '{translated_text[:100]}...'")
-            
-        else:
-            # Standard processing without translation
-            logging.info("--- RECORD ENDPOINT: Calling standard audio_processor.get_word_timestamps ---")
-            word_timestamps, processor_logs = processor.get_word_timestamps(tmp_file_path)
-            
-            for log_msg in processor_logs:
-                logging.info(f"--- AUDIO_PROCESSOR LOG: {log_msg} ---")
-
-            if not word_timestamps:
-                logging.error("--- RECORD ENDPOINT: Failed to generate timestamps. ---")
-                return jsonify({
-                    'success': False, 
-                    'error': 'Could not generate timestamps.', 
-                    'logs': processor_logs
-                })
-
-            full_text = " ".join([d['word'] for d in word_timestamps])
-            translated_text = full_text  # No translation requested
-            translated_timestamps = word_timestamps
-            result_data = {
-                'original_text': full_text,
-                'translated_text': translated_text,
-                'word_timestamps': word_timestamps,
-                'translated_timestamps': translated_timestamps,
-                'translation_success': not enable_translation
-            }
-            
-            logging.info(f"--- RECORD ENDPOINT: Transcription successful. Text: '{full_text[:100]}...'")
-        
-        # Read audio file for storage
-        with open(tmp_file_path, 'rb') as f:
-            audio_bytes = f.read()
-
-        # Prepare comprehensive transcription data
-        transcription_data = {
-            'original_text': result_data['original_text'],
-            'translated_text': result_data['translated_text'],
-            'word_timestamps': result_data['word_timestamps'],
-            'translated_timestamps': result_data.get('translated_timestamps', []),
-            'audio_bytes': audio_bytes.hex(),
-            'original_suffix': '.wav',
-            'markers': markers,
-            'target_language': target_language,
-            'translation_enabled': enable_translation,
-            'translation_success': result_data.get('translation_success', False),
-            'language_detected': result_data.get('language_detected', 'unknown')
-        }
-        
-        # Save comprehensive data to file
-        result_file_path = ""
-        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix=".json", dir=".", encoding='utf-8') as json_file:
-            json.dump(transcription_data, json_file, ensure_ascii=False, indent=2)
-            result_file_path = json_file.name
-        logging.info(f"--- RECORD ENDPOINT: Enhanced transcription data saved to {result_file_path} ---")
-
-        # Prepare successful response
-        response_data = {
-            'success': True,
-            'original_text': result_data['original_text'],
-            'translated_text': result_data['translated_text'],
-            'file_path': result_file_path,
-            'markers': markers,
-            'target_language': target_language,
-            'translation_enabled': enable_translation,
-            'translation_success': result_data.get('translation_success', False),
-            'language_detected': result_data.get('language_detected', 'unknown')
-        }
-        
-        print(f"🔍 DEBUG RESPONSE DATA:")
-        print(f"- success: {response_data['success']}")
-        print(f"- original_text: {response_data['original_text']}")
-        print(f"- translated_text: {response_data['translated_text']}")
-        print(f"- target_language: {response_data['target_language']}")
-        print(f"- translation_enabled: {response_data['translation_enabled']}")
-        print(f"- translation_success: {response_data['translation_success']}")
-        print(f"- language_detected: {response_data['language_detected']}")
-        
-        logging.info(f"--- RECORD ENDPOINT: Sending enhanced response with translation support ---")
-        return jsonify(response_data)
-
-    except Exception as e:
-        logging.error(f"--- RECORD ENDPOINT FATAL ERROR: {traceback.format_exc()} ---")
-        return jsonify({'success': False, 'error': str(e), 'trace': traceback.format_exc()}), 500
-    finally:
-        if tmp_file_path and os.path.exists(tmp_file_path):
-            os.unlink(tmp_file_path)
-
-@app.route('/translate', methods=['POST', 'OPTIONS'])
-def translate_text():
-    """Endpoint for standalone text translation"""
-    if request.method == 'OPTIONS':
-        # flask-cors ستتولى معالجة CORS headers
-        return '', 204
-    
-    try:
-        data = request.get_json()
-        if not data or 'text' not in data:
-            return jsonify({'success': False, 'error': 'No text provided for translation'})
-        
-        text = data['text']
-        target_language = data.get('target_language', 'ar')
-        source_language = data.get('source_language', 'auto')
-        
-        logging.info(f"--- TRANSLATE ENDPOINT: Translating text to {target_language} ---")
-        
-        translator = get_translator()
-        if not translator:
-            return jsonify({'success': False, 'error': 'Translation service not available'})
-        
-        translated_text, error = translator.translate_text(text, target_language, source_language)
-        
-        if translated_text:
-            # Detect source language if auto
-            detected_lang = 'unknown'
-            if source_language == 'auto':
-                detected_lang, _ = translator.detect_language(text)
-            
-            response_data = {
-                'success': True,
-                'original_text': text,
-                'translated_text': translated_text,
-                'source_language': detected_lang if source_language == 'auto' else source_language,
-                'target_language': target_language
-            }
-            logging.info(f"--- TRANSLATE ENDPOINT: Translation successful ---")
-            return jsonify(response_data)
-        else:
-            logging.error(f"--- TRANSLATE ENDPOINT: Translation failed: {error} ---")
-            return jsonify({'success': False, 'error': error})
-            
-    except Exception as e:
-        logging.error(f"--- TRANSLATE ENDPOINT ERROR: {traceback.format_exc()} ---")
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-@app.route('/languages', methods=['GET'])
-def get_supported_languages():
-    """Get list of supported languages"""
-    try:
-        translator = get_translator()
-        if translator:
-            languages = translator.get_supported_languages()
-            return jsonify({'success': True, 'languages': languages})
-        else:
-            return jsonify({'success': False, 'error': 'Translation service not available'})
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-@app.route('/ui-translations/<language>', methods=['GET'])
-def get_ui_translations(language):
-    """Get UI translations for a specific language"""
-    try:
-        from translator import UI_TRANSLATIONS
-        translations = UI_TRANSLATIONS.get(language, UI_TRANSLATIONS['en'])
-        return jsonify({'success': True, 'translations': translations, 'language': language})
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-# ======= وظائف الملخص والملاحظات الجديدة =======
-
-@app.route('/summarize', methods=['POST', 'OPTIONS'])
-def summarize_text():
-    """إنشاء ملخص ذكي من النص"""
-    logging.info(f"--- SUMMARIZE ENDPOINT: {request.method} request received ---")
-    logging.info(f"--- SUMMARIZE ENDPOINT: Origin: {request.headers.get('Origin', 'None')} ---")
-    logging.info(f"--- SUMMARIZE ENDPOINT: Headers: {dict(request.headers)} ---")
-    
-    if request.method == 'OPTIONS':
-        logging.info("--- SUMMARIZE ENDPOINT: Handling OPTIONS preflight request ---")
-        # لا حاجة لإعداد headers يدوياً، flask-cors ستتولى الأمر
-        return '', 204
-    
-    try:
-        data = request.get_json()
-        if not data or 'text' not in data:
-            return jsonify({'success': False, 'error': 'لم يتم توفير نص للتلخيص'})
-        
-        text = data['text']
-        language = data.get('language', 'ar')
-        subject = data.get('subject', '')
-        summary_type = data.get('type', 'full')  # full, key_points, questions
-        
-        logging.info(f"--- SUMMARIZE ENDPOINT: Creating {summary_type} summary ---")
-        
-        if summary_type == 'key_points':
-            result, error = summarizer.extract_key_points(text, language)
-            result_key = 'key_points'
-        elif summary_type == 'questions':
-            result, error = summarizer.generate_review_questions(text, language)
-            result_key = 'questions'
-        elif summary_type == 'study_notes':
-            result, error = summarizer.generate_study_notes(text, subject, language)
-            result_key = 'study_notes'
-        else:  # full summary
-            result, error = summarizer.generate_summary(text, language)
-            result_key = 'summary'
-        
-        if result:
-            response_data = {
-                'success': True,
-                result_key: result,
-                'type': summary_type,
-                'language': language
-            }
-            logging.info(f"--- SUMMARIZE ENDPOINT: {summary_type} summary created successfully ---")
-            return jsonify(response_data)
-        else:
-            logging.error(f"--- SUMMARIZE ENDPOINT: Failed to create {summary_type}: {error} ---")
-            return jsonify({'success': False, 'error': error})
-            
-    except Exception as e:
-        logging.error(f"--- SUMMARIZE ENDPOINT ERROR: {traceback.format_exc()} ---")
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-@app.route('/test-summarize', methods=['GET'])
-def test_summarize():
-    """اختبار بسيط لـ summarize endpoint"""
-    return jsonify({
-        'success': True, 
-        'message': 'Summarize endpoint is working!',
-        'test_summary': {
-            'main_summary': 'This is a test summary',
-            'key_points': ['Point 1', 'Point 2', 'Point 3'],
-            'review_questions': ['Question 1?', 'Question 2?'],
-            'study_notes': 'These are test study notes'
-        }
-    })
-
-@app.route('/notes', methods=['GET', 'POST', 'OPTIONS'])
-def handle_notes():
-    """التعامل مع الملاحظات - عرض وحفظ"""
-    if request.method == 'OPTIONS':
-        # flask-cors ستتولى معالجة CORS headers
-        return '', 204
-    
-    if request.method == 'GET':
-        try:
-            # البحث أو عرض جميع الملاحظات
-            search_query = request.args.get('search', '')
-            subject = request.args.get('subject', '')
-            limit = int(request.args.get('limit', 20))
-            
-            if search_query:
-                notes = db.search_notes(search_query)
-            elif subject:
-                notes = db.get_notes_by_subject(subject)
-            else:
-                notes = db.get_all_notes(limit)
-            
-            # إحصائيات سريعة
-            subjects = db.get_subjects()
-            
-            response = jsonify({
-                'success': True,
-                'notes': notes,
-                'subjects': subjects,
-                'total': len(notes)
-            })
-            return response
-            
-        except Exception as e:
-            response = jsonify({'success': False, 'error': str(e)})
-            return response, 500
-    
-    if request.method == 'POST':
-        try:
-            data = request.get_json()
-            
-            # التحقق من البيانات المطلوبة
-            if not data or 'original_text' not in data:
-                return jsonify({'success': False, 'error': 'البيانات غير مكتملة'})
-            
-            # حفظ الملاحظة
-            note_id = db.save_lecture_note(data)
-            
-            logging.info(f"--- NOTES ENDPOINT: Note saved with ID {note_id} ---")
-            
-            response = jsonify({
-                'success': True,
-                'note_id': note_id,
-                'message': 'تم حفظ الملاحظة بنجاح'
-            })
-            return response
-            
-        except Exception as e:
-            logging.error(f"--- NOTES ENDPOINT ERROR: {traceback.format_exc()} ---")
-            response = jsonify({'success': False, 'error': str(e)})
-            return response, 500
-
-@app.route('/notes/<int:note_id>', methods=['GET', 'PUT', 'DELETE', 'OPTIONS'])
-def handle_single_note(note_id):
-    """التعامل مع ملاحظة واحدة - عرض، تحديث، حذف"""
-    if request.method == 'OPTIONS':
-        # flask-cors ستتولى معالجة CORS headers
-        return '', 204
-    
-    if request.method == 'GET':
-        try:
-            note = db.get_note_by_id(note_id)
-            if note:
-                return jsonify({'success': True, 'note': note})
-            else:
-                return jsonify({'success': False, 'error': 'الملاحظة غير موجودة'}), 404
-                
-        except Exception as e:
-            return jsonify({'success': False, 'error': str(e)}), 500
-    
-    if request.method == 'PUT':
-        try:
-            data = request.get_json()
-            if not data:
-                return jsonify({'success': False, 'error': 'لم يتم توفير بيانات للتحديث'})
-            
-            success = db.update_note(note_id, data)
-            if success:
-                return jsonify({'success': True, 'message': 'تم تحديث الملاحظة بنجاح'})
-            else:
-                return jsonify({'success': False, 'error': 'فشل في تحديث الملاحظة'}), 400
-                
-        except Exception as e:
-            return jsonify({'success': False, 'error': str(e)}), 500
-    
-    if request.method == 'DELETE':
-        try:
-            success = db.delete_note(note_id)
-            if success:
-                return jsonify({'success': True, 'message': 'تم حذف الملاحظة بنجاح'})
-            else:
-                return jsonify({'success': False, 'error': 'فشل في حذف الملاحظة'}), 400
-                
-        except Exception as e:
-            return jsonify({'success': False, 'error': str(e)}), 500
-
-@app.route('/notes/subjects', methods=['GET'])
-def get_subjects():
-    """استرجاع قائمة المواد الدراسية"""
-    try:
-        subjects = db.get_subjects()
-        return jsonify({'success': True, 'subjects': subjects})
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500
-
-if __name__ == '__main__':
-    app.run(port=5001)

summarizer.py

@@ -21,7 +21,7 @@ class LectureSummarizer:
         Returns:
             Tuple of (summary, error_message)
         """
-        if not self.translator or not self.translator.client:
+        if not self.translator or not self.translator.model:
             return None, "خدمة الذكاء الاصطناعي غير متوفرة"
         
         if not text or len(text.strip()) < 50:
@@ -30,12 +30,9 @@ class LectureSummarizer:
         try:
             prompt = self._create_summary_prompt(text, language)
             
-            response = self.translator.client.models.generate_content(
-                model="gemini-2.5-flash",
-                contents=[prompt]
-            )
+            response = self.translator.model.generate_content(prompt)
             
-            if response and response.text:
+            if response and hasattr(response, 'text') and response.text:
                 summary = response.text.strip()
                 summary = self._clean_summary_output(summary)
                 return summary, None
@@ -56,18 +53,15 @@ class LectureSummarizer:
         Returns:
             Tuple of (key_points_list, error_message)
         """
-        if not self.translator or not self.translator.client:
+        if not self.translator or not self.translator.model:
             return None, "خدمة الذكاء الاصطناعي غير متوفرة"
         
         try:
             prompt = self._create_key_points_prompt(text, language)
             
-            response = self.translator.client.models.generate_content(
-                model="gemini-2.5-flash",
-                contents=[prompt]
-            )
-            
-            if response and response.text:
+            response = self.translator.model.generate_content(prompt)
+
+            if response and hasattr(response, 'text') and response.text:
                 key_points_text = response.text.strip()
                 key_points = self._parse_key_points(key_points_text)
                 return key_points, None
@@ -130,18 +124,15 @@ class LectureSummarizer:
         Returns:
             Tuple of (questions_list, error_message)
         """
-        if not self.translator or not self.translator.client:
+        if not self.translator or not self.translator.model:
             return None, "خدمة الذكاء الاصطناعي غير متوفرة"
         
         try:
             prompt = self._create_questions_prompt(text, language)
             
-            response = self.translator.client.models.generate_content(
-                model="gemini-2.5-flash",
-                contents=[prompt]
-            )
+            response = self.translator.model.generate_content(prompt)
             
-            if response and response.text:
+            if response and hasattr(response, 'text') and response.text:
                 questions_text = response.text.strip()
                 questions = self._parse_questions(questions_text)
                 return questions, None

templates/recorder.html

@@ -1,1958 +0,0 @@
-<!DOCTYPE html>
-<html lang="en" dir="ltr">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Lecture Recorder - SyncMaster</title>
-    <style>
-        :root {
-            --primary-color: #2563eb;
-            --primary-dark: #1d4ed8;
-            --success-color: #16a34a;
-            --danger-color: #dc2626;
-            --warning-color: #ea580c;
-            --neutral-100: #f5f5f5;
-            --neutral-200: #e5e5e5;
-            --neutral-300: #d4d4d8;
-            --neutral-600: #525252;
-            --neutral-700: #404040;
-            --neutral-800: #262626;
-            --neutral-900: #171717;
-            --white: #ffffff;
-            --text-primary: #0f172a;
-            --text-secondary: #64748b;
-            --border-radius: 8px;
-            --shadow-sm: 0 1px 2px 0 rgb(0 0 0 / 0.05);
-            --shadow-md: 0 4px 6px -1px rgb(0 0 0 / 0.1);
-            --shadow-lg: 0 10px 15px -3px rgb(0 0 0 / 0.1);
-        }
-        
-        /* RTL Support for Arabic */
-        html[dir="rtl"] {
-            direction: rtl;
-        }
-        
-        html[dir="rtl"] .language-selector {
-            left: 20px;
-            right: auto;
-        }
-        
-        * {
-            box-sizing: border-box;
-        }
-        
-        body {
-            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
-            margin: 0;
-            padding: 20px;
-            min-height: 100vh;
-            background: linear-gradient(135deg, #f1f5f9 0%, #e2e8f0 100%);
-            color: var(--text-primary);
-            display: flex;
-            align-items: center;
-            justify-content: center;
-        }
-        
-        .recorder-container {
-            background: var(--white);
-            border-radius: 16px;
-            box-shadow: var(--shadow-lg);
-            width: 100%;
-            max-width: 640px;
-            padding: 32px;
-            text-align: center;
-            position: relative;
-        }
-        
-        /* Language Selector */
-        .language-selector {
-            position: absolute;
-            top: 20px;
-            right: 20px;
-            z-index: 100;
-        }
-        
-        .language-selector select {
-            padding: 8px 12px;
-            border: 1px solid var(--neutral-300);
-            border-radius: var(--border-radius);
-            background: var(--white);
-            color: var(--text-primary);
-            font-size: 14px;
-            font-weight: 500;
-            cursor: pointer;
-            outline: none;
-        }
-        
-        .language-selector select:focus {
-            border-color: var(--primary-color);
-            box-shadow: 0 0 0 3px rgb(37 99 235 / 0.1);
-        }
-        
-        /* Translation Controls */
-        .translation-controls {
-            margin: 24px 0;
-            padding: 20px;
-            background: var(--neutral-100);
-            border-radius: var(--border-radius);
-            border: 1px solid var(--neutral-200);
-        }
-        
-        .translation-toggle {
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            gap: 16px;
-            margin-bottom: 12px;
-            flex-wrap: wrap;
-        }
-        
-        .toggle-switch {
-            position: relative;
-            width: 48px;
-            height: 24px;
-        }
-        
-        .toggle-switch input {
-            opacity: 0;
-            width: 0;
-            height: 0;
-        }
-        
-        .slider {
-            position: absolute;
-            cursor: pointer;
-            top: 0;
-            left: 0;
-            right: 0;
-            bottom: 0;
-            background-color: var(--neutral-300);
-            border-radius: 24px;
-            transition: background-color 0.3s ease;
-        }
-        
-        .slider:before {
-            position: absolute;
-            content: "";
-            height: 18px;
-            width: 18px;
-            left: 3px;
-            bottom: 3px;
-            background-color: var(--white);
-            border-radius: 50%;
-            transition: transform 0.3s ease;
-            box-shadow: var(--shadow-sm);
-        }
-        
-        input:checked + .slider {
-            background-color: var(--primary-color);
-        }
-        
-        input:checked + .slider:before {
-            transform: translateX(24px);
-        }
-        
-        .target-language-select {
-            padding: 8px 12px;
-            border: 1px solid var(--neutral-300);
-            border-radius: var(--border-radius);
-            background: var(--white);
-            min-width: 140px;
-            font-size: 14px;
-            color: var(--text-primary);
-        }
-        
-        .target-language-select:focus {
-            border-color: var(--primary-color);
-            outline: none;
-            box-shadow: 0 0 0 3px rgb(37 99 235 / 0.1);
-        }
-        
-        h2 {
-            margin-top: 0;
-            margin-bottom: 8px;
-            color: var(--text-primary);
-            font-size: 28px;
-            font-weight: 700;
-            letter-spacing: -0.025em;
-        }
-        
-        .subtitle {
-            color: var(--text-secondary);
-            margin-bottom: 32px;
-            font-size: 16px;
-            line-height: 1.5;
-        }
-        
-        .button-group {
-            margin-top: 24px;
-            display: grid;
-            grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
-            gap: 12px;
-        }
-        
-        .button {
-            color: var(--white);
-            border: none;
-            padding: 12px 20px;
-            font-size: 14px;
-            font-weight: 600;
-            border-radius: var(--border-radius);
-            cursor: pointer;
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            gap: 8px;
-            min-height: 44px;
-            text-transform: none;
-            letter-spacing: normal;
-            transition: none;
-        }
-        
-        .button:disabled {
-            opacity: 0.5;
-            cursor: not-allowed;
-        }
-        
-        .button:focus {
-            outline: none;
-            box-shadow: 0 0 0 3px rgb(0 0 0 / 0.1);
-        }
-        
-        #recordButton { 
-            background: var(--success-color);
-        }
-        
-        #stopButton { 
-            background: var(--danger-color);
-        }
-        
-        #pauseButton { 
-            background: var(--warning-color);
-        }
-        
-        #markButton { 
-            background: var(--primary-color);
-        }
-        
-        #extractButton { 
-            background: var(--primary-color);
-        }
-        
-        #rerecordButton { 
-            background: var(--neutral-600);
-        }
-
-        .status-display {
-            margin: 24px 0;
-            font-size: 16px;
-            color: var(--text-secondary);
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            gap: 12px;
-            font-weight: 500;
-        }
-        
-        .recording-indicator {
-            width: 10px;
-            height: 10px;
-            background-color: var(--danger-color);
-            border-radius: 50%;
-            animation: pulse 2s infinite;
-        }
-        
-        @keyframes pulse {
-            0%, 100% { 
-                opacity: 1; 
-                transform: scale(1);
-            }
-            50% { 
-                opacity: 0.5; 
-                transform: scale(1.1);
-            }
-        }
-        
-        #timer {
-            font-size: 36px;
-            font-weight: 300;
-            margin: 20px 0;
-            color: var(--primary-color);
-            font-family: 'SF Mono', 'Monaco', 'Inconsolata', 'Roboto Mono', monospace;
-            letter-spacing: 0.05em;
-        }
-        
-        #audio-level-container {
-            width: 100%;
-            height: 6px;
-            background-color: var(--neutral-200);
-            border-radius: 3px;
-            overflow: hidden;
-            margin: 20px 0;
-        }
-        
-        #audio-level-indicator {
-            width: 0%;
-            height: 100%;
-            background: linear-gradient(90deg, var(--success-color), var(--warning-color), var(--danger-color));
-            transition: width 0.1s ease;
-        }
-        
-        #review-section, #transcription-container {
-            margin-top: 32px;
-            text-align: left;
-        }
-        
-        .section-title {
-            font-size: 18px;
-            font-weight: 600;
-            margin-bottom: 16px;
-            color: var(--text-primary);
-            border-bottom: 2px solid var(--primary-color);
-            padding-bottom: 8px;
-        }
-        
-        textarea {
-            width: 100%;
-            border-radius: var(--border-radius);
-            border: 1px solid var(--neutral-300);
-            padding: 16px;
-            font-family: inherit;
-            resize: vertical;
-            font-size: 14px;
-            line-height: 1.6;
-            color: var(--text-primary);
-            background: var(--white);
-        }
-        
-        textarea:focus {
-            outline: none;
-            border-color: var(--primary-color);
-            box-shadow: 0 0 0 3px rgb(37 99 235 / 0.1);
-        }
-        
-        .translation-result {
-            margin-top: 20px;
-            padding: 20px;
-            background: var(--neutral-100);
-            border-radius: var(--border-radius);
-            border: 1px solid var(--neutral-200);
-        }
-        
-        .translation-header {
-            font-weight: 600;
-            color: var(--primary-color);
-            margin-bottom: 12px;
-            font-size: 16px;
-        }
-        
-        .language-info {
-            margin-top: 12px;
-            font-size: 13px;
-            color: var(--text-secondary);
-            padding: 8px 12px;
-            background: var(--white);
-            border-radius: var(--border-radius);
-            border: 1px solid var(--neutral-200);
-        }
-        
-        /* Loading Spinner */
-        .loading-spinner {
-            display: inline-block;
-            width: 20px;
-            height: 20px;
-            border: 2px solid var(--neutral-300);
-            border-top: 2px solid var(--primary-color);
-            border-radius: 50%;
-            animation: spin 1s linear infinite;
-        }
-        
-        @keyframes spin {
-            0% { transform: rotate(0deg); }
-            100% { transform: rotate(360deg); }
-        }
-        
-        /* Messages */
-        .error-message {
-            background: #fef2f2;
-            color: var(--danger-color);
-            padding: 12px 16px;
-            border-radius: var(--border-radius);
-            margin: 12px 0;
-            border: 1px solid #fecaca;
-            font-size: 14px;
-        }
-        
-        .success-message {
-            background: #f0fdf4;
-            color: var(--success-color);
-            padding: 12px 16px;
-            border-radius: var(--border-radius);
-            margin: 12px 0;
-            border: 1px solid #bbf7d0;
-            font-size: 14px;
-        }
-        
-        .translation-status {
-            font-size: 12px;
-            padding: 6px 10px;
-            border-radius: 4px;
-            margin-top: 8px;
-            font-weight: 500;
-        }
-        
-        /* Responsive Design */
-        @media (max-width: 768px) {
-            body {
-                padding: 12px;
-            }
-            
-            .recorder-container {
-                padding: 24px 20px;
-            }
-            
-            .button-group {
-                grid-template-columns: 1fr;
-                gap: 8px;
-            }
-            
-            #timer {
-                font-size: 28px;
-            }
-            
-            h2 {
-                font-size: 24px;
-            }
-            
-            .translation-toggle {
-                flex-direction: column;
-                gap: 12px;
-            }
-            
-            .language-selector {
-                position: static;
-                margin-bottom: 16px;
-                text-align: center;
-            }
-        }
-        
-        @media (max-width: 480px) {
-            .recorder-container {
-                padding: 20px 16px;
-            }
-            
-            h2 {
-                font-size: 20px;
-            }
-            
-            .subtitle {
-                font-size: 14px;
-            }
-            
-            #timer {
-                font-size: 24px;
-            }
-        }
-        
-        /* Focus indicators for accessibility */
-        .button:focus,
-        select:focus,
-        input:focus {
-            box-shadow: 0 0 0 3px rgb(37 99 235 / 0.1);
-        }
-
-        /* Summary and Notes Styles */
-        .note-item {
-            background: var(--white);
-            border: 1px solid var(--neutral-200);
-            border-radius: var(--border-radius);
-            padding: 20px;
-            margin-bottom: 16px;
-            transition: all 0.2s ease;
-        }
-
-        .note-item:hover {
-            border-color: var(--primary-color);
-            box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
-        }
-
-        .note-header {
-            display: flex;
-            justify-content: space-between;
-            align-items: flex-start;
-            margin-bottom: 12px;
-        }
-
-        .note-header h4 {
-            margin: 0;
-            color: var(--text-primary);
-            font-size: 16px;
-            font-weight: 600;
-        }
-
-        .note-date {
-            font-size: 12px;
-            color: var(--text-secondary);
-            white-space: nowrap;
-        }
-
-        .note-summary {
-            color: var(--text-secondary);
-            font-size: 14px;
-            line-height: 1.5;
-            margin-bottom: 12px;
-        }
-
-        .note-tags {
-            margin-bottom: 12px;
-        }
-
-        .tag {
-            display: inline-block;
-            background: var(--primary-color);
-            color: white;
-            padding: 4px 8px;
-            border-radius: 12px;
-            font-size: 12px;
-            margin-right: 6px;
-            margin-bottom: 4px;
-        }
-
-        .note-actions {
-            display: flex;
-            gap: 8px;
-        }
-
-        .btn-secondary {
-            background: var(--neutral-200);
-            color: var(--text-primary);
-            border: 1px solid var(--neutral-300);
-            padding: 6px 12px;
-            border-radius: 4px;
-            font-size: 12px;
-            cursor: pointer;
-            transition: all 0.2s ease;
-        }
-
-        .btn-secondary:hover {
-            background: var(--neutral-300);
-        }
-
-        .btn-danger {
-            background: #dc3545;
-            color: white;
-            border: 1px solid #dc3545;
-            padding: 6px 12px;
-            border-radius: 4px;
-            font-size: 12px;
-            cursor: pointer;
-            transition: all 0.2s ease;
-        }
-
-        .btn-danger:hover {
-            background: #c82333;
-            border-color: #c82333;
-        }
-
-        /* Modal Styles */
-        .note-modal {
-            position: fixed;
-            top: 0;
-            left: 0;
-            width: 100%;
-            height: 100%;
-            background: rgba(0, 0, 0, 0.5);
-            display: flex;
-            justify-content: center;
-            align-items: center;
-            z-index: 1000;
-            padding: 20px;
-        }
-
-        .note-modal-content {
-            background: var(--white);
-            border-radius: var(--border-radius);
-            max-width: 800px;
-            width: 100%;
-            max-height: 90vh;
-            overflow-y: auto;
-            box-shadow: 0 10px 30px rgba(0, 0, 0, 0.3);
-        }
-
-        .note-modal-header {
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-            padding: 20px 24px;
-            border-bottom: 1px solid var(--neutral-200);
-            position: sticky;
-            top: 0;
-            background: var(--white);
-            z-index: 1;
-        }
-
-        .note-modal-header h2 {
-            margin: 0;
-            color: var(--text-primary);
-            font-size: 20px;
-        }
-
-        .close-btn {
-            background: none;
-            border: none;
-            font-size: 24px;
-            cursor: pointer;
-            color: var(--text-secondary);
-            padding: 0;
-            width: 30px;
-            height: 30px;
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            border-radius: 50%;
-            transition: all 0.2s ease;
-        }
-
-        .close-btn:hover {
-            background: var(--neutral-100);
-            color: var(--text-primary);
-        }
-
-        .note-modal-body {
-            padding: 24px;
-        }
-
-        .note-section {
-            margin-bottom: 24px;
-        }
-
-        .note-section h3 {
-            color: var(--primary-color);
-            font-size: 16px;
-            font-weight: 600;
-            margin-bottom: 12px;
-            border-bottom: 1px solid var(--neutral-200);
-            padding-bottom: 8px;
-        }
-
-        .note-section p {
-            color: var(--text-primary);
-            line-height: 1.6;
-            margin: 0;
-        }
-
-        .note-section ul {
-            margin: 0;
-            padding-left: 20px;
-        }
-
-        .note-section li {
-            color: var(--text-primary);
-            line-height: 1.6;
-            margin-bottom: 8px;
-        }
-
-        /* Search Styles */
-        .search-container {
-            margin-bottom: 20px;
-        }
-
-        .search-container input {
-            width: 100%;
-            padding: 12px 16px;
-            border: 1px solid var(--neutral-300);
-            border-radius: var(--border-radius);
-            font-size: 14px;
-            background: var(--white);
-            color: var(--text-primary);
-        }
-
-        .search-container input:focus {
-            outline: none;
-            border-color: var(--primary-color);
-            box-shadow: 0 0 0 3px rgb(37 99 235 / 0.1);
-        }
-
-        /* Empty state */
-        .text-center {
-            text-align: center;
-        }
-
-        .text-muted {
-            color: var(--text-secondary);
-        }
-
-        /* Form Styles for Summary Section */
-        .form-group {
-            margin-bottom: 16px;
-        }
-
-        .form-group label {
-            display: block;
-            margin-bottom: 6px;
-            font-weight: 500;
-            color: var(--text-primary);
-        }
-
-        .form-group input,
-        .form-group textarea {
-            width: 100%;
-            padding: 10px 12px;
-            border: 1px solid var(--neutral-300);
-            border-radius: 4px;
-            font-size: 14px;
-            background: var(--white);
-            color: var(--text-primary);
-        }
-
-        .form-group input:focus,
-        .form-group textarea:focus {
-            outline: none;
-            border-color: var(--primary-color);
-            box-shadow: 0 0 0 3px rgb(37 99 235 / 0.1);
-        }
-
-        /* Summary Content Styling */
-        .summary-content {
-            background: var(--neutral-50);
-            border: 1px solid var(--neutral-200);
-            border-radius: var(--border-radius);
-            padding: 16px;
-            margin-bottom: 16px;
-        }
-
-        .summary-content h4 {
-            color: var(--primary-color);
-            margin-bottom: 12px;
-            font-size: 16px;
-        }
-
-        .summary-content ul {
-            margin: 0;
-            padding-left: 20px;
-        }
-
-        .summary-content li {
-            margin-bottom: 8px;
-            line-height: 1.5;
-        }
-    </style>
-</head>
-<body>
-    <div class="recorder-container">
-        <!-- Language Selector -->
-        <div class="language-selector">
-            <select id="languageSelect" aria-label="Select Language">
-                <option value="en">English</option>
-                <option value="ar">العربية</option>
-            </select>
-        </div>
-        
-        <h2 id="main-title">Lecture Recorder</h2>
-        <p class="subtitle" id="subtitle">Record and transcribe your lectures with AI-powered translation</p>
-        
-        <!-- Translation Controls -->
-        <div class="translation-controls">
-            <div class="translation-toggle">
-                <label for="translationToggle" id="translation-label">Enable Translation:</label>
-                <label class="toggle-switch">
-                    <input type="checkbox" id="translationToggle" checked>
-                    <span class="slider"></span>
-                </label>
-                <select id="targetLanguage" class="target-language-select">
-                    <option value="ar">العربية (Arabic)</option>
-                    <option value="en">English</option>
-                    <option value="fr">Français</option>
-                    <option value="es">Español</option>
-                </select>
-            </div>
-        </div>
-        
-        <div id="recording-controls">
-            <div class="status-display">
-                <div id="recording-indicator" class="recording-indicator" style="display: none;"></div>
-                <span id="status">Ready to Record</span>
-            </div>
-            <div id="timer">00:00:00</div>
-            <div id="audio-level-container">
-                <div id="audio-level-indicator"></div>
-            </div>
-            <div class="button-group">
-                <button id="recordButton" class="button" aria-label="Start Recording">
-                    <span>🎙️</span>
-                    <span id="record-text">Start</span>
-                </button>
-                <button id="pauseButton" class="button" disabled aria-label="Pause Recording">
-                    <span>⏸️</span>
-                    <span id="pause-text">Pause</span>
-                </button>
-                <button id="stopButton" class="button" disabled aria-label="Stop Recording">
-                    <span>⏹️</span>
-                    <span id="stop-text">Stop</span>
-                </button>
-                <button id="markButton" class="button" disabled aria-label="Mark Important Point">
-                    <span>📌</span>
-                    <span id="mark-text">Mark Important</span>
-                </button>
-            </div>
-        </div>
-
-        <div id="review-section" style="display: none;">
-            <h3 class="section-title" id="review-title">Review Recording</h3>
-            <audio id="audio-playback" controls style="width: 100%;"></audio>
-            <div class="button-group">
-                <button id="extractButton" class="button" aria-label="Extract Text">
-                    <span>📄</span>
-                    <span id="extract-text">Extract Text</span>
-                </button>
-                <button id="rerecordButton" class="button" aria-label="Record Again">
-                    <span>🔄</span>
-                    <span id="rerecord-text">Re-record</span>
-                </button>
-            </div>
-        </div>
-
-        <div id="transcription-container" style="display: none;">
-            <h3 class="section-title" id="transcription-title">Processing Result</h3>
-            
-            <!-- Original Transcription -->
-            <div class="transcription-section">
-                <h4 id="original-text-label">Original Text:</h4>
-                <textarea id="original-transcription-box" rows="6" readonly></textarea>
-            </div>
-            
-            <!-- Translation Result -->
-            <div id="translation-section" class="translation-result" style="display: none;">
-                <h4 class="translation-header" id="translated-text-label">Arabic Translation:</h4>
-                <textarea id="translated-transcription-box" rows="6" readonly></textarea>
-                
-                <!-- Language Info -->
-                <div class="language-info" style="margin-top: 10px; font-size: 0.9em; color: #6c757d;">
-                    <span id="detected-language">Detected Language: Unknown</span> → 
-                    <span id="target-language-info">Arabic</span>
-                </div>
-            </div>
-            
-            <!-- Markers Section -->
-            <div id="markers-section" style="display: none; margin-top: 20px;">
-                <h4 id="markers-label">Important Markers:</h4>
-                <div id="markers-list" style="background: #f8f9fa; padding: 10px; border-radius: 6px;"></div>
-            </div>
-
-            <!-- Summary Action Button (Always Visible) -->
-            <div id="summary-action-section" style="display: none; margin-top: 24px; text-align: center;">
-                <button id="generateSummaryBtn" class="button" style="padding: 12px 24px; font-size: 16px; min-height: auto; background: var(--primary-color); color: white;">
-                    <span>🤖</span>
-                    <span>Generate Smart Lecture Summary</span>
-                </button>
-            </div>
-            
-            <!-- Smart Summary Section -->
-            <div id="summary-section" style="display: none; margin-top: 24px;">
-                <div class="section-title">
-                    <span>📝 Smart Summary</span>
-                </div>
-                
-                <!-- Summary Content -->
-                <div id="summary-content" style="background: var(--neutral-100); border-radius: var(--border-radius); padding: 16px; margin-top: 12px;">
-                    
-                    <!-- Summary Text -->
-                    <div id="summary-text-section" style="display: none;">
-                        <h5 style="color: var(--primary-color); margin: 0 0 8px 0; font-size: 14px;">📋 Summary:</h5>
-                        <div id="summary-text" style="background: var(--white); padding: 12px; border-radius: 6px; border: 1px solid var(--neutral-200); line-height: 1.6; font-size: 14px;"></div>
-                    </div>
-                    
-                    <!-- Key Points -->
-                    <div id="key-points-section" style="display: none; margin-top: 16px;">
-                        <h5 style="color: var(--primary-color); margin: 0 0 8px 0; font-size: 14px;">🎯 Key Points:</h5>
-                        <ul id="key-points-list" style="background: var(--white); padding: 12px; border-radius: 6px; border: 1px solid var(--neutral-200); margin: 0;"></ul>
-                    </div>
-                    
-                    <!-- Review Questions -->
-                    <div id="questions-section" style="display: none; margin-top: 16px;">
-                        <h5 style="color: var(--primary-color); margin: 0 0 8px 0; font-size: 14px;">❓ Review Questions:</h5>
-                        <ol id="questions-list" style="background: var(--white); padding: 12px; border-radius: 6px; border: 1px solid var(--neutral-200); margin: 0;"></ol>
-                    </div>
-                    
-                    <!-- Save Note Section -->
-                    <div id="save-note-section" style="display: none; margin-top: 16px; padding-top: 16px; border-top: 1px solid var(--neutral-200);">
-                        <h5 style="color: var(--primary-color); margin: 0 0 8px 0; font-size: 14px;">💾 Save to Notes:</h5>
-                        <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 8px; margin-bottom: 12px;">
-                            <input type="text" id="noteTitle" placeholder="Note title..." style="padding: 8px; border: 1px solid var(--neutral-300); border-radius: 4px; font-size: 14px;">
-                            <input type="text" id="noteTags" placeholder="Tags (comma separated)..." style="padding: 8px; border: 1px solid var(--neutral-300); border-radius: 4px; font-size: 14px;">
-                        </div>
-                        <button id="saveNoteBtn" class="button" style="width: 100%; padding: 8px; font-size: 14px; min-height: auto;">
-                            <span>💾</span>
-                            <span>Save Note</span>
-                        </button>
-                    </div>
-                </div>
-            </div>
-            
-            <!-- Notes Library Section -->
-            <div id="notes-library-section" style="display: none; margin-top: 24px;">
-                <div class="section-title" style="display: flex; align-items: center; justify-content: space-between;">
-                    <span>📚 مكتبة المذكرات</span>
-                    <div style="display: flex; gap: 8px;">
-                        <button id="refreshNotesBtn" class="button" style="padding: 6px 12px; font-size: 12px; min-height: auto;">
-                            <span>🔄</span>
-                            <span>تحديث</span>
-                        </button>
-                        <button id="toggleNotesBtn" class="button" style="padding: 6px 12px; font-size: 12px; min-height: auto;">
-                            <span>📖</span>
-                            <span>عرض المذكرات</span>
-                        </button>
-                    </div>
-                </div>
-                
-                <!-- Search and Filter -->
-                <div id="notes-controls" style="display: none; margin-top: 12px; padding: 16px; background: var(--neutral-100); border-radius: var(--border-radius);">
-                    <div style="display: grid; grid-template-columns: 1fr auto; gap: 8px; margin-bottom: 12px;">
-                        <input type="text" id="notes-search" placeholder="البحث في المذكرات..." style="padding: 8px; border: 1px solid var(--neutral-300); border-radius: 4px; font-size: 14px;">
-                        <select id="subject-filter" style="padding: 8px; border: 1px solid var(--neutral-300); border-radius: 4px; font-size: 14px; min-width: 120px;">
-                            <option value="">جميع المواد</option>
-                        </select>
-                    </div>
-                    <button id="searchNotesBtn" class="button" style="padding: 6px 16px; font-size: 12px; min-height: auto;">
-                        <span>🔍</span>
-                        <span>بحث</span>
-                    </button>
-                </div>
-                
-                <!-- Notes List -->
-                <div id="notes-list" style="display: none; margin-top: 12px; max-height: 400px; overflow-y: auto;">
-                    <!-- Notes will be loaded here -->
-                </div>
-            </div>
-        </div>
-        
-        <!-- Loading Indicator -->
-        <div id="loading-indicator" style="display: none; margin: 20px 0;">
-            <div class="loading-spinner"></div>
-            <span id="loading-text" style="margin-left: 10px;">Processing...</span>
-        </div>
-        
-        <!-- Error/Success Messages -->
-        <div id="message-container"></div>
-    </div>
-
-    <script>
-        // --- Global Variables ---
-        let currentLanguage = 'en';
-        let translations = {};
-        
-        // --- DOM Elements ---
-        const elements = {
-            recordButton: document.getElementById('recordButton'),
-            stopButton: document.getElementById('stopButton'),
-            pauseButton: document.getElementById('pauseButton'),
-            markButton: document.getElementById('markButton'),
-            extractButton: document.getElementById('extractButton'),
-            rerecordButton: document.getElementById('rerecordButton'),
-            status: document.getElementById('status'),
-            timer: document.getElementById('timer'),
-            recordingIndicator: document.getElementById('recording-indicator'),
-            audioLevelIndicator: document.getElementById('audio-level-indicator'),
-            reviewSection: document.getElementById('review-section'),
-            audioPlayback: document.getElementById('audio-playback'),
-            transcriptionContainer: document.getElementById('transcription-container'),
-            originalTranscriptionBox: document.getElementById('original-transcription-box'),
-            translatedTranscriptionBox: document.getElementById('translated-transcription-box'),
-            recordingControls: document.getElementById('recording-controls'),
-            languageSelect: document.getElementById('languageSelect'),
-            translationToggle: document.getElementById('translationToggle'),
-            targetLanguage: document.getElementById('targetLanguage'),
-            translationSection: document.getElementById('translation-section'),
-            markersSection: document.getElementById('markers-section'),
-            markersList: document.getElementById('markers-list'),
-            loadingIndicator: document.getElementById('loading-indicator'),
-            messageContainer: document.getElementById('message-container')
-        };
-
-        // --- State ---
-        let state = {
-            mediaRecorder: null,
-            audioChunks: [],
-            audioBlob: null,
-            timerInterval: null,
-            seconds: 0,
-            microphoneStream: null,
-            markers: [],
-            currentResult: null
-        };
-
-        // --- Event Listeners ---
-        elements.recordButton.addEventListener('click', startRecording);
-        elements.stopButton.addEventListener('click', stopRecording);
-        elements.pauseButton.addEventListener('click', togglePause);
-        elements.markButton.addEventListener('click', markTimestamp);
-        elements.extractButton.addEventListener('click', processAudio);
-        elements.rerecordButton.addEventListener('click', resetRecorder);
-        elements.languageSelect.addEventListener('change', changeLanguage);
-        elements.translationToggle.addEventListener('change', toggleTranslationUI);
-        elements.targetLanguage.addEventListener('change', updateTargetLanguageInfo);
-
-        // --- Translation System ---
-        async function loadTranslations(language) {
-            try {
-                const response = await fetch(`http://localhost:5001/ui-translations/${language}`);
-                if (response.ok) {
-                    const data = await response.json();
-                    if (data.success) {
-                        translations = data.translations;
-                        applyTranslations();
-                        
-                        // Update HTML direction for RTL languages
-                        if (language === 'ar') {
-                            document.documentElement.setAttribute('dir', 'rtl');
-                            document.documentElement.setAttribute('lang', 'ar');
-                        } else {
-                            document.documentElement.setAttribute('dir', 'ltr');
-                            document.documentElement.setAttribute('lang', language);
-                        }
-                    }
-                }
-            } catch (error) {
-                console.error('Failed to load translations:', error);
-                // Fallback to default English
-                translations = getDefaultTranslations();
-                applyTranslations();
-            }
-        }
-
-        function getDefaultTranslations() {
-            return {
-                'start_recording': 'Start Recording',
-                'stop_recording': 'Stop Recording',
-                'pause_recording': 'Pause Recording',
-                'resume_recording': 'Resume Recording',
-                'mark_important': 'Mark Important',
-                'extract_text': 'Extract Text',
-                'rerecord': 'Re-record',
-                'processing': 'Processing...',
-                'ready_to_record': 'Ready to Record',
-                'recording': 'Recording...',
-                'paused': 'Paused',
-                'review_recording': 'Review your recording',
-                'processing_complete': 'Processing Complete!',
-                'microphone_permission': 'Microphone permission denied.',
-                'browser_not_supported': 'Your browser does not support audio recording.',
-                'transcription': 'Transcription',
-                'translation': 'Translation',
-                'markers': 'Important Markers',
-                'error_occurred': 'An error occurred',
-                'success': 'Success'
-            };
-        }
-
-        function applyTranslations() {
-            // Update text elements
-            const textMappings = {
-                'main-title': 'Lecture Recorder',
-                'subtitle': 'Record and transcribe your lectures with AI-powered translation',
-                'translation-label': 'Enable Translation:',
-                'record-text': translations.start_recording || 'Start',
-                'pause-text': translations.pause_recording || 'Pause',
-                'stop-text': translations.stop_recording || 'Stop',
-                'mark-text': translations.mark_important || 'Mark Important',
-                'extract-text': translations.extract_text || 'Extract Text',
-                'rerecord-text': translations.rerecord || 'Re-record',
-                'review-title': translations.review_recording || 'Review Recording',
-                'transcription-title': translations.processing_complete || 'Processing Result',
-                'original-text-label': 'Original Text:',
-                'translated-text-label': getTargetLanguageName() + ' Translation:',
-                'markers-label': translations.markers || 'Important Markers'
-            };
-
-            Object.entries(textMappings).forEach(([id, text]) => {
-                const element = document.getElementById(id);
-                if (element) {
-                    element.textContent = text;
-                }
-            });
-        }
-
-        function getTargetLanguageName() {
-            const langMap = {
-                'ar': 'Arabic (العربية)',
-                'en': 'English',
-                'fr': 'French (Français)',
-                'es': 'Spanish (Español)'
-            };
-            return langMap[elements.targetLanguage.value] || 'Translation';
-        }
-
-        async function changeLanguage() {
-            currentLanguage = elements.languageSelect.value;
-            await loadTranslations(currentLanguage);
-        }
-
-        function toggleTranslationUI() {
-            const isEnabled = elements.translationToggle.checked;
-            elements.targetLanguage.disabled = !isEnabled;
-            updateTargetLanguageInfo();
-            
-            // Show/hide translation section preview
-            updateTranslationSectionVisibility();
-        }
-        
-        function updateTranslationSectionVisibility() {
-            // Always prepare translation section when translation is enabled
-            if (elements.translationToggle.checked) {
-                // Make sure translation section is ready to be shown
-                const translatedLabelElement = document.getElementById('translated-text-label');
-                if (translatedLabelElement) {
-                    translatedLabelElement.textContent = getTargetLanguageName() + ' Translation:';
-                }
-            }
-        }
-
-        function updateTargetLanguageInfo() {
-            const targetLangElement = document.getElementById('target-language-info');
-            if (targetLangElement) {
-                targetLangElement.textContent = getTargetLanguageName();
-            }
-            
-            const translatedLabelElement = document.getElementById('translated-text-label');
-            if (translatedLabelElement) {
-                translatedLabelElement.textContent = getTargetLanguageName() + ' Translation:';
-            }
-        }
-        // --- Core Recording Functions ---
-        async function startRecording() {
-            if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
-                showMessage(translations.browser_not_supported || 'Your browser does not support audio recording.', 'error');
-                return;
-            }
-            try {
-                state.microphoneStream = await navigator.mediaDevices.getUserMedia({ audio: true });
-                updateUIMode('recording');
-                
-                state.audioChunks = [];
-                state.markers = [];
-                state.mediaRecorder = new MediaRecorder(state.microphoneStream);
-                state.mediaRecorder.ondataavailable = event => state.audioChunks.push(event.data);
-                state.mediaRecorder.onstop = handleRecordingStop;
-                
-                state.mediaRecorder.start();
-                startTimer();
-                visualizeAudio(state.microphoneStream);
-            } catch (error) {
-                showMessage(translations.microphone_permission || 'Microphone permission denied.', 'error');
-                console.error('Error accessing microphone:', error);
-            }
-        }
-
-        function stopRecording() {
-            if (state.mediaRecorder && state.mediaRecorder.state !== 'inactive') {
-                state.mediaRecorder.stop();
-            }
-        }
-
-        function handleRecordingStop() {
-            state.audioBlob = new Blob(state.audioChunks, { type: 'audio/wav' });
-            elements.audioPlayback.src = URL.createObjectURL(state.audioBlob);
-            state.microphoneStream.getTracks().forEach(track => track.stop());
-            clearInterval(state.timerInterval);
-            updateUIMode('review');
-        }
-
-        function togglePause() {
-            if (!state.mediaRecorder) return;
-            if (state.mediaRecorder.state === 'recording') {
-                state.mediaRecorder.pause();
-                updateUIMode('paused');
-            } else if (state.mediaRecorder.state === 'paused') {
-                state.mediaRecorder.resume();
-                updateUIMode('recording');
-            }
-        }
-
-        function markTimestamp() {
-            state.markers.push(state.seconds);
-            const markCount = state.markers.length;
-            elements.markButton.innerHTML = `<span>📌</span><span>Marked (${markCount})</span>`;
-            setTimeout(() => {
-                elements.markButton.innerHTML = `<span>📌</span><span>${translations.mark_important || 'Mark Important'}</span>`;
-            }, 1000);
-        }
-
-        async function processAudio() {
-            if (!state.audioBlob) return;
-            updateUIMode('processing');
-
-            const formData = new FormData();
-            formData.append('audio_data', state.audioBlob, 'recording.wav');
-            formData.append('markers', JSON.stringify(state.markers));
-            formData.append('enable_translation', elements.translationToggle.checked.toString());
-            formData.append('target_language', elements.targetLanguage.value);
-
-            try {
-                // Try multiple server URLs in case of port conflicts
-                const serverUrls = [
-                    'http://localhost:5001/record',
-                    'http://127.0.0.1:5001/record',
-                    'http://localhost:5000/record'
-                ];
-                
-                let response = null;
-                let lastError = null;
-                
-                for (const url of serverUrls) {
-                    try {
-                        console.log(`Trying server URL: ${url}`);
-                        response = await fetch(url, { 
-                            method: 'POST', 
-                            body: formData,
-                            timeout: 30000 // 30 seconds timeout
-                        });
-                        
-                        if (response.ok) {
-                            console.log(`Successfully connected to: ${url}`);
-                            break;
-                        }
-                    } catch (error) {
-                        console.log(`Failed to connect to ${url}:`, error.message);
-                        lastError = error;
-                        continue;
-                    }
-                }
-                
-                if (!response || !response.ok) {
-                    throw new Error(`Server connection failed. Last error: ${lastError?.message || 'Unknown error'}`);
-                }
-                
-                const result = await response.json();
-                
-                // Debug logging for translation analysis
-                console.log('🔍 SERVER RESPONSE ANALYSIS:');
-                console.log('- Success:', result.success);
-                console.log('- Translation enabled:', result.translation_enabled);
-                console.log('- Translation success:', result.translation_success);
-                console.log('- Original text:', result.original_text?.substring(0, 50) + '...');
-                console.log('- Translated text:', result.translated_text?.substring(0, 50) + '...');
-                console.log('- Target language:', result.target_language);
-                console.log('- Detected language:', result.language_detected);
-                console.log('- Are texts different?:', result.translated_text !== result.original_text);
-                
-                if (result.success) {
-                    state.currentResult = result;
-                    console.log('💾 STORED RESULT IN STATE:');
-                    console.log('- Complete result object:', result);
-                    console.log('- Available keys:', Object.keys(result));
-                    console.log('- state.currentResult set to:', state.currentResult);
-                    displayResults(result);
-                    updateUIMode('result');
-                    showMessage(translations.success || 'Success!', 'success');
-                } else {
-                    throw new Error(result.error || 'Processing failed');
-                }
-            } catch (error) {
-                updateUIMode('review');
-                const errorMessage = `${translations.error_occurred || 'Error'}: ${error.message}`;
-                showMessage(errorMessage, 'error');
-                console.error("Processing Error:", error);
-                
-                // Show detailed error for debugging
-                const detailedError = document.createElement('div');
-                detailedError.className = 'error-message';
-                detailedError.innerHTML = `
-                    <strong>Connection Error Details:</strong><br>
-                    • Make sure the recorder server is running on port 5001<br>
-                    • Try running: <code>python recorder_server.py</code><br>
-                    • Check if port 5001 is available<br>
-                    • Error: ${error.message}
-                `;
-                elements.messageContainer.appendChild(detailedError);
-            }
-        }
-
-        function displayResults(result) {
-            console.log('🎯 DISPLAY RESULTS FUNCTION:');
-            console.log('- Translation enabled:', result.translation_enabled);
-            console.log('- Has translated text:', !!result.translated_text);
-            console.log('- Translation section element:', !!elements.translationSection);
-            
-            // Display original transcription
-            elements.originalTranscriptionBox.value = result.original_text || result.text || '';
-            
-            // Always show translation section if translation toggle is enabled or we have translated text
-            const shouldShowTranslation = (
-                elements.translationToggle.checked || 
-                (result.translated_text && result.translated_text.trim())
-            );
-            
-            console.log('- Should show translation:', shouldShowTranslation);
-            console.log('- Translation toggle checked:', elements.translationToggle.checked);
-            console.log('- Has translated text content:', !!(result.translated_text && result.translated_text.trim()));
-            
-            if (shouldShowTranslation) {
-                console.log('✅ Showing translation section');
-                
-                // Set translated text or show placeholder if no translation
-                if (result.translated_text && result.translated_text.trim()) {
-                    elements.translatedTranscriptionBox.value = result.translated_text;
-                } else {
-                    elements.translatedTranscriptionBox.value = result.original_text || 'Translation in progress...';
-                }
-                
-                elements.translationSection.style.display = 'block';
-                
-                // Update language info
-                const detectedLangElement = document.getElementById('detected-language');
-                const targetLangElement = document.getElementById('target-language-info');
-                if (detectedLangElement) {
-                    const detectedLang = result.language_detected || 'Unknown';
-                    detectedLangElement.textContent = `Detected Language: ${detectedLang}`;
-                }
-                if (targetLangElement) {
-                    targetLangElement.textContent = getTargetLanguageName();
-                }
-                
-                // Add status indicator for translation quality
-                const translationStatus = document.createElement('div');
-                translationStatus.style.cssText = 'margin-top: 5px; font-size: 0.8em; padding: 3px 8px; border-radius: 4px;';
-                
-                if (result.translation_success === true) {
-                    translationStatus.style.backgroundColor = '#d4edda';
-                    translationStatus.style.color = '#155724';
-                    translationStatus.textContent = '✓ Translation successful';
-                } else if (!result.translated_text || result.translated_text === result.original_text) {
-                    translationStatus.style.backgroundColor = '#fff3cd';
-                    translationStatus.style.color = '#856404';
-                    translationStatus.textContent = '⚠ Translation failed - showing original text';
-                } else {
-                    translationStatus.style.backgroundColor = '#cce7ff';
-                    translationStatus.style.color = '#004085';
-                    translationStatus.textContent = '🔄 Translation completed';
-                }
-                
-                // Remove existing status if any
-                const existingStatus = elements.translationSection.querySelector('.translation-status');
-                if (existingStatus) {
-                    existingStatus.remove();
-                }
-                
-                // Add status indicator
-                translationStatus.className = 'translation-status';
-                elements.translationSection.appendChild(translationStatus);
-                
-            } else {
-                console.log('❌ Hiding translation section - conditions not met');
-                elements.translationSection.style.display = 'none';
-            }
-            
-            // Display markers if available
-            if (result.markers && result.markers.length > 0) {
-                displayMarkers(result.markers);
-                elements.markersSection.style.display = 'block';
-            } else {
-                elements.markersSection.style.display = 'none';
-            }
-
-            // Show summary button after successful transcription
-            const summaryActionSection = document.getElementById('summary-action-section');
-            if (summaryActionSection) {
-                summaryActionSection.style.display = 'block';
-            }
-        }
-
-        function displayMarkers(markers) {
-            const markersList = elements.markersList;
-            markersList.innerHTML = '';
-            
-            markers.forEach((timestamp, index) => {
-                const markerElement = document.createElement('span');
-                markerElement.style.cssText = 'display: inline-block; margin: 2px 5px; padding: 2px 8px; background: #007bff; color: white; border-radius: 12px; font-size: 0.85em;';
-                markerElement.textContent = `${index + 1}: ${formatTime(timestamp)}`;
-                markersList.appendChild(markerElement);
-            });
-        }
-
-        function resetRecorder() {
-            state = { 
-                ...state, 
-                audioChunks: [], 
-                audioBlob: null, 
-                seconds: 0, 
-                markers: [],
-                currentResult: null,
-                currentSummary: null
-            };
-            clearInterval(state.timerInterval);
-            elements.translationSection.style.display = 'none';
-            elements.markersSection.style.display = 'none';
-            
-            // Hide summary sections
-            const summaryActionSection = document.getElementById('summary-action-section');
-            const summarySection = document.getElementById('summary-section');
-            if (summaryActionSection) summaryActionSection.style.display = 'none';
-            if (summarySection) summarySection.style.display = 'none';
-            
-            updateUIMode('idle');
-        }
-
-        function updateUIMode(mode) {
-            const isRecording = mode === 'recording';
-            const isPaused = mode === 'paused';
-            const isReview = mode === 'review';
-            const isProcessing = mode === 'processing';
-            const isResult = mode === 'result';
-            const isIdle = mode === 'idle';
-
-            // Button states
-            elements.recordButton.disabled = !isIdle;
-            elements.stopButton.disabled = !isRecording && !isPaused;
-            elements.pauseButton.disabled = !isRecording && !isPaused;
-            elements.markButton.disabled = !isRecording && !isPaused;
-            elements.extractButton.disabled = !isReview;
-            elements.rerecordButton.disabled = !isReview && !isResult;
-
-            // UI Visibility
-            elements.recordingControls.style.display = (isReview || isResult || isProcessing) ? 'none' : 'block';
-            elements.reviewSection.style.display = (isReview || isResult) ? 'block' : 'none';
-            elements.transcriptionContainer.style.display = isResult ? 'block' : 'none';
-            elements.loadingIndicator.style.display = isProcessing ? 'block' : 'none';
-
-            // Recording indicator
-            elements.recordingIndicator.style.display = isRecording ? 'block' : 'none';
-
-            // Button text updates
-            const pauseTextElement = document.getElementById('pause-text');
-            if (pauseTextElement) {
-                pauseTextElement.textContent = isPaused ? 
-                    (translations.resume_recording || 'Resume') : 
-                    (translations.pause_recording || 'Pause');
-            }
-
-            // Status updates
-            if (isIdle) {
-                elements.status.textContent = translations.ready_to_record || 'Ready to Record';
-                elements.timer.textContent = '00:00:00';
-                elements.audioLevelIndicator.style.width = '0%';
-            } else if (isRecording) {
-                elements.status.textContent = translations.recording || 'Recording...';
-            } else if (isPaused) {
-                elements.status.textContent = translations.paused || 'Paused';
-            } else if (isReview) {
-                elements.status.textContent = translations.review_recording || 'Review your recording';
-            } else if (isProcessing) {
-                elements.status.textContent = translations.processing || 'Processing... please wait';
-                const loadingTextElement = document.getElementById('loading-text');
-                if (loadingTextElement) {
-                    loadingTextElement.textContent = translations.processing || 'Processing...';
-                }
-            } else if (isResult) {
-                elements.status.textContent = translations.processing_complete || 'Processing Complete!';
-            }
-        }
-
-        function startTimer() {
-            state.seconds = 0;
-            state.timerInterval = setInterval(() => {
-                state.seconds++;
-                elements.timer.textContent = formatTime(state.seconds);
-            }, 1000);
-        }
-
-        function formatTime(totalSeconds) {
-            const hours = Math.floor(totalSeconds / 3600).toString().padStart(2, '0');
-            const minutes = Math.floor((totalSeconds % 3600) / 60).toString().padStart(2, '0');
-            const seconds = (totalSeconds % 60).toString().padStart(2, '0');
-            return `${hours}:${minutes}:${seconds}`;
-        }
-
-        function visualizeAudio(stream) {
-            const audioContext = new (window.AudioContext || window.webkitAudioContext)();
-            const analyser = audioContext.createAnalyser();
-            const microphone = audioContext.createMediaStreamSource(stream);
-            microphone.connect(analyser);
-            analyser.fftSize = 256;
-            const dataArray = new Uint8Array(analyser.frequencyBinCount);
-
-            function draw() {
-                if (state.mediaRecorder && state.mediaRecorder.state === 'inactive') return;
-                requestAnimationFrame(draw);
-                analyser.getByteFrequencyData(dataArray);
-                const avg = dataArray.reduce((a, b) => a + b, 0) / dataArray.length;
-                elements.audioLevelIndicator.style.width = `${(avg / 128) * 100}%`;
-            }
-            draw();
-        }
-
-        function showMessage(message, type = 'info') {
-            const messageElement = document.createElement('div');
-            messageElement.className = `${type}-message`;
-            messageElement.textContent = message;
-            
-            elements.messageContainer.innerHTML = '';
-            elements.messageContainer.appendChild(messageElement);
-            
-            // Auto-hide after 5 seconds
-            setTimeout(() => {
-                if (elements.messageContainer.contains(messageElement)) {
-                    elements.messageContainer.removeChild(messageElement);
-                }
-            }, 5000);
-        }
-
-        // --- Keyboard Shortcuts ---
-        document.addEventListener('keydown', function(event) {
-            if (event.target.tagName === 'TEXTAREA' || event.target.tagName === 'INPUT') return;
-            
-            switch(event.code) {
-                case 'Space':
-                    event.preventDefault();
-                    if (!elements.recordButton.disabled) {
-                        startRecording();
-                    } else if (!elements.stopButton.disabled) {
-                        stopRecording();
-                    }
-                    break;
-                case 'KeyM':
-                    if (!elements.markButton.disabled) {
-                        markTimestamp();
-                    }
-                    break;
-                case 'KeyP':
-                    if (!elements.pauseButton.disabled) {
-                        togglePause();
-                    }
-                    break;
-                case 'KeyR':
-                    if (!elements.rerecordButton.disabled) {
-                        resetRecorder();
-                    }
-                    break;
-            }
-        });
-
-        // --- Server Status Check ---
-        async function checkServerStatus() {
-            const statusIndicator = document.createElement('div');
-            statusIndicator.id = 'server-status';
-            statusIndicator.style.cssText = `
-                position: fixed;
-                top: 10px;
-                left: 10px;
-                padding: 8px 12px;
-                border-radius: 6px;
-                font-size: 12px;
-                font-weight: bold;
-                z-index: 1000;
-                transition: all 0.3s;
-            `;
-            document.body.appendChild(statusIndicator);
-            
-            try {
-                const response = await fetch('http://localhost:5001/record', { method: 'GET' });
-                if (response.ok) {
-                    statusIndicator.textContent = '🟢 Server Connected';
-                    statusIndicator.style.background = '#d4edda';
-                    statusIndicator.style.color = '#155724';
-                    statusIndicator.style.border = '1px solid #c3e6cb';
-                } else {
-                    throw new Error('Server not responding');
-                }
-            } catch (error) {
-                statusIndicator.textContent = '🔴 Server Disconnected';
-                statusIndicator.style.background = '#f8d7da';
-                statusIndicator.style.color = '#721c24';
-                statusIndicator.style.border = '1px solid #f5c6cb';
-                
-                // Show connection instructions
-                setTimeout(() => {
-                    if (statusIndicator.parentNode) {
-                        statusIndicator.innerHTML = `
-                            🔴 Server Offline<br>
-                            <small>Run: python recorder_server.py</small>
-                        `;
-                    }
-                }, 2000);
-            }
-        }
-
-        // --- Summary and Notes System ---
-        async function generateSummary() {
-            console.log('🤖 GENERATE SUMMARY DEBUG:');
-            console.log('- state.currentResult:', state.currentResult);
-            console.log('- original_text:', state.currentResult?.original_text);
-            console.log('- text:', state.currentResult?.text);
-            console.log('- translated_text:', state.currentResult?.translated_text);
-            
-            if (!state.currentResult) {
-                console.log('❌ No currentResult found');
-                showMessage('لا توجد نتائج متاحة للملخص', 'error');
-                return;
-            }
-            
-            const textToSummarize = state.currentResult.original_text || state.currentResult.text || state.currentResult.translated_text;
-            
-            if (!textToSummarize || textToSummarize.trim() === '') {
-                console.log('❌ No text available for summarization');
-                console.log('Available properties:', Object.keys(state.currentResult));
-                showMessage('لا يوجد نص متاح للملخص', 'error');
-                return;
-            }
-            
-            console.log('✅ Text to summarize:', textToSummarize.substring(0, 100) + '...');
-
-            const summaryBtn = document.getElementById('generateSummaryBtn');
-            const originalContent = summaryBtn.innerHTML;
-            summaryBtn.disabled = true;
-            summaryBtn.innerHTML = '<span>⏳</span><span>جاري إنشاء الملخص...</span>';
-
-            try {
-                console.log('📤 Sending summarization request...');
-                console.log('📤 Request payload:', {
-                    text: textToSummarize.substring(0, 100) + '...',
-                    language: elements.targetLanguage.value || 'arabic'
-                });
-                
-                const response = await fetch('http://localhost:5001/summarize', {
-                    method: 'POST',
-                    headers: { 
-                        'Content-Type': 'application/json',
-                        'Accept': 'application/json'
-                    },
-                    body: JSON.stringify({
-                        text: textToSummarize,
-                        language: elements.targetLanguage.value || 'arabic',
-                        type: 'full'
-                    })
-                });
-
-                console.log('📥 Response status:', response.status);
-                console.log('📥 Response headers:', response.headers);
-
-                if (response.ok) {
-                    const data = await response.json();
-                    console.log('📥 Summarization response:', data);
-                    
-                    if (data.success) {
-                        // التعامل مع الاستجابة الجديدة
-                        if (data.summary) {
-                            displaySummaryResults(data.summary);
-                            showMessage('تم إنشاء الملخص بنجاح!', 'success');
-                        } else {
-                            console.error('❌ No summary in response:', data);
-                            showMessage('لم يتم العثور على ملخص في الاستجابة', 'error');
-                        }
-                    } else {
-                        throw new Error(data.error || 'فشل في إنشاء الملخص');
-                    }
-                } else {
-                    const errorText = await response.text();
-                    console.error('❌ HTTP Error:', response.status, errorText);
-                    throw new Error(`خطأ في الشبكة: ${response.status} - ${errorText}`);
-                }
-            } catch (error) {
-                console.error('❌ Summary generation error:', error);
-                
-                // رسائل خطأ محددة
-                let errorMessage = 'فشل في إنشاء الملخص';
-                if (error.name === 'TypeError' && error.message.includes('fetch')) {
-                    errorMessage = 'لا يمكن الاتصال بخادم التلخيص - تأكد من تشغيل الخادم';
-                } else if (error.message.includes('CORS')) {
-                    errorMessage = 'مشكلة في إعدادات CORS - يجب إعادة تشغيل الخادم';
-                } else {
-                    errorMessage = error.message;
-                }
-                
-                showMessage(errorMessage, 'error');
-            } finally {
-                summaryBtn.disabled = false;
-                summaryBtn.innerHTML = originalContent;
-            }
-        }
-
-        function displaySummaryResults(summary) {
-            console.log('📝 Displaying summary results:', summary);
-            
-            // Show the summary section
-            document.getElementById('summary-section').style.display = 'block';
-            
-            // التعامل مع تنسيق الاستجابة - قد يكون النص مباشرة أو كائن
-            let summaryText = '';
-            if (typeof summary === 'string') {
-                summaryText = summary;
-            } else if (summary && summary.main_summary) {
-                summaryText = summary.main_summary;
-            } else if (summary && typeof summary === 'object') {
-                // إذا كانت الاستجابة كائن، نأخذ المحتوى النصي
-                summaryText = JSON.stringify(summary, null, 2);
-            }
-            
-            // Display main summary
-            const summaryTextSection = document.getElementById('summary-text-section');
-            const summaryTextElement = document.getElementById('summary-text');
-            if (summaryTextSection && summaryTextElement && summaryText) {
-                summaryTextElement.innerHTML = summaryText.replace(/\n/g, '<br>');
-                summaryTextSection.style.display = 'block';
-            }
-
-            // Display key points (إذا كانت متوفرة)
-            const keyPointsSection = document.getElementById('key-points-section');
-            const keyPointsList = document.getElementById('key-points-list');
-            if (keyPointsSection && keyPointsList && summary && summary.key_points && Array.isArray(summary.key_points)) {
-                keyPointsList.innerHTML = summary.key_points.map(point => `<li>${point}</li>`).join('');
-                keyPointsSection.style.display = 'block';
-            }
-
-            // Display review questions (إذا كانت متوفرة)
-            const questionsSection = document.getElementById('questions-section');
-            const questionsList = document.getElementById('questions-list');
-            if (questionsSection && questionsList && summary && summary.review_questions && Array.isArray(summary.review_questions)) {
-                questionsList.innerHTML = summary.review_questions.map(question => `<li>${question}</li>`).join('');
-                questionsSection.style.display = 'block';
-            }
-
-            // Show save note section
-            const saveNoteSection = document.getElementById('save-note-section');
-            if (saveNoteSection) {
-                saveNoteSection.style.display = 'block';
-            }
-            
-            // Store current summary in state for saving
-            state.currentSummary = summary;
-        }
-
-        async function saveNote() {
-            if (!state.currentSummary) {
-                showMessage('لا يوجد ملخص متاح للحفظ', 'error');
-                return;
-            }
-
-            const title = document.getElementById('noteTitle').value.trim();
-            const tags = document.getElementById('noteTags').value.trim();
-            
-            if (!title) {
-                showMessage('يرجى إدخال عنوان للمذكرة', 'error');
-                return;
-            }
-
-            const saveBtn = document.getElementById('saveNoteBtn');
-            const originalText = saveBtn.textContent;
-            saveBtn.disabled = true;
-            saveBtn.textContent = 'جاري الحفظ...';
-
-            try {
-                const contentToSave = state.currentResult.original_text || state.currentResult.text;
-                const response = await fetch('http://localhost:5001/notes', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        title: title,
-                        content: contentToSave,
-                        summary: state.currentSummary,
-                        tags: tags ? tags.split(',').map(tag => tag.trim()) : [],
-                        markers: state.markers
-                    })
-                });
-
-                if (response.ok) {
-                    const data = await response.json();
-                    if (data.success) {
-                        showMessage('تم حفظ المذكرة بنجاح!', 'success');
-                        // Clear form
-                        document.getElementById('noteTitle').value = '';
-                        document.getElementById('noteTags').value = '';
-                        // Refresh notes list
-                        loadNotesList();
-                    } else {
-                        throw new Error(data.error || 'Failed to save note');
-                    }
-                } else {
-                    throw new Error('Network error while saving note');
-                }
-            } catch (error) {
-                console.error('Note saving error:', error);
-                showMessage('فشل في حفظ المذكرة: ' + error.message, 'error');
-            } finally {
-                saveBtn.disabled = false;
-                saveBtn.textContent = originalText;
-            }
-        }
-
-        async function loadNotesList() {
-            try {
-                const response = await fetch('http://localhost:5001/notes');
-                if (response.ok) {
-                    const data = await response.json();
-                    if (data.success) {
-                        displayNotesList(data.notes);
-                    }
-                }
-            } catch (error) {
-                console.error('Failed to load notes:', error);
-            }
-        }
-
-        function displayNotesList(notes) {
-            const notesContainer = document.getElementById('notesContainer');
-            
-            if (notes.length === 0) {
-                notesContainer.innerHTML = '<p class="text-center text-muted">No saved notes yet</p>';
-                return;
-            }
-
-            notesContainer.innerHTML = notes.map(note => `
-                <div class="note-item" data-note-id="${note.id}">
-                    <div class="note-header">
-                        <h4>${note.title}</h4>
-                        <span class="note-date">${new Date(note.created_at).toLocaleDateString()}</span>
-                    </div>
-                    <div class="note-summary">
-                        ${note.summary ? note.summary.main_summary.substring(0, 150) + '...' : 'No summary available'}
-                    </div>
-                    <div class="note-tags">
-                        ${note.tags ? note.tags.map(tag => `<span class="tag">${tag}</span>`).join('') : ''}
-                    </div>
-                    <div class="note-actions">
-                        <button onclick="viewNote(${note.id})" class="btn-secondary">View</button>
-                        <button onclick="deleteNote(${note.id})" class="btn-danger">Delete</button>
-                    </div>
-                </div>
-            `).join('');
-        }
-
-        async function viewNote(noteId) {
-            try {
-                const response = await fetch(`http://localhost:5001/notes/${noteId}`);
-                if (response.ok) {
-                    const data = await response.json();
-                    if (data.success) {
-                        displayNoteDetails(data.note);
-                    }
-                }
-            } catch (error) {
-                console.error('Failed to load note:', error);
-                showMessage('Failed to load note details', 'error');
-            }
-        }
-
-        function displayNoteDetails(note) {
-            // Create modal or expand view for note details
-            const modal = document.createElement('div');
-            modal.className = 'note-modal';
-            modal.innerHTML = `
-                <div class="note-modal-content">
-                    <div class="note-modal-header">
-                        <h2>${note.title}</h2>
-                        <button onclick="closeNoteModal()" class="close-btn">&times;</button>
-                    </div>
-                    <div class="note-modal-body">
-                        <div class="note-section">
-                            <h3>Summary</h3>
-                            <p>${note.summary ? note.summary.main_summary : 'No summary available'}</p>
-                        </div>
-                        ${note.summary && note.summary.key_points ? `
-                        <div class="note-section">
-                            <h3>Key Points</h3>
-                            <ul>${note.summary.key_points.map(point => `<li>${point}</li>`).join('')}</ul>
-                        </div>
-                        ` : ''}
-                        <div class="note-section">
-                            <h3>Full Transcription</h3>
-                            <p>${note.content}</p>
-                        </div>
-                        ${note.tags && note.tags.length > 0 ? `
-                        <div class="note-section">
-                            <h3>Tags</h3>
-                            <div class="note-tags">
-                                ${note.tags.map(tag => `<span class="tag">${tag}</span>`).join('')}
-                            </div>
-                        </div>
-                        ` : ''}
-                    </div>
-                </div>
-            `;
-            document.body.appendChild(modal);
-        }
-
-        function closeNoteModal() {
-            const modal = document.querySelector('.note-modal');
-            if (modal) {
-                modal.remove();
-            }
-        }
-
-        async function deleteNote(noteId) {
-            if (!confirm('Are you sure you want to delete this note?')) {
-                return;
-            }
-
-            try {
-                const response = await fetch(`http://localhost:5001/notes/${noteId}`, {
-                    method: 'DELETE'
-                });
-
-                if (response.ok) {
-                    const data = await response.json();
-                    if (data.success) {
-                        showMessage('Note deleted successfully', 'success');
-                        loadNotesList();
-                    } else {
-                        throw new Error(data.error || 'Failed to delete note');
-                    }
-                } else {
-                    throw new Error('Network error while deleting note');
-                }
-            } catch (error) {
-                console.error('Delete note error:', error);
-                showMessage('Failed to delete note: ' + error.message, 'error');
-            }
-        }
-
-        function searchNotes() {
-            const searchTerm = document.getElementById('notesSearch').value.toLowerCase();
-            const noteItems = document.querySelectorAll('.note-item');
-            
-            noteItems.forEach(item => {
-                const title = item.querySelector('h4').textContent.toLowerCase();
-                const summary = item.querySelector('.note-summary').textContent.toLowerCase();
-                const tags = item.querySelector('.note-tags').textContent.toLowerCase();
-                
-                if (title.includes(searchTerm) || summary.includes(searchTerm) || tags.includes(searchTerm)) {
-                    item.style.display = 'block';
-                } else {
-                    item.style.display = 'none';
-                }
-            });
-        }
-
-        // --- Initialization ---
-        async function initialize() {
-            await loadTranslations(currentLanguage);
-            await checkServerStatus();
-            toggleTranslationUI();
-            updateTargetLanguageInfo();
-            resetRecorder();
-            
-            // Load existing notes
-            loadNotesList();
-            
-            // Add event listeners for summary and notes
-            const generateSummaryBtn = document.getElementById('generateSummaryBtn');
-            const saveNoteBtn = document.getElementById('saveNoteBtn');
-            const notesSearch = document.getElementById('notesSearch');
-            
-            if (generateSummaryBtn) {
-                generateSummaryBtn.addEventListener('click', generateSummary);
-            }
-            if (saveNoteBtn) {
-                saveNoteBtn.addEventListener('click', saveNote);
-            }
-            if (notesSearch) {
-                notesSearch.addEventListener('input', searchNotes);
-            }
-            
-            // Check server status every 30 seconds
-            setInterval(checkServerStatus, 30000);
-        }
-
-        // Start the application
-        initialize();
-    </script>
-</body>
-</html>

translator.py

@@ -6,6 +6,7 @@ import json
 import traceback
 from typing import Dict, List, Optional, Tuple
 import google.generativeai as genai
+import streamlit as st
 
 class AITranslator:
     """
@@ -13,7 +14,7 @@ class AITranslator:
     """
     
     def __init__(self):
-        self.client = None
+        self.model = None
         self.init_error = None
         self.supported_languages = {
             'ar': 'Arabic (العربية)',
@@ -28,16 +29,20 @@ class AITranslator:
         self._initialize_gemini()
     
     def _initialize_gemini(self):
-        """Initialize Gemini AI client"""
+        """Initialize Gemini AI client using the new API structure."""
         try:
             load_dotenv()
             api_key = os.getenv("GEMINI_API_KEY")
             if not api_key:
-                raise ValueError("GEMINI_API_KEY not found in environment variables.")
-            self.client = genai.Client(api_key=api_key)
+                # This error is handled by the main app now, but we keep a fallback.
+                self.init_error = "GEMINI_API_KEY not found."
+                return
+
+            genai.configure(api_key=api_key)
+            self.model = genai.GenerativeModel('gemini-1.5-flash')
         except Exception as e:
             self.init_error = f"FATAL ERROR during Gemini Init: {str(e)}"
-            self.client = None
+            self.model = None
     
     def translate_text(self, text: str, target_language: str = 'ar', source_language: str = 'auto') -> Tuple[Optional[str], Optional[str]]:
         """
@@ -54,27 +59,21 @@ class AITranslator:
         if self.init_error:
             return None, self.init_error
         
-        if not self.client:
-            return None, "ERROR: Gemini client is not available."
+        if not self.model:
+            return None, "ERROR: Gemini model is not available."
         
         if not text or not text.strip():
             return None, "ERROR: Empty text provided for translation."
         
         try:
-            # Get language name for better prompting
             target_lang_name = self.supported_languages.get(target_language, target_language)
-            
-            # Create specialized prompt for better translation quality
             prompt = self._create_translation_prompt(text, target_lang_name, target_language)
             
-            response = self.client.models.generate_content(
-                model="gemini-2.5-flash",
-                contents=[prompt]
-            )
+            # Use the new generate_content method on the model instance
+            response = self.model.generate_content(prompt)
             
-            if response and response.text:
+            if response and hasattr(response, 'text') and response.text:
                 translated_text = response.text.strip()
-                # Clean up any markdown formatting that might be added
                 translated_text = self._clean_translation_output(translated_text)
                 return translated_text, None
             else:
@@ -196,8 +195,8 @@ Text to translate:
         Returns:
             Tuple of (language_code, error_message)
         """
-        if not self.client:
-            return None, "ERROR: Gemini client not available"
+        if not self.model:
+            return None, "ERROR: Gemini model not available"
         
         try:
             prompt = f"""
@@ -215,12 +214,9 @@ Detect the language of the following text and return ONLY the language code:
 Text: {text[:200]}...
 """
             
-            response = self.client.models.generate_content(
-                model="gemini-2.5-flash",
-                contents=[prompt]
-            )
+            response = self.model.generate_content(prompt)
             
-            if response and response.text:
+            if response and hasattr(response, 'text') and response.text:
                 detected_lang = response.text.strip().lower()
                 return detected_lang, None
             else:
@@ -339,12 +335,10 @@ def get_translation(key: str, language: str = 'en') -> str:
     return UI_TRANSLATIONS.get(language, {}).get(key, UI_TRANSLATIONS['en'].get(key, key))
 
 
-# Initialize global translator instance
-translator_instance = None
-
+@st.cache_resource
 def get_translator():
-    """Get singleton translator instance"""
-    global translator_instance
-    if translator_instance is None:
-        translator_instance = AITranslator()
-    return translator_instance
+    """
+    Get a singleton translator instance using Streamlit's resource caching.
+    This ensures the model is initialized only once per session.
+    """
+    return AITranslator()