src/app.py

import os
import gradio as gr
import re
import logging # Added for debugging
from dotenv import load_dotenv
from src.core.transformer import TranscriptTransformer
from src.utils.pdf_processor import PDFProcessor
from src.utils.text_processor import TextProcessor

# Set up basic logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

load_dotenv()
logging.info("Environment variables loaded.")

# Translations dictionary for UI elements
TRANSLATIONS = {
    "en": {
        "title": "AI Script Generator",
        "subtitle": "Transform transcripts and PDFs into timed, structured teaching scripts using AI",
        "input_type_label": "Input Type",
        "input_type_options": ["PDF", "Raw Text"],
        "upload_pdf_label": "Upload Transcript (PDF)",
        "paste_text_label": "Paste Transcript Text",
        "paste_text_placeholder": "Paste your transcript text here...",
        "guiding_prompt_label": "Guiding Prompt (Optional)",
        "guiding_prompt_placeholder": "Additional instructions to customize the output. Examples: 'Use a more informal tone', 'Focus only on section X', 'Generate the content in Spanish', 'Include more practical programming examples', etc.",
        "guiding_prompt_info": "The Guiding Prompt allows you to provide specific instructions to modify the generated content, like output/desired LANGUAGE. You can use it to change the tone, style, focus ONLY on specific sections of the text, specify the output language (e.g., 'Generate in Spanish/French/German'), or give any other instruction that helps personalize the final result.",
        "duration_label": "Target Lecture Duration (minutes)",
        "examples_label": "Include Practical Examples",
        "thinking_model_label": "Use Experimental Thinking Model (Gemini Only)",
        "submit_button": "Transform Transcript",
        "output_label": "Generated Teaching Transcript",
        "error_no_pdf": "Error: No PDF file uploaded",
        "error_no_text": "Error: No text provided",
        "error_prefix": "Error processing transcript: ",
        "language_selector": "Language / Idioma",
        "show_timestamps": "Show Timestamps",
        "hide_timestamps": "Hide Timestamps"
    },
    "es": {
        "title": "Generador de Guiones IA",
        "subtitle": "Transforma transcripciones y PDFs en guiones de enseñanza estructurados y cronometrados usando IA",
        "input_type_label": "Tipo de Entrada",
        "input_type_options": ["PDF", "Texto"],
        "upload_pdf_label": "Subir Transcripción (PDF)",
        "paste_text_label": "Pegar Texto de Transcripción",
        "paste_text_placeholder": "Pega tu texto de transcripción aquí...",
        "guiding_prompt_label": "Instrucciones Guía (Opcional)",
        "guiding_prompt_placeholder": "Instrucciones adicionales para personalizar el resultado. Ejemplos: 'Usa un tono más informal', 'Enfócate solo en la sección X', 'Genera el contenido en inglés', 'Incluye más ejemplos prácticos de programación', etc.",
        "guiding_prompt_info": "Las Instrucciones Guía te permiten proporcionar indicaciones específicas para modificar el contenido generado, como el IDIOMA deseado. Puedes usarlas para cambiar el tono, estilo, enfocarte SOLO en secciones específicas del texto, especificar el idioma de salida (ej., 'Generar en inglés/francés/alemán'), o dar cualquier otra instrucción que ayude a personalizar el resultado final.",
        "duration_label": "Duración Objetivo de la Clase (minutos)",
        "examples_label": "Incluir Ejemplos Prácticos",
        "thinking_model_label": "Usar Modelo de Pensamiento Experimental (Solo Gemini)",
        "submit_button": "Transformar Transcripción",
        "output_label": "Guión de Enseñanza Generado",
        "error_no_pdf": "Error: No se ha subido ningún archivo PDF",
        "error_no_text": "Error: No se ha proporcionado texto",
        "error_prefix": "Error al procesar la transcripción: ",
        "language_selector": "Language / Idioma",
        "show_timestamps": "Mostrar Marcas de Tiempo",
        "hide_timestamps": "Ocultar Marcas de Tiempo"
    }
}

# Language-specific prompt suffixes to append automatically
LANGUAGE_PROMPTS = {
    "en": "",  # Default language doesn't need special instructions
    "es": "Generate the content in Spanish. Genera todo el contenido en español."
}

class TranscriptTransformerApp:
    def __init__(self):
        logging.info("Initializing TranscriptTransformerApp...")
        self.pdf_processor = PDFProcessor()
        self.text_processor = TextProcessor()
        self.current_language = "en"  # Default language
        self.last_generated_content = ""  # Store the last generated content
        self.content_with_timestamps = ""  # Store content with timestamps
        self.content_without_timestamps = ""  # Store content without timestamps
        logging.info("TranscriptTransformerApp initialized.")

    def process_transcript(self, 
                           language: str,
                           input_type: str,
                           file_obj: gr.File = None,
                           raw_text_input: str = "",
                           initial_prompt: str = "",
                           target_duration: int = 30,
                           include_examples: bool = True,
                           use_gemini: bool = True,
                           use_thinking_model: bool = False) -> str:
        """
        Process uploaded transcript and transform it into a teaching transcript
        
        Args:
            language: Selected UI language
            input_type: Type of input (PDF or Raw Text)
            file_obj: Uploaded PDF file (if input_type is PDF)
            raw_text_input: Raw text input (if input_type is Raw Text)
            initial_prompt: Additional guiding instructions for the content generation
            target_duration: Target lecture duration in minutes
            include_examples: Whether to include practical examples
            use_gemini: Whether to use Gemini API instead of OpenAI
            use_thinking_model: Requires use_gemini=True
            
        Returns:
            str: Generated teaching transcript
        """
        logging.info(f"Processing transcript. Language: {language}, InputType: {input_type}, HasFile: {file_obj is not None}, HasText: {bool(raw_text_input)}, Duration: {target_duration}, Examples: {include_examples}, Gemini: {use_gemini}, ThinkingModel: {use_thinking_model}")
        try:
            # Force enable Gemini if thinking model is selected
            if use_thinking_model:
                logging.info("Thinking model selected, forcing use_gemini=True")
                use_gemini = True
                
            self.transformer = TranscriptTransformer(
                use_gemini=use_gemini,
                use_thinking_model=use_thinking_model
            )
            
            # Get text based on input type
            if input_type == TRANSLATIONS[language]["input_type_options"][0]:  # PDF
                if file_obj is None:
                    return TRANSLATIONS[language]["error_no_pdf"]
                raw_text = self.pdf_processor.extract_text(file_obj.name)
            else:  # Raw Text
                if not raw_text_input.strip():
                    return TRANSLATIONS[language]["error_no_text"]
                raw_text = raw_text_input
            
            # Modify initial prompt based on language if no explicit language instruction is given
            modified_prompt = initial_prompt
            
            # Check if user has specified a language in the prompt
            language_keywords = ["spanish", "español", "english", "inglés", "french", "francés", "german", "alemán"]
            user_specified_language = any(keyword in initial_prompt.lower() for keyword in language_keywords)
            
            # Only append language instruction if user hasn't specified one and we have a non-default language
            if not user_specified_language and language in LANGUAGE_PROMPTS and LANGUAGE_PROMPTS[language]:
                if modified_prompt:
                    modified_prompt += " " + LANGUAGE_PROMPTS[language]
                else:
                    modified_prompt = LANGUAGE_PROMPTS[language]
            
            # Transform to teaching transcript with user guidance
            lecture_transcript = self.transformer.transform_to_lecture(
                text=raw_text,
                target_duration=target_duration,
                include_examples=include_examples,
                initial_prompt=modified_prompt
            )
            
            # Store the generated content
            self.content_with_timestamps = lecture_transcript
            logging.info("Generated content stored (with timestamps).")
            
            # Create a version without timestamps
            self.content_without_timestamps = self.remove_timestamps(lecture_transcript)
            logging.info("Generated content stored (without timestamps).")
            
            # Default: show content with timestamps
            self.last_generated_content = lecture_transcript
            
            logging.info("Transcript processing successful.")
            return lecture_transcript
            
        except Exception as e:
            logging.error(f"Error processing transcript: {e}", exc_info=True) # Log exception info
            return f"{TRANSLATIONS[language]['error_prefix']}{str(e)}"
    
    def remove_timestamps(self, text):
        """Remove all timestamps (e.g., [00:00]) from the text"""
        logging.info("Removing timestamps...")
        # Regex to match the timestamp pattern [MM:SS] or [HH:MM:SS]
        result = re.sub(r'\[\d{1,2}:\d{2}(:\d{2})?\]', '', text)
        logging.info("Timestamps removed.")
        return result
    
    def toggle_timestamps(self, show_timestamps):
        """Toggle visibility of timestamps in output"""
        logging.info(f"Toggling timestamps visibility. Show: {show_timestamps}")
        if show_timestamps:
            logging.info("Returning content WITH timestamps.")
            return self.content_with_timestamps
        else:
            logging.info("Returning content WITHOUT timestamps.")
            return self.content_without_timestamps
    
    def update_ui_language(self, language):
        """Update UI elements based on selected language"""
        logging.info(f"Updating UI language to: {language}")
        self.current_language = language
        
        translations = TRANSLATIONS[language]
        
        return [
            translations["title"],
            translations["subtitle"],
            translations["input_type_label"],
            gr.update(choices=translations["input_type_options"], value=translations["input_type_options"][0]),
            translations["upload_pdf_label"],
            translations["paste_text_label"],
            translations["paste_text_placeholder"],
            translations["guiding_prompt_label"],
            translations["guiding_prompt_placeholder"],
            translations["guiding_prompt_info"],
            translations["duration_label"],
            translations["examples_label"],
            translations["thinking_model_label"],
            translations["submit_button"],
            translations["output_label"]
        ]
        logging.info("UI language updated.")

    def launch(self):
        """Launch the Gradio interface"""
        logging.info("Configuring Gradio interface...")
        # Get the path to the example PDF
        example_pdf = os.path.join(os.path.dirname(os.path.dirname(__file__)), "data", "sample2.pdf")
        logging.info(f"Example PDF path: {example_pdf}")
        
        with gr.Blocks(title=TRANSLATIONS["en"]["title"]) as interface:
            # Header with title and language selector side by side
            with gr.Row():
                with gr.Column(scale=4):
                    title_md = gr.Markdown("# " + TRANSLATIONS["en"]["title"])
                with gr.Column(scale=1):
                    language_selector = gr.Dropdown(
                        choices=["🇺🇸 English", "🇪🇸 Español"],
                        value="🇺🇸 English",
                        label=TRANSLATIONS["en"]["language_selector"],
                        elem_id="language-selector",
                        interactive=True
                    )
            
            # Subtitle
            subtitle_md = gr.Markdown(TRANSLATIONS["en"]["subtitle"])
            
            # Input type row
            with gr.Row():
                input_type = gr.Radio(
                    choices=TRANSLATIONS["en"]["input_type_options"],
                    label=TRANSLATIONS["en"]["input_type_label"],
                    value=TRANSLATIONS["en"]["input_type_options"][0]
                )
            
            # File/text input columns
            with gr.Row():
                with gr.Column(visible=True) as pdf_column:
                    file_input = gr.File(
                        label=TRANSLATIONS["en"]["upload_pdf_label"],
                        file_types=[".pdf"]
                    )
                
                with gr.Column(visible=False) as text_column:
                    text_input = gr.Textbox(
                        label=TRANSLATIONS["en"]["paste_text_label"],
                        lines=10,
                        placeholder=TRANSLATIONS["en"]["paste_text_placeholder"]
                    )
            
            # Guiding prompt 
            with gr.Row():
                initial_prompt = gr.Textbox(
                    label=TRANSLATIONS["en"]["guiding_prompt_label"],
                    lines=3,
                    value="",
                    placeholder=TRANSLATIONS["en"]["guiding_prompt_placeholder"],
                    info=TRANSLATIONS["en"]["guiding_prompt_info"]
                )
            
            # Settings row
            with gr.Row():
                target_duration = gr.Number(
                    label=TRANSLATIONS["en"]["duration_label"],
                    value=30,
                    minimum=2,
                    maximum=60,
                    step=1
                )
                
                include_examples = gr.Checkbox(
                    label=TRANSLATIONS["en"]["examples_label"],
                    value=True
                )
                
                use_thinking_model = gr.Checkbox(
                    label=TRANSLATIONS["en"]["thinking_model_label"],
                    value=True
                )
            
            # Submit button
            with gr.Row():
                submit_btn = gr.Button(TRANSLATIONS["en"]["submit_button"])
            
            # Output area
            output = gr.Textbox(
                label=TRANSLATIONS["en"]["output_label"],
                lines=25
            )
            
            # Toggle timestamps button and Copy button
            with gr.Row():
                timestamps_checkbox = gr.Checkbox(
                    label=TRANSLATIONS["en"]["show_timestamps"],
                    value=True,
                    interactive=True
                )
            
            # Map language dropdown values to language codes
            lang_map = {
                "🇺🇸 English": "en",
                "🇪🇸 Español": "es"
            }
            
            # Handle visibility of input columns based on selection
            def update_input_visibility(language_display, choice):
                language = lang_map.get(language_display, "en")
                return [
                    gr.update(visible=(choice == TRANSLATIONS[language]["input_type_options"][0])),  # pdf_column
                    gr.update(visible=(choice == TRANSLATIONS[language]["input_type_options"][1]))  # text_column
                ]
            
            # Get language code from display value
            def get_language_code(language_display):
                logging.info(f"Getting language code for display value: {language_display}")
                code = lang_map.get(language_display, "en")
                logging.info(f"Language code: {code}")
                return code
            
            # Update UI elements when language changes
            def update_ui_with_display(language_display):
                logging.info(f"Update UI triggered for language: {language_display}")
                language = get_language_code(language_display)
                self.current_language = language
                
                translations = TRANSLATIONS[language]
                
                return [
                    "# " + translations["title"],  # Title with markdown formatting
                    translations["subtitle"],
                    translations["input_type_label"],
                    gr.update(choices=translations["input_type_options"], value=translations["input_type_options"][0], label=translations["input_type_label"]),
                    gr.update(label=translations["upload_pdf_label"]),
                    gr.update(label=translations["paste_text_label"], placeholder=translations["paste_text_placeholder"]),
                    gr.update(label=translations["guiding_prompt_label"], placeholder=translations["guiding_prompt_placeholder"], info=translations["guiding_prompt_info"]),
                    gr.update(label=translations["duration_label"]),
                    gr.update(label=translations["examples_label"]),
                    gr.update(label=translations["thinking_model_label"]),
                    translations["submit_button"],
                    gr.update(label=translations["output_label"]),
                    gr.update(label=translations["show_timestamps"])
                ]
                logging.info("UI elements update values prepared.")
            
            input_type.change(
                fn=lambda lang_display, choice: update_input_visibility(lang_display, choice),
                inputs=[language_selector, input_type],
                outputs=[pdf_column, text_column]
            )
            
            # Language change event
            language_selector.change(
                fn=update_ui_with_display,
                inputs=language_selector,
                outputs=[
                    title_md, subtitle_md, 
                    input_type, input_type,
                    file_input, text_input,
                    initial_prompt,
                    target_duration, include_examples, use_thinking_model,
                    submit_btn, output,
                    timestamps_checkbox
                ]
            )
            
            # Toggle timestamps event
            timestamps_checkbox.change(
                fn=self.toggle_timestamps,
                inputs=[timestamps_checkbox],
                outputs=[output]
            )
            
            # Set up submission logic with language code conversion
            submit_btn.click(
                fn=lambda lang_display, *args: self.process_transcript(get_language_code(lang_display), *args),
                inputs=[
                    language_selector,
                    input_type,
                    file_input,
                    text_input,
                    initial_prompt,
                    target_duration,
                    include_examples,
                    use_thinking_model
                ],
                outputs=output
            )
            
            # Example for PDF input
            logging.info("Setting up Gradio Examples...")
            gr.Examples(
                examples=[[example_pdf, "", "", 30, True, True]],
                inputs=[file_input, text_input, initial_prompt, target_duration, include_examples, use_thinking_model]
            )
            logging.info("Gradio Examples configured.")
        
        logging.info("Launching Gradio interface...")
        # Note: Setting share=True is not recommended/supported in Spaces, but kept for consistency with original code
        # It might generate a warning, which is expected.
        interface.launch(share=True)
        logging.info("Gradio interface launched.")

if __name__ == "__main__":
    logging.info("Starting application...")
    app = TranscriptTransformerApp()
    app.launch()
    logging.info("Application finished.")