app.py

import gradio as gr
import os
import json
import hashlib
import shutil
import time
import re
import anthropic
from fpdf import FPDF
from pathlib      import Path
from dotenv       import load_dotenv
from google       import genai
from google.genai import types
from pdf2image    import convert_from_path
from PIL          import Image
import io

# -----------------------------------------------------------------------------
# CONFIGURATION
# -----------------------------------------------------------------------------
# On HF Spaces, set this in "Settings" -> "Secrets"
load_dotenv() 
API_KEY         = os.getenv("GOOGLE_API_KEY")
CLAUDE_API_KEY  = os.getenv("CLAUDE_API_KEY")
ACCESS_PASSWORD = os.getenv("APP_PASSWORD") 

SCANNER_MODEL  = "gemini-3.1-pro-preview"
FALLBACK_MODEL = "gemini-2.5-pro"
#COACH_MODEL    = "claude-sonnet-4-6"
COACH_MODEL    = "claude-opus-4-6"
CACHE_DIR      = Path("cache/slides")
CACHE_DIR.mkdir(parents=True, exist_ok=True)

COACH_PERSONAS = {
    "business": {
        "name": "Business Strategy Coach",
        "icon": "💼",
        "role": "You are a Senior Business Strategist and executive communication expert.",
        "focus": (
            "Evaluate through a BUSINESS LENS:\n"
            "- Is the business problem clearly articulated? Would a VP understand it?\n"
            "- Does the executive summary lead with the answer, not the methodology?\n"
            "- Is the value proposition compelling with specific ROI numbers?\n"
            "- Is the business impact quantified and positioned persuasively?\n"
            "- Would this presentation convince decision-makers to act?"
        )
    },
    "analytics": {
        "name": "Analytics & Methodology Coach",
        "icon": "📊",
        "role": "You are a Senior Data Scientist and ML methodology expert.",
        "focus": (
            "Evaluate through a TECHNICAL/ANALYTICAL LENS:\n"
            "- Is the data structure and preparation approach well-documented?\n"
            "- Are the target variables and evaluation metrics appropriate and justified?\n"
            "- Is model selection rigorous? Were enough candidates explored?\n"
            "- Is the HPO strategy systematic and well-explained?\n"
            "- Is validation thorough (holdout tests, cross-validation, confidence intervals)?\n"
            "- Are results reproducible from what is shown?"
        )
    }
}

# -----------------------------------------------------------------------------
# LOGIC: CONVERSION (PDF -> IMAGES)
# -----------------------------------------------------------------------------
def convert_to_images(file_path):
    output_dir = Path("temp_slides")
    if output_dir.exists():
        shutil.rmtree(output_dir)
    output_dir.mkdir()
    
    # Check extension
    ext = Path(file_path).suffix.lower()
    
    if ext == ".pdf":
        print("Converting PDF to images...")
        images = convert_from_path(file_path, dpi=300)
        image_paths = []
        for i, img in enumerate(images):
            path = output_dir / f"slide-{i+1:02d}.jpg"
            img.save(path, "JPEG", quality=85, optimize=True)
            image_paths.append(path)
        return image_paths
    else:
        # TODO: PPTX support requires LibreOffice/Aspose. 
        # For V1, we ask users to upload PDF.
        raise ValueError("Please convert your PPTX to PDF before uploading.")

# -----------------------------------------------------------------------------
# LOGIC: PASS 1 (VISION SCANNER)
# -----------------------------------------------------------------------------
def scan_slides(client, image_paths):
    inventory = []
    warnings = []
    total = len(image_paths)
    
    cache_hits = 0
    use_model = SCANNER_MODEL
    start = time.perf_counter()
    for i, img_path in enumerate(image_paths):
        slide_num = i + 1
        yield f"Reading Slide {slide_num}/{total}...", None
        
        with open(img_path, "rb") as f:
            img_bytes = f.read()
        
        # Check slide cache by image hash
        img_hash = hashlib.sha256(img_bytes).hexdigest()
        cache_path = CACHE_DIR / f"{img_hash}.json"
        
        if cache_path.exists():
            data = json.loads(cache_path.read_text())
            data["slide_number"] = slide_num
            inventory.append(data)
            cache_hits += 1
            print(f"   Slide {slide_num}: CACHE HIT")
            continue
        
        print(f"Scanning Slide {slide_num}...")
        
        # Rate Limiting: Sleep to respect API limits (avoid 429 errors)
        file_size_mb = len(img_bytes) / (1024 * 1024)
        
        if file_size_mb > 1.0:
            print(f"   Large file ({file_size_mb:.1f}MB). Pausing 10s to refill quota...")
            time.sleep(10)
        else:
            time.sleep(2)

        prompt = f"""
        Analyze this slide (Slide {slide_num}).
        
        INSTRUCTIONS:
        1. **Title**: Extract the title. If text is embedded in an image (e.g. "Questions"), use that. If none, "Untitled".
        2. **Visuals**: Describe the visual content (e.g. "Photo of oil rig", "Bar chart of accuracy").
        3. **Busy**: boolean true if crowded.
        
        OUTPUT STRICT JSON:
        {{
            "slide_number": {slide_num},
            "title": "Extracted Title",
            "main_text_bullets": ["List of points"],
            "visual_elements": {{ "chart_count": Int, "screenshot_count": Int, "is_busy": Bool }},
            "visual_description": "Brief description of images/charts",
            "key_takeaway": "Summary sentence"
        }}
        """
        
        max_retries = 3
        slide_ok = False
        
        for model_name in [use_model, FALLBACK_MODEL]:
            if slide_ok:
                break
            for attempt in range(max_retries):
                try:
                    response = client.models.generate_content(
                        model=model_name,
                    contents=[
                        types.Part.from_bytes(data=img_bytes, mime_type="image/jpeg"),
                        prompt
                    ],
                        config=types.GenerateContentConfig(
                            response_mime_type="application/json",
                            temperature=0.1
                        )
                    )
                    
                    if response.text is None:
                        raise ValueError("Empty response from model (text is None)")
                    
                    data = json.loads(response.text)
                    
                    if isinstance(data, list):
                        if len(data) > 0 and isinstance(data[0], dict):
                            data = data[0]
                        else:
                            raise ValueError(f"Model returned a list without a dict: {data}")

                    if isinstance(data, dict):
                        inventory.append(data)
                        cache_path.write_text(json.dumps(data, indent=2))
                        slide_ok = True
                    else:
                        raise ValueError(f"Response is not a valid JSON dict: {data}")
                    
                    break

                except Exception as e:
                    error_str = str(e)
                    is_rate_limit = ("429" in error_str or "RESOURCE_EXHAUSTED" in error_str)
                    is_retryable = (is_rate_limit or
                                    "Empty response" in error_str or
                                    "NoneType" in error_str)
                    
                    if is_rate_limit and model_name == use_model:
                        print(f"   ⚠️ Slide {slide_num}: {model_name} rate limited. Falling back to {FALLBACK_MODEL}...")
                        yield f"⚠️ Rate limit hit — switching to fallback model for Slide {slide_num}...", None
                        use_model = FALLBACK_MODEL
                        time.sleep(2)
                        break
                    elif is_retryable and attempt < max_retries - 1:
                        wait_time = (attempt + 1) * 5
                        print(f"   ⚠️ Slide {slide_num} attempt {attempt+1} failed: {e}. Retrying in {wait_time}s...")
                        yield f"⚠️ Retrying Slide {slide_num} ({attempt+1}/{max_retries})...", None
                        time.sleep(wait_time)
                    else:
                        print(f"   ❌ Slide {slide_num} failed on {model_name}: {e}")
                        break
        
        if not slide_ok:
            warnings.append(slide_num)
            yield f"⚠️ **Warning: Slide {slide_num} could not be scanned — skipped**", None
    
    print(f"   Cache: {cache_hits}/{total} slides cached, {total - cache_hits} scanned via API")
    if warnings:
        print(f"   ⚠️ Skipped slides: {warnings}")
    end = time.perf_counter()
    print(f"Elapsed Time: {end-start:.6f} seconds")
    yield "Scan Complete", (inventory, warnings)

def debug_inventory(inventory):
    print("\n--- DEBUG: INVENTORY SANITY CHECK ---")
    print(f"Total Slides Captured: {len(inventory)}")
    captured_nums = sorted([s.get("slide_number", -1) for s in inventory])
    print(f"Slide Numbers: {captured_nums}")
    
    # Check for empty content
    for s in inventory:
        if not s.get("title") and not s.get("key_takeaway"):
            print(f"⚠️ WARNING: Slide {s.get('slide_number')} has empty title/takeaway!")
    print("---------------------------------------\n")

# -----------------------------------------------------------------------------
# LOGIC: PASS 2 (COACH CRITIQUE)
# -----------------------------------------------------------------------------
def build_inventory_script(inventory):
    """Shared logic: filter appendices and build the text script from inventory."""
    def get_title(slide):
        if not isinstance(slide, dict): return ""
        t = slide.get("title")
        return t if t else ""
        
    active = [s for s in inventory if isinstance(s, dict) and "appendix" not in get_title(s).lower()]
    print(f"DEBUG: Pass 2 using {len(active)} active slides (excluding appendices).")
    
    script = []
    for s in active:
        visuals = s.get("visual_elements", {})
        if not isinstance(visuals, dict): visuals = {}
        
        busy = "BUSY" if visuals.get("is_busy") else "OK"
        title = s.get('title', 'No Title')
        num = s.get('slide_number', '?')
        takeaway = s.get('key_takeaway', '')
        desc = s.get('visual_description', '')
        
        entry = f"Slide {num}: {title}\n- Content: {takeaway}\n- Visuals: {desc} [{busy}]"
        script.append(entry)
        
    return "\n".join(script)

def generate_critique(coach_client, inventory, persona, temperature=0.2):
    start = time.perf_counter()
    try:
        full_text = build_inventory_script(inventory)
        
        prompt = f"""{persona['role']}
Your goal is to guide a Data Science student to professional excellence.

{persona['focus']}

SLIDE INVENTORY:
{full_text}

TASK:
Coach this student based on the 8-Step Story Arc.

REQUIRED STORY ARC:
1. Executive Summary
2. Data Structure
3. Targets & Metrics
4. Candidate Models
5. HPO Strategy
6. Best Model Selection
7. Validation
8. Business Impact

INSTRUCTIONS:
1. **Fill the Roadmap**: For each of the 8 steps above, determine status (✅, ⚠️, ❓, ⭕).
2. **Check for Specifics**: If the student provides specific numbers (e.g. "$5,065 savings", "98% accuracy"), YOU MUST QUOTE THEM in the notes. Do not give generic advice if the specific data is present.
3. **Slide Refs**: Cite specific slide numbers in the notes.
4. **Tone**: Encouraging but precise.
5. **Summary**: Write a robust 2-paragraph summary (approx 150 words) from your perspective as {persona['name']}.

OUTPUT STRICT JSON (no markdown fences, no extra text):
{{
    "overall_summary": "Encouraging feedback (2 paragraphs).",
    "structure_roadmap": [
        {{ 
            "step_name": "String (e.g. '1. Exec Summary')", 
            "status_icon": "String (✅, ⚠️, ❓, ⭕)", 
            "coach_notes": "String"
        }}
    ]
}}"""
        
        response = coach_client.messages.create(
            model=COACH_MODEL,
            max_tokens=4096,
            temperature=temperature,
            messages=[{"role": "user", "content": prompt}]
        )
        
        raw_text = response.content[0].text
        print(f"DEBUG: {persona['name']} response received from {COACH_MODEL}.")
        
        cleaned = raw_text.strip()
        fence_match = re.search(r"```(?:json)?\s*\n?(.*?)```", cleaned, re.DOTALL)
        if fence_match:
            cleaned = fence_match.group(1).strip()
        
        critique = json.loads(cleaned)
        
        if isinstance(critique, list):
            if len(critique) > 0 and isinstance(critique[0], dict):
                critique = critique[0]
            else:
                 raise ValueError(f"Coach returned a list, expected a dictionary. Output: {critique}")
        
        end = time.perf_counter()
        print(f"Elapsed Time: {end-start:.6f} seconds")
        return critique
        
    except Exception as e:
        print(f"CRITICAL ERROR in Pass 2 ({persona['name']}): {e}")
        return {
            "overall_summary": f"Error generating critique: {e}",
            "structure_roadmap": [],
        }

# -----------------------------------------------------------------------------
# GRADIO INTERFACE
# -----------------------------------------------------------------------------
def format_roadmap_table(critique):
    """Build a markdown table from a critique's structure_roadmap."""
    table_md = (
        "| <span style='display:inline-block; min-width:180px'>STEP</span> "
        "| <span style='display:inline-block; min-width:60px'>FLAG</span> "
        "| COACH NOTES |\n|---|:---:|---|\n"
    )
    for item in critique.get("structure_roadmap", []):
        icon = item.get('status_icon', '❓')
        step = item.get('step_name', 'Step')
        note = item.get('coach_notes', '')
        table_md += f"| **{step}** | <span style='font-size: 1.5em'>{icon}</span> | {note} |\n"
    return table_md

def extract_student_name(inventory, fallback):
    """Extract student name from title slide. Checks bullets, key_takeaway, and description."""
    if not inventory or not isinstance(inventory[0], dict):
        return fallback
    
    slide1 = inventory[0]
    
    # Check short bullets on slide 1 — name is usually a short entry
    for bullet in slide1.get("main_text_bullets", []):
        if isinstance(bullet, str) and 3 < len(bullet) < 40:
            # Skip entries that look like dates, universities, or titles
            lower = bullet.lower()
            if any(skip in lower for skip in ["university", "capstone", "project", "201", "202"]):
                continue
            return bullet
    
    # Check key_takeaway for "by [Name]" or "presented by [Name]"
    takeaway = slide1.get("key_takeaway", "")
    for pattern in [r"presented by ([A-Z][a-z]+ [A-Z][a-z]+)", 
                    r"by ([A-Z][a-z]+ [A-Z][a-z]+)"]:
        match = re.search(pattern, takeaway)
        if match:
            return match.group(1)
    
    print(f"   Note: Could not extract student name from slide 1, using filename.")
    return fallback

def generate_pdf_report(filename, student_name, persona, critique, title_slide_path=None):
    ICON_MAP = {'✅': '[PASS]', '⚠️': '[WARN]', '❓': '[UNCLEAR]', '⭕': '[MISSING]'}
    FONT_DIR = "/usr/share/fonts/truetype/dejavu"
    
    pdf = FPDF()
    pdf.set_auto_page_break(auto=True, margin=15)
    
    pdf.add_font("DejaVu", "", f"{FONT_DIR}/DejaVuSans.ttf")
    pdf.add_font("DejaVu", "B", f"{FONT_DIR}/DejaVuSans-Bold.ttf")
    
    pdf.add_page()
    
    # Title
    pdf.set_font("DejaVu", "B", 18)
    pdf.cell(0, 12, f"Dr. Jones Feedback: {student_name}", new_x="LMARGIN", new_y="NEXT")
    pdf.ln(2)
    pdf.set_font("DejaVu", "", 12)
    pdf.cell(0, 8, persona['name'], new_x="LMARGIN", new_y="NEXT")
    pdf.ln(4)
    
    # Title slide image
    if title_slide_path and os.path.exists(str(title_slide_path)):
        page_width = pdf.w - pdf.l_margin - pdf.r_margin
        pdf.image(str(title_slide_path), w=page_width)
        pdf.ln(6)
    
    # Summary
    pdf.set_font("DejaVu", "B", 12)
    pdf.cell(0, 8, "Coach Summary", new_x="LMARGIN", new_y="NEXT")
    pdf.ln(2)
    pdf.set_font("DejaVu", "", 10)
    summary = critique.get("overall_summary", "")
    pdf.multi_cell(0, 5, summary)
    
    pdf.add_page()
    
    # Roadmap table
    pdf.set_font("DejaVu", "B", 12)
    pdf.cell(0, 8, "Story Roadmap", new_x="LMARGIN", new_y="NEXT")
    pdf.ln(2)
    
    table_width = pdf.w - pdf.l_margin - pdf.r_margin
    col_widths = (table_width * 0.20, table_width * 0.10, table_width * 0.70)
    
    with pdf.table(col_widths=col_widths, text_align="LEFT") as table:
        header = table.row()
        pdf.set_font("DejaVu", "B", 9)
        header.cell("STEP")
        header.cell("FLAG")
        header.cell("COACH NOTES")
        
        pdf.set_font("DejaVu", "", 8)
        for item in critique.get("structure_roadmap", []):
            icon = item.get('status_icon', '?')
            flag = ICON_MAP.get(icon, icon)
            step = item.get('step_name', 'Step')
            note = item.get('coach_notes', '')
            row = table.row()
            row.cell(step)
            row.cell(flag)
            row.cell(note)
    
    pdf.output(filename)
    print(f"   Saved PDF to {filename}")

EMPTY_OUTPUTS = ("", "", "", "", None, None, None, "")

def process_presentation(file_obj, email, password):
    temperature = 0.2
    print("--- NEW JOB STARTED ---")
    if file_obj is None:
        yield ("❌ Error: No file uploaded",) + EMPTY_OUTPUTS
        return

    # Validate TAMU email domain
    if not email or not re.match(r'^[^@]+@(\w+\.)?tamu\.edu$', email.strip(), re.IGNORECASE):
        yield ("❌ Please enter a valid tamu.edu email address",) + EMPTY_OUTPUTS
        return

    if password != ACCESS_PASSWORD:
        yield ("❌ Incorrect Password",) + EMPTY_OUTPUTS
        return
    
    print(f"   User: {email.strip()}")
        
    if not API_KEY:
        yield ("❌ Server Error: Google API Key missing",) + EMPTY_OUTPUTS
        return
    if not CLAUDE_API_KEY:
        yield ("❌ Server Error: Claude API Key missing",) + EMPTY_OUTPUTS
        return
        
    scanner_client = genai.Client(api_key=API_KEY)
    coach_client   = anthropic.Anthropic(api_key=CLAUDE_API_KEY)
    
    try:
        # 1. Convert
        print("Step 1: Converting PDF...")
        yield ("⏳ **Converting PDF to images...**",) + EMPTY_OUTPUTS
        images = convert_to_images(file_obj.name)
        print(f"   Converted {len(images)} slides.")
        
        # 2. Scan (Pass 1 - Gemini Flash)
        yield (f"⏳ **Scanning {len(images)} slides...**",) + EMPTY_OUTPUTS
        print("Step 2: Scanning Slides (Pass 1)...")
        
        scanner = scan_slides(scanner_client, images)
        inventory = []
        scan_warnings = []
        
        for msg, result in scanner:
            if result is None:
                yield (f"⏳ **{msg}**",) + EMPTY_OUTPUTS
            else:
                inventory, scan_warnings = result
                
        print("   Scan Complete.")
        
        # Save Inventory
        original_stem = Path(file_obj.name).stem
        target_dir = Path("slides_images") / original_stem
        target_dir.mkdir(parents=True, exist_ok=True)
        
        inventory_filename = target_dir / f"{original_stem}_Inventory.json"
        with open(inventory_filename, "w") as f:
            json.dump(inventory, f, indent=4)
        print(f"   Saved Inventory to {inventory_filename}")
        
        # 3. Coach (Pass 2 - Sonnet 4.6, two personas)
        debug_inventory(inventory)
        
        biz_persona = COACH_PERSONAS["business"]
        ana_persona = COACH_PERSONAS["analytics"]
        
        yield (f"⏳ **💼 {biz_persona['name']} reviewing...**",) + EMPTY_OUTPUTS
        print(f"Step 3a: {biz_persona['name']} [Temp: {temperature}]...")
        biz_critique = generate_critique(coach_client, inventory, biz_persona, temperature)
        print(f"   {biz_persona['name']} done.")
        
        yield (f"⏳ **📊 {ana_persona['name']} reviewing...**",) + EMPTY_OUTPUTS
        print(f"Step 3b: {ana_persona['name']} [Temp: {temperature}]...")
        ana_critique = generate_critique(coach_client, inventory, ana_persona, temperature)
        print(f"   {ana_persona['name']} done.")
        
        # 4. Format Output
        biz_summary  = biz_critique.get("overall_summary", "")
        biz_table    = format_roadmap_table(biz_critique)
        ana_summary  = ana_critique.get("overall_summary", "")
        ana_table    = format_roadmap_table(ana_critique)
            
        # Create separate PDF reports
        student_name = extract_student_name(inventory, original_stem)
        title_slide = images[0] if images else None
        
        biz_pdf = f"{original_stem}_Business_Review.pdf"
        ana_pdf = f"{original_stem}_Analytics_Review.pdf"
        generate_pdf_report(biz_pdf, student_name, biz_persona, biz_critique, title_slide)
        generate_pdf_report(ana_pdf, student_name, ana_persona, ana_critique, title_slide)

        done_msg = "✅ Done!"
        if scan_warnings:
            skipped = ", ".join(str(s) for s in scan_warnings)
            done_msg += f"  ⚠️ **Warning: Slide(s) {skipped} could not be scanned and were excluded from the review.**"
        
        yield done_msg, biz_summary, biz_table, ana_summary, ana_table, \
              images[0], biz_pdf, ana_pdf, ""
        
    except Exception as e:
        print(f"CRITICAL ERROR: {e}")
        yield (f"❌ Error: {str(e)}",) + EMPTY_OUTPUTS

# Define a custom maroon color palette
maroon = gr.themes.Color(
    c50="#fdf2f2",
    c100="#fbe5e5",
    c200="#f7c8c8",
    c300="#f09e9e",
    c400="#e66a6a",
    c500="#d63d3d",
    c600="#800000", # Core Maroon
    c700="#800000",
    c800="#800000", # Deep Maroon
    c900="#701a1a",
    c950="#450a0a",
)

with gr.Blocks(title="Dr. Jones AI Coach", 
        theme=gr.themes.Default(primary_hue=maroon, text_size="lg")) as demo:
    gr.Markdown("# 🎓 Capstone Slide Review")
    gr.Markdown("Upload your slides (PDF) for feedback from your AI coaching committee.")
    
    with gr.Row():
        with gr.Column(scale=3):
            file_input = gr.File(label="Upload PDF Slides", 
                                 file_types=[".pdf", "application/pdf"], 
                                 type="filepath", height=150)
        with gr.Column(scale=1):
            email_input = gr.Textbox(label="Email Address", placeholder="you@tamu.edu")
            pass_input  = gr.Textbox(label="Password", type="password")
    
    status = gr.Markdown("**Status**: Ready")
    
    btn = gr.Button("REVIEW PRESENTATION", scale=1, variant="primary")
    
    with gr.Row():
        with gr.Column(scale=1):
            preview_img = gr.Image(label="Title Slide", interactive=False)
            with gr.Row():
                download_biz = gr.File(label="💼 Business (PDF)")
                download_ana = gr.File(label="📊 Analytics (PDF)")
            progress_status = gr.Markdown(value="")
    
        with gr.Column(scale=2):
            with gr.Tabs():
                with gr.TabItem("💼 Business Strategy Coach"):
                    biz_summary_display = gr.Textbox(label="Business Summary", 
                                                     show_label=False, lines=6, interactive=False)
                    
                with gr.TabItem("📊 Analytics & Methodology Coach"):
                    ana_summary_display = gr.Textbox(label="Analytics Summary", 
                                                     show_label=False, lines=6, interactive=False)

    with gr.Tabs():
        with gr.TabItem("💼 Business Roadmap"):
            biz_roadmap_display = gr.Markdown()
            
        with gr.TabItem("📊 Analytics Roadmap"):
            ana_roadmap_display = gr.Markdown()

    btn.click(
        fn=process_presentation,
        inputs=[file_input, email_input, pass_input],
        outputs=[status, biz_summary_display, biz_roadmap_display,
                 ana_summary_display, ana_roadmap_display,
                 preview_img, download_biz, download_ana, progress_status]
    )

if __name__ == "__main__":
    demo.queue() # Enable queuing for generators
    demo.launch(debug=True) # Debug mode on