app.py

from __future__ import annotations
import os
import time
import shutil
import uuid
import json
import asyncio
import base64
import re
import traceback
from typing import List, Optional, Dict, Any
from fastapi import FastAPI, UploadFile, File, BackgroundTasks, HTTPException, Form
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel, ConfigDict
import warnings

# Suppress warnings
warnings.filterwarnings('ignore', category=FutureWarning)

# CrewAI imports
from crewai import Agent, Task, Crew, Process
from crewai.llm import LLM

# Gemini imports
import google.generativeai as genai
from google.generativeai.types import HarmCategory, HarmBlockThreshold

# OpenCV
import cv2
import numpy as np

# Configuration
GEMINI_API_KEY = os.getenv("GOOGLE_API_KEY")
GROQ_API_KEY = os.getenv("GROQ_API_KEY")

if not GEMINI_API_KEY:
    raise ValueError("GOOGLE_API_KEY environment variable required")
if not GROQ_API_KEY:
    raise ValueError("GROQ_API_KEY environment variable required")

genai.configure(api_key=GEMINI_API_KEY)

app = FastAPI(title="BJJ AI Coach - Dense Frame Analysis")

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# --- MODELS ---

class TimestampedEvent(BaseModel):
    time: str
    title: str
    description: str
    category: Optional[str] = "GENERAL"
    frame_image: Optional[str] = None
    frame_timestamp: Optional[str] = None
    model_config = ConfigDict(extra="allow")

class Drill(BaseModel):
    name: str
    focus_area: str
    reason: str
    duration: Optional[str] = "15 min/day"
    frequency: Optional[str] = "5x/week"

class DetailedSkillBreakdown(BaseModel):
    offense: int
    defense: int
    guard: int
    passing: int
    standup: int

class PerformanceGrades(BaseModel):
    defense_grade: str
    offense_grade: str
    control_grade: str

class AnalysisResult(BaseModel):
    overall_score: int
    performance_label: str
    performance_grades: PerformanceGrades
    skill_breakdown: DetailedSkillBreakdown
    strengths: List[str]
    weaknesses: List[str]
    missed_opportunities: List[TimestampedEvent]
    key_moments: List[TimestampedEvent]
    coach_notes: str
    recommended_drills: List[Drill]

db_storage = {}

# --- UTILITIES ---

def parse_time_to_seconds(time_str: str) -> Optional[int]:
    if not time_str:
        return None
    match = re.search(r"(\d{1,2}):(\d{2})", time_str)
    if not match:
        return None
    mm, ss = match.groups()
    return int(mm) * 60 + int(ss)

def find_closest_frame(target_time_sec: int, frames: list) -> dict:
    return min(frames, key=lambda f: abs(f["second"] - target_time_sec))

def attach_frames_to_events(events: List[dict], frames: list):
    for event in events:
        try:
            event_time_sec = parse_time_to_seconds(event.get("time"))
            if event_time_sec is None:
                continue
            closest = find_closest_frame(event_time_sec, frames)
            event["frame_timestamp"] = closest["timestamp"]
            event["frame_image"] = base64.b64encode(closest["bytes"]).decode("utf-8")
        except:
            event["frame_image"] = None

def extract_json_from_text(text: str) -> Dict:
    """Robust JSON extraction"""
    text = text.strip()
    
    try:
        return json.loads(text)
    except:
        pass
    
    if "```json" in text or "```" in text:
        try:
            if "```json" in text:
                text = text.split("```json")[1].split("```")[0]
            else:
                text = text.split("```")[1].split("```")[0]
            return json.loads(text.strip())
        except:
            pass
    
    try:
        start_idx = text.find('{')
        if start_idx == -1:
            raise ValueError("No opening brace")
        
        brace_count = 0
        end_idx = -1
        
        for i in range(start_idx, len(text)):
            if text[i] == '{':
                brace_count += 1
            elif text[i] == '}':
                brace_count -= 1
                if brace_count == 0:
                    end_idx = i
                    break
        
        if end_idx != -1:
            json_str = text[start_idx:end_idx+1]
            return json.loads(json_str)
        
        json_str = text[start_idx:]
        open_braces = json_str.count('{')
        close_braces = json_str.count('}')
        open_brackets = json_str.count('[')
        close_brackets = json_str.count(']')
        
        if open_brackets > close_brackets:
            json_str += ']' * (open_brackets - close_brackets)
        if open_braces > close_braces:
            json_str += '}' * (open_braces - close_braces)
        
        return json.loads(json_str)
        
    except:
        pass
    
    raise ValueError("Could not extract JSON")

def is_generic(text: str) -> bool:
    """Check if feedback is too generic"""
    patterns = [r'^More \w+$', r'^Improve \w+$', r'^Work \w+$', r'^Better \w+$']
    for p in patterns:
        if re.match(p, text.strip(), re.IGNORECASE):
            return True
    if not re.search(r'\d{1,2}:\d{2}', text):
        return True
    if len(text) < 20:
        return True
    return False

# --- ENHANCED DENSE FRAME EXTRACTION ---

def extract_dense_consecutive_frames(video_path: str) -> tuple:
    """
    OPTIMIZED: Extract frames for MAXIMUM ACCURACY in 50-60s total processing
    
    Strategy - Balanced for speed + accuracy:
    - 10-15s video: 15 frames (~1.0s intervals) → Gemini ~30s
    - 15-30s video: 20 frames (~1.2s intervals) → Gemini ~40s
    - 30-60s video: 30 frames (~1.8s intervals) → Gemini ~50s
    - 60-90s video: 40 frames (~2.0s intervals) → Gemini ~60s
    
    Distribution (submission-focused):
    - START (0-20%): 20% of frames
    - MIDDLE (20-70%): 30% of frames
    - END (70-100%): 50% of frames (DENSEST for submission detection)
    """
    try:
        cap = cv2.VideoCapture(video_path)
        if not cap.isOpened():
            raise Exception("Cannot open video")
        
        fps = cap.get(cv2.CAP_PROP_FPS)
        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
        duration = total_frames / fps if fps > 0 else 0
        
        # Validate video duration
        if duration < 5:
            raise ValueError("Video too short (< 5 seconds). Please upload a longer clip (10-90 seconds recommended).")
        
        if duration > 120:
            raise ValueError("Video too long (> 2 minutes). Please upload a shorter clip (10-90 seconds recommended) for optimal analysis.")
        
        # OPTIMIZED FRAME COUNTS - Balanced for 50-60s Gemini processing
        if duration <= 15:
            total_to_extract = 15  # ~1.0s intervals → ~30s Gemini
        elif duration <= 30:
            total_to_extract = 20  # ~1.5s intervals → ~40s Gemini
        elif duration <= 60:
            total_to_extract = 30  # ~2.0s intervals → ~50s Gemini
        elif duration <= 90:
            total_to_extract = 40  # ~2.25s intervals → ~60s Gemini
        else:
            total_to_extract = 45  # ~2.7s intervals → ~65s Gemini (max)
        
        print(f"📹 OPTIMIZED EXTRACTION: {total_to_extract} frames from {duration:.1f}s video")
        print(f"   Target: 1 frame every {duration/total_to_extract:.1f}s (Gemini: ~{total_to_extract * 1.5:.0f}s)")
        
        # SUBMISSION-FOCUSED distribution: 20% start, 30% middle, 50% end
        start_frames = max(3, int(total_to_extract * 0.20))
        middle_frames = max(6, int(total_to_extract * 0.30))
        end_frames = total_to_extract - start_frames - middle_frames
        
        print(f"   Distribution (submission-focused): START={start_frames}, MIDDLE={middle_frames}, END={end_frames}")
        
        # Define sections
        start_section_end = int(total_frames * 0.20)
        middle_section_start = start_section_end
        middle_section_end = int(total_frames * 0.70)
        end_section_start = middle_section_end
        
        frames = []
        
        # Extract START section (0-20%) - Overview
        start_interval = max(1, start_section_end // start_frames)
        for i in range(0, start_section_end, start_interval):
            if len([f for f in frames if f["second"] < duration * 0.20]) >= start_frames:
                break
            frame = get_frame(cap, i, fps)
            if frame:
                frames.append(frame)
        
        # Extract MIDDLE section (20-70%) - Standard coverage
        middle_section_frames = middle_section_end - middle_section_start
        middle_interval = max(1, middle_section_frames // middle_frames)
        for i in range(middle_section_start, middle_section_end, middle_interval):
            if len([f for f in frames if duration * 0.20 <= f["second"] < duration * 0.70]) >= middle_frames:
                break
            frame = get_frame(cap, i, fps)
            if frame:
                frames.append(frame)
        
        # Extract END section (70-100%) - DENSEST for submissions (50% of all frames!)
        end_section_frames = total_frames - end_section_start
        end_interval = max(1, end_section_frames // end_frames)
        
        print(f"   END section (50% of frames): 1 frame every {end_interval/fps:.2f}s for submission detection")
        
        for i in range(end_section_start, total_frames, end_interval):
            if len([f for f in frames if f["second"] >= duration * 0.70]) >= end_frames:
                break
            frame = get_frame(cap, i, fps)
            if frame:
                frames.append(frame)
        
        # CRITICAL: Always add final 2 frames for tap detection
        for offset in [2, 1]:
            final_frame_idx = total_frames - offset
            if final_frame_idx > 0:
                frame = get_frame(cap, final_frame_idx, fps)
                if frame:
                    if not any(f["frame_idx"] == frame["frame_idx"] for f in frames):
                        frames.append(frame)
        
        cap.release()
        frames.sort(key=lambda f: f["second"])
        
        # Calculate stats
        intervals = []
        for i in range(1, len(frames)):
            time_gap = frames[i]["second"] - frames[i-1]["second"]
            intervals.append(time_gap)
        
        avg_interval = sum(intervals) / len(intervals) if intervals else 0
        
        metadata = {
            "duration": round(duration, 2),
            "fps": round(fps, 2),
            "frames_extracted": len(frames),
            "avg_frame_interval": round(avg_interval, 2),
            "estimated_gemini_time": round(len(frames) * 1.5, 1),  # ~1.5s per frame
            "distribution": {
                "start": len([f for f in frames if f["second"] < duration * 0.20]),
                "middle": len([f for f in frames if duration * 0.20 <= f["second"] < duration * 0.70]),
                "end": len([f for f in frames if f["second"] >= duration * 0.70])
            }
        }
        
        print(f"✅ Extracted {len(frames)} frames (avg interval: {avg_interval:.2f}s)")
        print(f"   Estimated Gemini time: ~{metadata['estimated_gemini_time']:.0f}s")
        print(f"   Actual distribution: START={metadata['distribution']['start']}, "
              f"MIDDLE={metadata['distribution']['middle']}, "
              f"END={metadata['distribution']['end']} (50% in final 30%!)")
        
        return frames, metadata
        
    except Exception as e:
        if 'cap' in locals():
            cap.release()
        raise Exception(f"Frame extraction failed: {str(e)}")

def get_frame(cap: cv2.VideoCapture, frame_idx: int, fps: float) -> Optional[dict]:
    try:
        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
        ret, frame = cap.read()
        if not ret:
            return None
        
        h, w = frame.shape[:2]
        target_h = 720
        target_w = int(w * (target_h / h))
        resized = cv2.resize(frame, (target_w, target_h))
        _, buffer = cv2.imencode('.jpg', resized, [cv2.IMWRITE_JPEG_QUALITY, 85])
        
        timestamp_sec = frame_idx / fps
        timestamp_str = f"{int(timestamp_sec // 60):02d}:{int(timestamp_sec % 60):02d}"
        
        return {
            "bytes": buffer.tobytes(),
            "timestamp": timestamp_str,
            "second": round(timestamp_sec, 2),
            "frame_idx": frame_idx
        }
    except:
        return None

# --- ENHANCED GEMINI VISION WITH CONSECUTIVE CONTEXT ---

async def extract_frame_observations(frames: List[Dict], user_desc: str, opp_desc: str, duration: float, metadata: Dict) -> str:
    """Use Gemini to analyze DENSE CONSECUTIVE frames"""
    
    print("STEP 1: Gemini Vision - Dense Consecutive Frame Analysis")
    
    try:
        # Build detailed frame list with time gaps
        frame_details = []
        for i, f in enumerate(frames):
            if i > 0:
                time_gap = f["second"] - frames[i-1]["second"]
                gap_indicator = f" [+{time_gap:.1f}s]" if time_gap > 2 else ""
            else:
                gap_indicator = ""
            
            frame_details.append(f"Frame {i+1} @ {f['timestamp']} ({f['second']:.1f}s){gap_indicator}")
        
        frame_list = "\n".join(frame_details)
        
        avg_interval = metadata.get("avg_frame_interval", 2.0)
        
        prompt = f"""
You are an EXPERT Brazilian Jiu-Jitsu black belt analyst performing PRECISE EVIDENCE-BASED frame analysis.

====================
CRITICAL: VIDEO CONTENT VERIFICATION (STEP 0 - MANDATORY)
====================

BEFORE analyzing frames, verify this is BJJ/grappling content.

ACCEPTABLE: BJJ (gi/no-gi), Wrestling, Judo (newaza), Submission grappling, MMA grappling
REJECT: Striking arts, kata/forms, non-combat sports, random videos

If NOT grappling → Output this JSON and STOP:
{{"content_verification": "FAILED", "reason": "This video shows [what you see]. Please upload BJJ/grappling footage.", "suggested_action": "Upload ground grappling, submissions, or takedowns."}}

====================
CORE PRINCIPLE: EVIDENCE-ONLY ANALYSIS
====================

YOU ARE ABSOLUTELY FORBIDDEN FROM:
❌ Assuming intent or motivation
❌ Inferring pain levels or discomfort
❌ Guessing what happened between frames
❌ Extrapolating beyond visible evidence
❌ Making confident claims from unclear visuals

YOU MUST ONLY:
✅ Describe EXACTLY what is visible in each frame
✅ Use conservative language when uncertain
✅ Say "Unclear" or "Insufficient evidence" if you cannot confirm
✅ Track visible progressions across consecutive frames

====================
CONSECUTIVE FRAME CONTEXT
====================

You have {len(frames)} frames with ~{avg_interval:.1f}s average interval.

Frame sequence (time gaps shown):
{frame_list}

IMPORTANT:
- Frames < 2s apart = CONTINUOUS ACTION (track progressions)
- Frames > 3s apart = POTENTIAL TRANSITION (note gap)
- Final 50% of frames are DENSE (70-100% of video) for submission detection

====================
POSITION CLASSIFICATION (STRICT RULES)
====================

Use ONLY these positions if CLEARLY visible:

STANDING/CLINCH:
- Standing: Both athletes upright, no ground contact
- Clinch: Standing with upper body control

GUARD POSITIONS (Bottom player has legs between them):
- Closed Guard: Legs locked around opponent's waist
- Open Guard: Legs not locked, but controlling opponent (Butterfly, DLR, Spider, X-Guard)
- Half Guard: One leg trapped between opponent's legs

TOP CONTROL:
- Side Control: Chest across opponent's chest, perpendicular, opponent flat
- North-South: Head-to-head, chest across opponent's chest
- Mount: ONLY if BOTH knees on mat, hips square over torso, opponent flat, NO leg entanglement
  - If ANY condition missing → "Top pressure (not mount)" or "Knee on belly"
- Back Control: Behind opponent with hooks or body triangle

NEUTRAL/TRANSITION:
- Turtle: Opponent on hands/knees
- Scramble: Both athletes moving, position unclear
- Transitional: Between defined positions

WHEN UNCERTAIN: Use "Unclear position" or "Transitional control" - NEVER guess!

====================
SUBMISSION DETECTION (ULTRA-STRICT)
====================

A submission is confirmed ONLY if you see ALL of:
1. ✅ CLEAR lock/control visible in 2+ consecutive frames
2. ✅ EXPLICIT tap (hand slapping mat/body 2+ times) OR
3. ✅ Match stopping during locked submission OR
4. ✅ Video ending during unmistakable locked submission

TAP INDICATORS (must be EXPLICIT):
- ✅ Hand rapidly slapping mat (2+ distinct slaps)
- ✅ Hand rapidly patting opponent's body (2+ distinct pats)
- ✅ Verbal submission with visible distress
- ✅ Body going completely limp during lock

INSUFFICIENT FOR CONFIRMATION:
- ❌ Position control alone (even if perfect)
- ❌ "Could be applying pressure" - NOT confirmed
- ❌ "Appears to be in pain" - NOT confirmed
- ❌ "Submission position visible" - NOT confirmed unless TAP visible
- ❌ Hand moving once - NOT a tap
- ❌ Match ending without clear tap or lock - NOT confirmed

DECISION TREE:
Is lock clearly visible? NO → "No submission"
Is lock clearly visible? YES → Is tap EXPLICITLY visible? NO → "Submission attempt only"
Is tap EXPLICITLY visible? YES → "SUBMISSION CONFIRMED"

====================
FRAME-BY-FRAME ANALYSIS (REQUIRED FORMAT)
====================

For EACH frame, report:

Frame X (MM:SS):
Position: [Conservative label - say "Unclear" if unsure]
Advantage: [User / Opponent / Neutral - based ONLY on visible control]
Action: [OFFENSE / DEFENSE / GUARD / PASSING / STANDUP / NONE]
Threats: [None / Submission attempt (name) / Positional advance]
Details: [Observable grips, pressure, movements - NO speculation]
Progression: [If < 2s from previous frame: "Continues [action]" / If > 3s: "New sequence"]

CRITICAL RULES:
- If position unclear → say "Position unclear"  
- If advantage unclear → say "Neutral" 
- If can't see details → say "Insufficient detail visible"
- NEVER fill in gaps with assumptions

====================
ACTION TYPE DEFINITIONS (STRICT)
====================

OFFENSE: Initiated submission attempts OR active attack chains (NOT just control)
DEFENSE: Actively escaping, framing, or defending attacks (NOT just being on bottom)
GUARD: Bottom position with legs controlling opponent (NOT just being on back)
PASSING: Actively clearing legs and advancing position (NOT just being on top)
STANDUP: Takedown attempts or clinch exchanges
NONE: Static control, unclear action, or transitional movement

====================
FINAL SUMMARY (EVIDENCE-LOCKED)
====================

1. OUTCOME VERDICT:
   - Submission: YES (only if tap EXPLICITLY visible) / NO / UNCLEAR
   - Winner: User / Opponent / NONE / UNCLEAR
   - Technique: [Name ONLY if lock + tap confirmed] / NONE / UNCLEAR
   - Evidence: "Frames X-Y show [specific visible evidence]"
   - Confidence: HIGH (tap explicitly visible) / MEDIUM (strong indicators) / LOW (unclear)

2. POSITIONAL SUMMARY:
   - Describe visible progressions
   - Note dominant positions
   - List transitions between confirmed positions
   - ADMIT UNCERTAINTY where applicable

3. KEY SEQUENCES:
   - List multi-frame progressions with frame references
   - Format: "Frames X-Y: [observable progression]"

====================
QUALITY CHECKLIST (VERIFY BEFORE SUBMITTING)
====================

Before finalizing, verify:
- [ ] Did I ONLY describe what's CLEARLY visible?
- [ ] Did I use "Unclear" when uncertain?
- [ ] Did I confirm submission ONLY if tap EXPLICITLY visible?
- [ ] Did I avoid assuming pain, intent, or motivation?
- [ ] Did I track progressions in consecutive frames?
- [ ] Did I use conservative position labels?
- [ ] Did I admit gaps in evidence?
- [ ] Did I verify "mount" meets ALL 4 criteria?

REMEMBER: 
- It is BETTER to say "Unclear" than to make a wrong diagnosis
- Conservative analysis is MORE valuable than confident guessing
- Visible evidence > Positional inference
- When in doubt, describe what you SEE, not what you THINK

Your analysis will guide training decisions. ACCURACY and HONESTY are paramount.

✅ Track continuous movement progressions
✅ Identify setup sequences (e.g., grip → control → finish)
✅ Detect transitional movements between positions
✅ Recognize submission attempts developing over multiple frames
✅ See tapping sequences frame-by-frame

IMPORTANT INSTRUCTIONS:
1. When frames are close together (< 2 seconds apart), treat them as CONTINUOUS ACTION
2. Look for PROGRESSIONS across consecutive frames, not just isolated moments
3. A technique may develop over 3-5 consecutive frames - describe the SEQUENCE
4. For submissions: Track the setup (Frame N) → control (Frame N+1) → finish (Frame N+2) → tap (Frame N+3)

====================
VIDEO CONTEXT
====================
- Duration: {duration}s
- Total Frames: {len(frames)} (DENSE consecutive sampling)
- Average time between frames: {avg_interval:.1f}s
- Athlete Being Analyzed (User): {user_desc}
- Opponent: {opp_desc}

====================
FRAME SEQUENCE
====================
{frame_list}

NOTE: Frames marked with [+X.Xs] have larger time gaps - these are transitions between sequences.

====================
REFERENCE KNOWLEDGE (VOCABULARY ONLY)
====================

Use these terms ONLY if clearly visible in frames.

POSITIONS:
Standing, Clinch, Closed Guard, Open Guard (Butterfly, De La Riva, Spider, X-Guard),
Half Guard (Top/Bottom, Knee Shield, Deep Half), Side Control (Standard, Kesa Gatame),
North-South, Mount (Low, High, S-Mount), Back Control, Turtle (Top/Bottom)

CRITICAL POSITION RULE:
- "Full Mount" requires: BOTH knees on mat, hips square, opponent flat, NO leg entanglement
- If ANY missing → use "Top control (not mount)" or "Transitional position"

ATTACKS & THREATS:
Chokes (RNC, Guillotine, Triangle, Arm Triangle, D'Arce, Anaconda, Ezekiel, Collar chokes)
Joint Locks (Armbar, Kimura, Americana, Omoplata, Wrist locks)
Leg Locks (Straight Ankle, Kneebar, Heel Hook, Toe Hold, Calf Slicer)

====================
SUBMISSION DETECTION (STRICT)
====================

With {len(frames)} dense frames, you can now track COMPLETE submission sequences:

A submission is confirmed ONLY if you see:
1. SETUP in earlier frames (e.g., Frame 28: "Leg entangled")
2. CONTROL in middle frames (e.g., Frame 29: "Ankle isolated, arching back")
3. PRESSURE in later frames (e.g., Frame 30: "Full extension applied")
4. TAP or STOPPAGE in final frames (e.g., Frame 31: "Hand tapping mat")

Visual tap indicators:
- ✅ Hand slapping mat/body rapidly (2+ times)
- ✅ Verbal submission (grimacing in pain)
- ✅ Body going limp/giving up resistance
- ✅ Match ending during locked submission

If unclear or incomplete sequence → classify as "submission attempt" NOT "submission"

====================
CONSECUTIVE FRAME ANALYSIS TASK
====================

For EACH frame, provide:

1. POSITION: Current position (conservative labels if unclear)

2. ADVANTAGE: User / Opponent / Neutral (based on visible control)

3. ACTION TYPE: OFFENSE | DEFENSE | GUARD | PASSING | STANDUP | NONE

4. THREATS: None / Submission Attempt (name it) / Positional Advance

5. TECHNICAL DETAILS: Observable grips, pressure, transitions
   - For consecutive frames < 2s apart: Describe the PROGRESSION
   - Example: "Continuing from previous frame, hand now moved to..."

6. CONSECUTIVE CONTEXT: (NEW - VERY IMPORTANT)
   - If this frame continues action from previous frame, note: "Continuation of [action]"
   - If this starts new sequence, note: "New sequence initiated"
   - Track multi-frame progressions: "Frame 3/5 of [technique] setup"

STRICT OUTPUT FORMAT:

Frame X (MM:SS):
Position: [name]
Advantage: [User/Opponent/Neutral]
Action: [type]
Threats: [description]
Details: [technical observation]
Context: [consecutive progression if applicable]

====================
CONSECUTIVE SEQUENCE TRACKING (CRITICAL)
====================

With dense frames, pay special attention to:

1. MULTI-FRAME PROGRESSIONS:
   - Frame 25: Grip established
   - Frame 26: Control secured (progression)
   - Frame 27: Position improved (progression continues)
   - Frame 28: Submission attempt initiated (culmination)

2. SUBMISSION SEQUENCES (if visible):
   Track EVERY step:
   - Early frame: "Leg control established, foot isolated"
   - Next frame: "Opponent arching back, pressure applied"
   - Next frame: "Ankle lock fully extended"
   - Final frame: "Tapping motion visible / Match stopped"

3. TRANSITIONAL FLOWS:
   Note when position changes occur across consecutive frames

====================
FINAL SUMMARY (EVIDENCE-LOCKED)
====================

1. OUTCOME VERDICT:
   - Submission: YES / NO
   - Winner: User / Opponent / NONE
   - Technique: <name or NONE>
   - Time: MM:SS or NONE
   - Frame Sequence: "Frames X-Y showed [setup/execution/finish]"
   - Confidence: HIGH / MEDIUM / LOW
   - Evidence: Specific frame numbers + descriptions

2. POSITIONAL FLOW:
   - Describe the overall progression through consecutive frames
   - Note dominant positions and transitions
   - Identify key turning points in the sequence

3. KEY SEQUENCES:
   - List any multi-frame progressions that led to significant moments
   - Format: "Frames X-Y: [description of progression]"

====================
FINAL CHECKLIST
====================

Before submitting, verify:
- [ ] Did I analyze frames CONSECUTIVELY, not in isolation?
- [ ] Did I track multi-frame progressions (setup → execution → finish)?
- [ ] For close frames (< 2s apart), did I note continuations?
- [ ] If submission visible, did I describe the COMPLETE sequence?
- [ ] Did I use "Frame X-Y" notation for extended sequences?
- [ ] Are all position labels conservative and evidence-based?
- [ ] No speculation beyond what's visible in frames?

REMEMBER: With {len(frames)} dense consecutive frames, you can see COMPLETE action sequences.
Use this advantage to provide CONTEXTUAL analysis, not just isolated observations.
"""

        # Prepare content
        content = []
        for f in frames:
            content.append({
                "mime_type": "image/jpeg",
                "data": base64.b64encode(f["bytes"]).decode("utf-8")
            })
        content.append(prompt)
        
        # Call Gemini
        start = time.time()
        model = genai.GenerativeModel(
            model_name="gemini-2.5-flash",
            generation_config={
                "temperature": 0.2,  
                "max_output_tokens": 12000  # Increased for more frames
            }
        )
        
        response = await asyncio.get_event_loop().run_in_executor(
            None,
            lambda: model.generate_content(
                content,
                safety_settings={
                    HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
                    HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
                    HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
                    HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
                }
            )
        )
        
        elapsed = time.time() - start
        print(f"✅ Gemini vision completed: {elapsed:.2f}s ({len(frames)} frames analyzed)")
        
        try:
            observations = response.text
        except:
            observations = response.candidates[0].content.parts[0].text
        
        # Log first 500 chars for debugging
        print(f"📄 Observations preview: {observations[:500]}...")
        
        return observations
        
    except Exception as e:
        print(f"❌ Vision extraction failed: {e}")
        traceback.print_exc()
        return f"Error analyzing frames: {str(e)}"

# --- CREWAI AGENTS (UPDATED FOR DENSE FRAMES) ---

def create_analysis_crew(observations: str, user_desc: str, opp_desc: str, duration: float, num_frames: int):
    """Create CrewAI agents with awareness of dense consecutive frame analysis"""
    
    model = genai.GenerativeModel(
            model_name="gemini-3-flash-preview",
            generation_config={
                "temperature": 0.2,  
                "max_output_tokens": 12000  # Increased for more frames
            }
        )
        
    llm = LLM(
        model="groq/llama-3.3-70b-versatile",
        api_key=GROQ_API_KEY,
        temperature=0.2
    )
    
    analyst = Agent(
        role="BJJ Technical Analyst",
        goal=f"Analyze {num_frames} consecutive frame observations for {user_desc} to detect submissions, score performance, and identify patterns",
        backstory=f"""
You are a BJJ black belt coach analyzing DENSE CONSECUTIVE FRAME observations.

CONTEXT AWARENESS:
- You received observations from {num_frames} frames (high density sampling)
- Frames are CONSECUTIVE with small time gaps (avg 1-2 seconds)
- This allows you to see COMPLETE action sequences, not just snapshots

CRITICAL RULES:
1. OUTCOME AUTHORITY: Accept submission verdicts from observations - do NOT override
2. SEQUENCE AWARENESS: Look for multi-frame progressions described in observations
3. POSITION AUTHORITY: Respect position labels used in observations
4. TIMESTAMP PRECISION: Every claim must reference specific timestamps
5. NO GENERICS: "More aggression" and similar phrases are FORBIDDEN

SCORING GUIDELINES:
- If user was submitted: Defense ≤40, Overall ≤60
- If user finished opponent: Offense ≥80, Overall ≥80
- Score based on demonstrated actions, not potential

STRENGTHS/WEAKNESSES:
- Must be SPECIFIC with timestamps
- Minimum 25 characters with context
- If submission occurred, it MUST be #1 in relevant category
- Each item must be distinct (no repetition with different wording)

DENSE FRAME ADVANTAGE:
- Use the sequential context to identify setup patterns
- Reference frame progressions (e.g., "Frames 25-28 showed grip sequence leading to...")
- Distinguish between isolated mistakes vs systematic issues
""",
        verbose=True,
        allow_delegation=False,
        llm=llm,
        memory=True
    )
    
    formatter = Agent(
        role="Data Structure Specialist",
        goal="Convert analysis into valid JSON matching exact schema requirements",
        backstory="""You transform technical analysis into structured JSON.

REQUIREMENTS:
- Exactly 3 strengths and 3 weaknesses
- All feedback includes timestamps (MM:SS format)
- No generic phrases like "More aggression" or "Improve timing"
- Scores reflect actual match outcome
- JSON is valid (no trailing commas, proper syntax)
- Each strength/weakness minimum 25 characters

VALIDATION CHECKS:
- All timestamps in MM:SS format? ✓
- No trailing commas? ✓
- Exactly 3 of each category? ✓
- All feedback includes timestamps? ✓
- No generic phrases? ✓
""",
        verbose=True,
        allow_delegation=False,
        llm=llm,
        memory=True
    )
    
    analysis_task = Task(
        description=f"""
Analyze DENSE CONSECUTIVE frame observations from BJJ match.

OBSERVATIONS (from {num_frames} frames):
{observations}

VIDEO INFO:
- Duration: {duration}s
- Frames analyzed: {num_frames} (consecutive with ~1-2s intervals)
- User: {user_desc}
- Opponent: {opp_desc}

REQUIRED OUTPUT:

1. OUTCOME SUMMARY:
   - Restate outcome exactly as in observations
   - Note frame sequences if submission occurred

2. SKILL SCORING (0-100, evidence-based):
   - Offense: Submission attempts / attacks (NOT positional control)
   - Defense: Escapes / survival (≤40 if submitted, ≤65 if never threatened)
   - Guard: Bottom position effectiveness (≤40 if not meaningfully used)
   - Passing: Clearing legs and advancing (mount ≠ passing)
   - Standup: Takedowns / clinch (=0 if no standing engagement)

3. STRENGTHS (EXACTLY 3):
   - Format: "At MM:SS - [Specific technical observation, min 25 chars]"
   - If submission: #1 MUST be the finish
   - Use sequential context from observations
   - NO generics

4. WEAKNESSES (EXACTLY 3):
   - Format: "At MM:SS - [Specific technical flaw, min 25 chars]"
   - If submitted: #1 MUST be the defensive failure
   - Reference frame progressions if applicable
   - NO generics

5. MISSED OPPORTUNITIES (2-3):
   - Must be visible in observations
   - Reference specific timestamps

6. KEY MOMENTS (2-4):
   - Include submission if occurred
   - Note significant transitions

7. COACH NOTES (150-250 words):
   - Technical, honest, evidence-based
   - Reference sequential patterns if observed
   - No speculation

8. DRILLS (EXACTLY 3):
   - Each addresses a specific weakness
   - Include timestamp justification
""",
        agent=analyst,
        expected_output="Detailed technical analysis with submission detection and sequential awareness"
    )
    
    formatting_task = Task(
        description="""Convert the analysis into this EXACT JSON structure. NO markdown wrapping.

{{
  "overall_score": <int 0-100>,
  "performance_label": "EXCELLENT|STRONG|SOLID|DEVELOPING|NEEDS IMPROVEMENT",
  "performance_grades": {{
    "defense_grade": "<A+|A|B+|B|C+|C|D+|D>",
    "offense_grade": "<letter>",
    "control_grade": "<letter>"
  }},
  "skill_breakdown": {{
    "offense": <int>,
    "defense": <int>,
    "guard": <int>,
    "passing": <int>,
    "standup": <int>
  }},
  "strengths": [
    "At 0:XX - Specific observation with context (min 25 chars)",
    "At 0:XX - Another specific observation",
    "At 0:XX - Third specific observation"
  ],
  "weaknesses": [
    "At 0:XX - Specific weakness with context (min 25 chars)",
    "At 0:XX - Another weakness",
    "At 0:XX - Third weakness"
  ],
  "missed_opportunities": [
    {{"time": "MM:SS", "title": "Brief", "description": "Detail", "category": "SUBMISSION|POSITION|SWEEP"}}
  ],
  "key_moments": [
    {{"time": "MM:SS", "title": "Event", "description": "What happened", "category": "SUBMISSION|TRANSITION|DEFENSE"}}
  ],
  "coach_notes": "Paragraph 150-250 words",
  "recommended_drills": [
    {{"name": "Drill 1", "focus_area": "Area", "reason": "Why (reference timestamp)", "duration": "15 min/day", "frequency": "5x/week"}},
    {{"name": "Drill 2", "focus_area": "Area", "reason": "Why", "duration": "10 min/day", "frequency": "4x/week"}},
    {{"name": "Drill 3", "focus_area": "Area", "reason": "Why", "duration": "12 min/day", "frequency": "3x/week"}}
  ]
}}

VALIDATION CHECKS:
- All timestamps in MM:SS format ✓
- No trailing commas ✓
- Exactly 3 strengths, 3 weaknesses, 3 drills ✓
- All feedback includes timestamps ✓
- No generic phrases ✓
- Valid JSON syntax ✓
""",
        agent=formatter,
        expected_output="Valid JSON only"
    )
    
    crew = Crew(
        agents=[analyst, formatter],
        tasks=[analysis_task, formatting_task],
        process=Process.sequential,
        verbose=True
    )
    
    return crew

# --- HYBRID ANALYSIS ---

async def hybrid_agentic_analysis(
    frames: List[Dict],
    metadata: Dict,
    user_desc: str,
    opp_desc: str,
    activity_type: str,
    analysis_id: str = None
) -> AnalysisResult:
    """Hybrid: Gemini vision + CrewAI agents + Python validation"""
    
    print("\n" + "="*70)
    print("HYBRID AGENTIC ANALYSIS (Dense Consecutive Frames)")
    print("="*70)
    
    try:
        if analysis_id:
            db_storage[analysis_id]["progress"] = 30
        
        # STEP 1: Gemini Vision with dense frames
        observations = await extract_frame_observations(
            frames, user_desc, opp_desc, metadata["duration"], metadata
        )
        
        # Check for content verification failure
        if "content_verification" in observations and "FAILED" in observations:
            print("❌ Content verification failed - not BJJ/grappling content")
            
            # Try to parse the rejection message
            try:
                rejection_data = json.loads(observations)
                reason = rejection_data.get("reason", "Video does not appear to contain BJJ or grappling content.")
                suggested = rejection_data.get("suggested_action", "Please upload a BJJ or grappling video.")
                
                if analysis_id:
                    db_storage[analysis_id]["status"] = "rejected"
                    db_storage[analysis_id]["rejection_reason"] = reason
                
                # Return a special rejection result
                return AnalysisResult(**{
                    "overall_score": 0,
                    "performance_label": "CONTENT VERIFICATION FAILED",
                    "performance_grades": {"defense_grade": "N/A", "offense_grade": "N/A", "control_grade": "N/A"},
                    "skill_breakdown": {"offense": 0, "defense": 0, "guard": 0, "passing": 0, "standup": 0},
                    "strengths": [
                        "This video does not appear to contain BJJ or grappling content.",
                        "Please upload footage showing ground grappling, submissions, or takedowns.",
                        "Acceptable: BJJ (gi/no-gi), wrestling, judo newaza, submission grappling."
                    ],
                    "weaknesses": [
                        f"Content detected: {reason}",
                        "This system is designed specifically for grappling analysis.",
                        f"Action needed: {suggested}"
                    ],
                    "missed_opportunities": [],
                    "key_moments": [],
                    "coach_notes": f"⚠️ CONTENT VERIFICATION FAILED\n\n{reason}\n\n{suggested}\n\nThis AI system is specifically trained for Brazilian Jiu-Jitsu and grappling analysis. It cannot analyze striking-based martial arts, non-combat sports, or general videos. Please upload a video showing:\n\n• Ground grappling or submissions\n• Takedowns or clinch work\n• BJJ, wrestling, judo, or submission grappling\n\nFor best results, ensure the video clearly shows both athletes engaged in grappling exchanges.",
                    "recommended_drills": []
                })
            except:
                # Fallback if parsing fails
                if analysis_id:
                    db_storage[analysis_id]["status"] = "rejected"
                    db_storage[analysis_id]["rejection_reason"] = "Video content verification failed"
                
                return AnalysisResult(**{
                    "overall_score": 0,
                    "performance_label": "CONTENT VERIFICATION FAILED",
                    "performance_grades": {"defense_grade": "N/A", "offense_grade": "N/A", "control_grade": "N/A"},
                    "skill_breakdown": {"offense": 0, "defense": 0, "guard": 0, "passing": 0, "standup": 0},
                    "strengths": [
                        "Video does not appear to contain BJJ or grappling content.",
                        "Please upload footage of ground grappling or submissions.",
                        "This system is designed for grappling analysis only."
                    ],
                    "weaknesses": [
                        "Upload a video showing BJJ, wrestling, or submission grappling.",
                        "Ensure both athletes are visible and engaged in grappling.",
                        "Videos should show ground work, takedowns, or submissions."
                    ],
                    "missed_opportunities": [],
                    "key_moments": [],
                    "coach_notes": "⚠️ CONTENT VERIFICATION FAILED\n\nThis video does not appear to contain Brazilian Jiu-Jitsu or grappling content. This AI system is specifically designed for analyzing ground grappling, submissions, and takedowns.\n\nPlease upload a video showing:\n• BJJ (gi or no-gi)\n• Wrestling\n• Judo (newaza)\n• Submission grappling\n• MMA grappling exchanges\n\nFor optimal results, ensure the video clearly shows both athletes engaged in grappling.",
                    "recommended_drills": []
                })
        
        if analysis_id:
            db_storage[analysis_id]["progress"] = 60
        
        # STEP 2: CrewAI Agents
        print("\nSTEP 2: CrewAI Agents - Analysis & Formatting")
        crew = create_analysis_crew(observations, user_desc, opp_desc, metadata["duration"], len(frames))
        
        crew_start = time.time()
        result = await asyncio.get_event_loop().run_in_executor(
            None,
            crew.kickoff
        )
        crew_time = time.time() - crew_start
        print(f"✅ CrewAI completed: {crew_time:.2f}s")
        
        if analysis_id:
            db_storage[analysis_id]["progress"] = 90
        
        # STEP 3: Parse & Validate
        print("\nSTEP 3: Python Validation")
        result_text = str(result)
        
        if "```json" in result_text:
            result_text = result_text.split("```json")[1].split("```")[0].strip()
        elif "```" in result_text:
            result_text = result_text.split("```")[1].split("```")[0].strip()
        
        data = extract_json_from_text(result_text)
        data = validate_and_filter(data, frames)
        
        # Attach frames
        attach_frames_to_events(data.get("missed_opportunities", []), frames)
        attach_frames_to_events(data.get("key_moments", []), frames)
        
        if analysis_id:
            db_storage[analysis_id]["progress"] = 100
        
        print("✅ Analysis complete")
        print("="*70 + "\n")
        
        return AnalysisResult(**data)
        
    except Exception as e:
        print(f"❌ Hybrid analysis failed: {e}")
        traceback.print_exc()
        fallback = make_fallback(frames)
        if analysis_id:
            db_storage[analysis_id]["used_fallback"] = True
        return AnalysisResult(**fallback)

def validate_and_filter(data: Dict, frames: List[Dict]) -> Dict:
    """Python-level validation and generic filtering"""
    
    if "overall_score" not in data:
        data["overall_score"] = 65
    data["overall_score"] = max(0, min(100, data["overall_score"]))
    
    if "performance_label" not in data:
        score = data["overall_score"]
        if score >= 85:
            data["performance_label"] = "EXCELLENT PERFORMANCE"
        elif score >= 75:
            data["performance_label"] = "STRONG PERFORMANCE"
        elif score >= 60:
            data["performance_label"] = "SOLID PERFORMANCE"
        else:
            data["performance_label"] = "DEVELOPING PERFORMANCE"
    
    if "performance_grades" not in data:
        data["performance_grades"] = {"defense_grade": "C+", "offense_grade": "C", "control_grade": "C+"}
    
    if "skill_breakdown" not in data:
        base = data["overall_score"]
        data["skill_breakdown"] = {
            "offense": max(0, min(100, base - 5)),
            "defense": max(0, min(100, base + 3)),
            "guard": max(0, min(100, base - 2)),
            "passing": max(0, min(100, base - 10)),
            "standup": max(0, min(100, base - 13))
        }
    
    # Filter generic feedback
    for field in ["strengths", "weaknesses"]:
        if field in data and data[field]:
            filtered = [item for item in data[field] if not is_generic(item)]
            if len(filtered) >= 3:
                data[field] = filtered[:3]
            else:
                data[field] = make_specific(field, frames, filtered)
        else:
            data[field] = make_specific(field, frames, [])
    
    if "missed_opportunities" not in data or not data["missed_opportunities"]:
        data["missed_opportunities"] = [{
            "time": frames[len(frames)//2]["timestamp"],
            "title": "Position",
            "description": "Review sequence for improvement opportunities",
            "category": "POSITION"
        }]
    
    if "key_moments" not in data or not data["key_moments"]:
        data["key_moments"] = [{
            "time": frames[-3]["timestamp"],
            "title": "Exchange",
            "description": "Significant moment in match flow",
            "category": "TRANSITION"
        }]
    
    if "coach_notes" not in data or len(data["coach_notes"]) < 50:
        data["coach_notes"] = "Focus on maintaining consistent technique throughout sequences. Review timestamped moments for detailed improvement areas."
    
    if "recommended_drills" not in data or len(data["recommended_drills"]) < 3:
        data["recommended_drills"] = [
            {"name": "Position Control Sequences", "focus_area": "General", "reason": "Improve sequential awareness", "duration": "15 min/day", "frequency": "5x/week"},
            {"name": "Guard Retention Drills", "focus_area": "Defense", "reason": "Strengthen defensive sequences", "duration": "10 min/day", "frequency": "4x/week"},
            {"name": "Transition Flow Training", "focus_area": "Movement", "reason": "Improve position transitions", "duration": "12 min/day", "frequency": "3x/week"}
        ]
    
    return data

def make_specific(field: str, frames: List[Dict], existing: List[str]) -> List[str]:
    feedback = existing.copy()
    
    start = frames[len(frames) // 8]
    mid = frames[len(frames) // 2]
    end = frames[-3] if len(frames) > 2 else frames[-1]
    
    if field == "strengths":
        templates = [
            f"At {start['timestamp']} - Maintained good structural positioning during opening sequence",
            f"At {mid['timestamp']} - Demonstrated positional awareness during mid-match exchange",
            f"At {end['timestamp']} - Showed consistent control in final phase of match"
        ]
    else:
        templates = [
            f"At {start['timestamp']} - Could improve initial positioning strategy and grip selection",
            f"At {mid['timestamp']} - Slow to recognize transitional opportunity during position change",
            f"At {end['timestamp']} - Room to improve execution and pressure application in final sequence"
        ]
    
    for t in templates:
        if len(feedback) < 3:
            feedback.append(t)
    
    return feedback[:3]

def make_fallback(frames: List[Dict]) -> Dict:
    mid = frames[len(frames)//2]["timestamp"] if frames else "00:30"
    end = frames[-3]["timestamp"] if len(frames) > 2 else "00:45"
    
    return {
        "overall_score": 65,
        "performance_label": "SOLID PERFORMANCE",
        "performance_grades": {"defense_grade": "C+", "offense_grade": "C", "control_grade": "C+"},
        "skill_breakdown": {"offense": 60, "defense": 68, "guard": 63, "passing": 55, "standup": 52},
        "strengths": [
            "At 0:10 - Maintained structural integrity during opening",
            f"At {mid} - Showed positional awareness during exchange",
            f"At {end} - Demonstrated control in final sequences"
        ],
        "weaknesses": [
            "At 0:15 - Could improve initial positioning approach",
            f"At {mid} - Slow to recognize transitional opportunities",
            f"At {end} - Room to improve execution in final phase"
        ],
        "missed_opportunities": [{"time": mid, "title": "Position", "description": "Review for improvement", "category": "POSITION"}],
        "key_moments": [{"time": end, "title": "Exchange", "description": "Significant sequence", "category": "TRANSITION"}],
        "coach_notes": "Focus on maintaining consistent technique throughout match sequences. Review specific timestamped moments for detailed improvement areas.",
        "recommended_drills": [
            {"name": "Sequential Control", "focus_area": "General", "reason": "Improve awareness", "duration": "15 min/day", "frequency": "5x/week"},
            {"name": "Guard Sequences", "focus_area": "Defense", "reason": "Strengthen defense", "duration": "10 min/day", "frequency": "4x/week"},
            {"name": "Flow Training", "focus_area": "Movement", "reason": "Improve transitions", "duration": "12 min/day", "frequency": "3x/week"}
        ]
    }

# --- API ---

@app.post("/analyze-complete")
async def analyze_complete(
    file: UploadFile = File(...),
    user_description: str = Form(...),
    opponent_description: str = Form(...),
    activity_type: str = Form("Brazilian Jiu-Jitsu")
):
    start_time = time.time()
    file_path = None
    
    try:
        file_name = f"{uuid.uuid4()}_{file.filename}"
        file_path = f"temp_videos/{file_name}"
        os.makedirs("temp_videos", exist_ok=True)
        
        with open(file_path, "wb") as buffer:
            shutil.copyfileobj(file.file, buffer)
        
        analysis_id = str(uuid.uuid4())
        db_storage[analysis_id] = {"status": "processing", "progress": 0}
        
        # Extract DENSE CONSECUTIVE frames
        try:
            frames, metadata = await asyncio.get_event_loop().run_in_executor(
                None, extract_dense_consecutive_frames, file_path
            )
        except ValueError as ve:
            # Duration validation error
            error_msg = str(ve)
            print(f"⚠️ Duration validation failed: {error_msg}")
            
            return {
                "status": "rejected",
                "error": error_msg,
                "error_type": "duration_validation",
                "data": {
                    "overall_score": 0,
                    "performance_label": "VIDEO DURATION ERROR",
                    "performance_grades": {"defense_grade": "N/A", "offense_grade": "N/A", "control_grade": "N/A"},
                    "skill_breakdown": {"offense": 0, "defense": 0, "guard": 0, "passing": 0, "standup": 0},
                    "strengths": [],
                    "weaknesses": [],
                    "missed_opportunities": [],
                    "key_moments": [],
                    "coach_notes": f"⚠️ VIDEO DURATION ERROR\n\n{error_msg}\n\nRecommended video length: 10-90 seconds\n\nTips:\n• Focus on a single exchange or position\n• Trim longer videos to key moments\n• Ensure the clip shows clear grappling action",
                    "recommended_drills": []
                }
            }
        
        # Hybrid analysis
        result = await hybrid_agentic_analysis(
            frames, metadata,
            user_description.strip(), opponent_description.strip(),
            activity_type, analysis_id
        )
        
        total_time = time.time() - start_time
        
        # Check if content was rejected
        if result.performance_label == "CONTENT VERIFICATION FAILED":
            return {
                "status": "rejected",
                "error": "Video content verification failed - not BJJ/grappling",
                "error_type": "content_verification",
                "data": result.model_dump(),
                "processing_time": f"{total_time:.2f}s"
            }
        
        return {
            "status": "completed",
            "data": result.model_dump(),
            "processing_time": f"{total_time:.2f}s",
            "frames_analyzed": len(frames),
            "avg_frame_interval": f"{metadata.get('avg_frame_interval', 0):.2f}s",
            "used_fallback": db_storage[analysis_id].get("used_fallback", False),
            "method": "dense_consecutive_frames"
        }
    except Exception as e:
        print(f"❌ Error: {e}")
        traceback.print_exc()
        
        # Try to provide helpful fallback
        try:
            frames_fb, _ = await asyncio.get_event_loop().run_in_executor(None, extract_dense_consecutive_frames, file_path)
            fallback = make_fallback(frames_fb)
        except:
            fallback = make_fallback([{"timestamp": "00:30", "second": 30}])
        
        return {
            "status": "completed_with_fallback",
            "data": fallback,
            "error": str(e),
            "used_fallback": True
        }
    finally:
        if file_path:
            try:
                os.remove(file_path)
            except:
                pass

@app.get("/health")
async def health_check():
    return {"status": "healthy", "version": "29.0.0-optimized-accurate"}

@app.get("/")
async def root():
    return {
        "message": "BJJ AI Coach - Optimized for Speed + Accuracy",
        "version": "29.0.0",
        "target_performance": "Total analysis: 50-60 seconds",
        "architecture": "Gemini Vision + CrewAI Agents + Python Validation",
        "optimizations": [
            "⚡ Optimized frame counts for 50-60s Gemini processing",
            "🎯 50% of frames in final 30% (submission-focused)",
            "📊 15-40 frames (optimized for speed + accuracy)",
            "✅ Ultra-strict evidence requirements (prevents wrong diagnosis)",
            "🔍 Conservative analysis (admits uncertainty when unclear)",
            "⏱️ Target: 50-60s total (15s video: ~30s, 60s video: ~50s)"
        ],
        "frame_strategy": {
            "10-15s_video": "15 frames (~1.0s intervals) → Gemini ~30s",
            "15-30s_video": "20 frames (~1.5s intervals) → Gemini ~40s",
            "30-60s_video": "30 frames (~2.0s intervals) → Gemini ~50s",
            "60-90s_video": "40 frames (~2.3s intervals) → Gemini ~60s"
        },
        "submission_focus": {
            "distribution": "20% start, 30% middle, 50% end",
            "end_section": "50% of all frames in final 30% of video",
            "final_frames": "Always includes last 2 frames for tap detection",
            "confirmation": "Ultra-strict: requires EXPLICIT tap visible (2+ slaps)"
        },
        "accuracy_improvements": [
            "Evidence-only analysis (NO assumptions or inferences)",
            "Conservative position labels (says 'Unclear' when uncertain)",
            "Stricter submission confirmation (tap must be EXPLICIT)",
            "Mount requires ALL 4 criteria (knees, hips, flat, no entangle)",
            "No pain inference, intent assumption, or guessing",
            "Better to admit uncertainty than make wrong diagnosis"
        ],
        "validation": {
            "content_types_accepted": [
                "BJJ (gi/no-gi)",
                "Submission grappling",
                "Wrestling",
                "Judo (newaza)",
                "MMA grappling"
            ],
            "content_types_rejected": [
                "Striking arts",
                "Kata/forms",
                "Non-combat sports"
            ],
            "duration": "5-120 seconds"
        }
    }

if __name__ == "__main__":
    import uvicorn
    port = int(os.environ.get("PORT", 7860))
    uvicorn.run(app, host="0.0.0.0", port=port)