Update app.py

app.py

@@ -13,6 +13,7 @@ import numpy as np
 import cv2
 import threading
 import queue
+from io import BytesIO
 
 # Page configuration
 st.set_page_config(
@@ -22,42 +23,124 @@ st.set_page_config(
     initial_sidebar_state="expanded"
 )
 
-# Custom CSS for styling
+# Custom CSS for improved styling
 st.markdown("""
 <style>
     .main-header {
-        background: linear-gradient(90deg, #0066cc, #004499);
-        padding: 20px;
-        border-radius: 10px;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        padding: 2rem;
+        border-radius: 15px;
         color: white;
         text-align: center;
-        margin-bottom: 30px;
+        margin-bottom: 2rem;
+        box-shadow: 0 10px 20px rgba(0,0,0,0.1);
+    }
+    .main-header h1 {
+        margin: 0;
+        font-size: 2.5rem;
+        font-weight: 700;
+    }
+    .main-header p {
+        margin-top: 0.5rem;
+        opacity: 0.95;
+        font-size: 1.1rem;
     }
     .assessment-box {
-        background: #f0fdf4;
-        padding: 20px;
-        border-radius: 10px;
-        border-left: 5px solid #059669;
-        margin: 20px 0;
+        background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+        padding: 1.5rem;
+        border-radius: 12px;
+        border-left: 5px solid #667eea;
+        margin: 1.5rem 0;
     }
     .competency-item {
-        background: #f8fafc;
-        padding: 15px;
-        margin: 10px 0;
+        background: white;
+        padding: 1rem;
+        margin: 0.5rem 0;
         border-radius: 8px;
-        border-left: 4px solid #0891b2;
+        border-left: 4px solid #764ba2;
+        transition: transform 0.2s;
+    }
+    .competency-item:hover {
+        transform: translateX(5px);
     }
     .score-display {
         text-align: center;
-        padding: 30px;
+        padding: 2rem;
         background: white;
-        border-radius: 15px;
-        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
-        margin: 20px 0;
+        border-radius: 20px;
+        box-shadow: 0 10px 30px rgba(0,0,0,0.1);
+        margin: 1.5rem 0;
+    }
+    .stButton > button {
+        border-radius: 8px;
+        font-weight: 600;
+        transition: all 0.3s;
+    }
+    .stButton > button:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 5px 15px rgba(0,0,0,0.2);
+    }
+    .recording-status {
+        padding: 1rem;
+        border-radius: 10px;
+        margin: 1rem 0;
+        text-align: center;
+        font-weight: 600;
+    }
+    .recording-active {
+        background: #fee2e2;
+        color: #dc2626;
+        border: 2px solid #dc2626;
+        animation: pulse 2s infinite;
+    }
+    .recording-complete {
+        background: #d1fae5;
+        color: #059669;
+        border: 2px solid #059669;
+    }
+    @keyframes pulse {
+        0% { opacity: 1; }
+        50% { opacity: 0.7; }
+        100% { opacity: 1; }
     }
 </style>
 """, unsafe_allow_html=True)
 
+# Initialize session state
+if "recording" not in st.session_state:
+    st.session_state.recording = False
+if "recorded_video_data" not in st.session_state:
+    st.session_state.recorded_video_data = None
+if "video_processor" not in st.session_state:
+    st.session_state.video_processor = None
+if "assessment_result" not in st.session_state:
+    st.session_state.assessment_result = None
+
+class VideoProcessor:
+    def __init__(self):
+        self.frames = []
+        self.recording = False
+        
+    def recv(self, frame):
+        img = frame.to_ndarray(format="bgr24")
+        
+        if self.recording:
+            self.frames.append(img)
+            # Add recording indicator
+            cv2.putText(img, "RECORDING", (30, 30), 
+                       cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+            cv2.circle(img, (15, 30), 5, (0, 0, 255), -1)
+        
+        return av.VideoFrame.from_ndarray(img, format="bgr24")
+    
+    def start_recording(self):
+        self.frames = []
+        self.recording = True
+    
+    def stop_recording(self):
+        self.recording = False
+        return self.frames
+
 # CICE Assessment Class
 class CICE_Assessment:
     def __init__(self, api_key):
@@ -76,7 +159,7 @@ class CICE_Assessment:
         temp_path = None
         try:
             # Save uploaded file to temporary location
-            with tempfile.NamedTemporaryFile(delete=False, suffix='.webm') as tmp_file:
+            with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as tmp_file:
                 tmp_file.write(video_file.read())
                 temp_path = tmp_file.name
             
@@ -86,17 +169,28 @@ class CICE_Assessment:
             # Wait for processing
             max_wait = 300
             wait_time = 0
+            progress_bar = st.progress(0)
+            status_text = st.empty()
+            
             while uploaded_file.state.name == "PROCESSING" and wait_time < max_wait:
                 time.sleep(3)
                 wait_time += 3
+                progress = min(wait_time / max_wait, 0.9)
+                progress_bar.progress(progress)
+                status_text.text(f"Processing video... {wait_time}s / {max_wait}s")
                 uploaded_file = genai.get_file(uploaded_file.name)
                 
+            progress_bar.progress(1.0)
+            status_text.text("Video processing complete!")
+            
             if uploaded_file.state.name == "FAILED":
                 raise Exception("Video processing failed")
 
             # The 18-point CICE 2.0 assessment prompt
             prompt = """Analyze this healthcare team interaction video and provide a comprehensive assessment based on the CICE 2.0 instrument's 18 interprofessional competencies.
+            
             For EACH of the following 18 competencies, clearly state whether it was "OBSERVED" or "NOT OBSERVED" and provide specific examples with timestamps when possible:
+            
             1. IDENTIFIES FACTORS INFLUENCING HEALTH STATUS
             2. IDENTIFIES TEAM GOALS FOR THE PATIENT
             3. PRIORITIZES GOALS FOCUSED ON IMPROVING HEALTH OUTCOMES
@@ -115,20 +209,27 @@ class CICE_Assessment:
             16. REFLECTS ON STRENGTHS OF TEAM INTERACTIONS
             17. REFLECTS ON CHALLENGES OF TEAM INTERACTIONS
             18. IDENTIFIES HOW TO IMPROVE TEAM EFFECTIVENESS
+            
             STRUCTURE YOUR RESPONSE AS FOLLOWS:
+            
             ## OVERALL ASSESSMENT
             Provide a brief overview of the team interaction quality and professionalism.
+            
             ## DETAILED COMPETENCY EVALUATION
             For each of the 18 competencies, format as:
             Competency [number]: [name]
             Status: [OBSERVED/NOT OBSERVED]
             Evidence: [Specific examples from the video, or explanation of why it wasn't observed]
+            
             ## STRENGTHS
             List 3-5 key strengths observed in the team interaction
+            
             ## AREAS FOR IMPROVEMENT
             List 3-5 specific areas where the team could improve
+            
             ## RECOMMENDATIONS
             Provide 3-5 actionable recommendations for enhancing team collaboration and patient care
+            
             ## FINAL SCORE
             Competencies Observed: X/18
             Overall Performance Level: [Exemplary/Proficient/Developing/Needs Improvement]"""
@@ -140,6 +241,8 @@ class CICE_Assessment:
             # Clean up temporary file
             if temp_path and os.path.exists(temp_path):
                 os.unlink(temp_path)
+            progress_bar.empty()
+            status_text.empty()
     
     def generate_audio_feedback(self, text):
         """Convert assessment text to audio feedback"""
@@ -153,18 +256,12 @@ class CICE_Assessment:
             # Generate audio with gTTS
             tts = gTTS(text=clean_text, lang='en', slow=False)
             
-            # Save to temporary file
-            temp_audio = tempfile.NamedTemporaryFile(delete=False, suffix='.mp3')
-            tts.save(temp_audio.name)
-            
-            # Read audio data
-            with open(temp_audio.name, 'rb') as f:
-                audio_data = f.read()
+            # Save to BytesIO instead of file
+            audio_buffer = BytesIO()
+            tts.write_to_fp(audio_buffer)
+            audio_buffer.seek(0)
             
-            # Clean up temporary file
-            os.unlink(temp_audio.name)
-            
-            return audio_data
+            return audio_buffer.getvalue()
             
         except Exception as e:
             st.error(f"⚠️ Audio generation failed: {str(e)}")
@@ -173,8 +270,6 @@ class CICE_Assessment:
 def parse_assessment_score(assessment_text):
     """Parse the assessment text to extract score"""
     try:
-        # Look for pattern like "X/18" in the text
-        import re
         pattern = r'(\d+)/18'
         match = re.search(pattern, assessment_text)
         if match:
@@ -199,75 +294,37 @@ def parse_assessment_score(assessment_text):
         pass
     return 0, 0, "Unknown", "#6b7280"
 
-# Video recording state
-if "recording" not in st.session_state:
-    st.session_state.recording = False
-if "recorded_frames" not in st.session_state:
-    st.session_state.recorded_frames = []
-if "frame_queue" not in st.session_state:
-    st.session_state.frame_queue = queue.Queue()
-if "webrtc_ctx" not in st.session_state:
-    st.session_state.webrtc_ctx = None
-if "webrtc_error" not in st.session_state:
-    st.session_state.webrtc_error = False
-
-def video_frame_callback(frame):
-    """Callback function to process video frames during recording"""
-    try:
-        if st.session_state.recording and frame is not None:
-            img = frame.to_ndarray(format="bgr24")
-            # Use a non-blocking put to avoid queue overflow
-            if st.session_state.frame_queue.qsize() < 1000:  # Limit queue size
-                st.session_state.frame_queue.put(img, block=False)
-        return frame
-    except Exception as e:
-        # Log error but don't stop recording
-        print(f"Frame callback error: {e}")
-        return frame
-
-def save_recorded_video():
-    """Save recorded frames to a video file"""
-    try:
-        if st.session_state.recorded_frames:
-            # Create temporary file
-            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
-            temp_path = temp_file.name
-            temp_file.close()
-            
-            # Video properties
-            height, width, _ = st.session_state.recorded_frames[0].shape
-            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-            fps = 20  # frames per second
-            
-            # Create video writer
-            out = cv2.VideoWriter(temp_path, fourcc, fps, (width, height))
-            
-            # Write frames
-            for frame in st.session_state.recorded_frames:
-                out.write(frame)
-            
-            out.release()
-            return temp_path
+def save_frames_to_video(frames):
+    """Convert frames to video bytes"""
+    if not frames:
         return None
-    except Exception as e:
-        st.error(f"❌ Error saving video: {str(e)}")
-        return None
-
-def cleanup_webrtc():
-    """Clean up WebRTC resources properly"""
-    try:
-        if st.session_state.webrtc_ctx:
-            # Try to stop the WebRTC context gracefully
-            if hasattr(st.session_state.webrtc_ctx, 'state') and st.session_state.webrtc_ctx.state:
-                try:
-                    st.session_state.webrtc_ctx.state = None
-                except:
-                    pass
-            st.session_state.webrtc_ctx = None
-    except Exception as e:
-        print(f"WebRTC cleanup error: {e}")
-        # Reset anyway
-        st.session_state.webrtc_ctx = None
+    
+    height, width, _ = frames[0].shape
+    
+    # Create temporary file
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
+    temp_path = temp_file.name
+    temp_file.close()
+    
+    # Video writer settings
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    fps = 20
+    out = cv2.VideoWriter(temp_path, fourcc, fps, (width, height))
+    
+    # Write frames
+    for frame in frames:
+        out.write(frame)
+    
+    out.release()
+    
+    # Read video bytes
+    with open(temp_path, 'rb') as f:
+        video_bytes = f.read()
+    
+    # Clean up
+    os.unlink(temp_path)
+    
+    return video_bytes
 
 def main():
     # Header
@@ -295,458 +352,270 @@ def main():
         st.markdown("---")
         st.markdown("""
         ### 📋 CICE 2.0 Competencies
+        
+        **Communication & Teamwork:**
         1. Health Status Factors
         2. Team Goals Identification
         3. Goal Prioritization
         4. Role Verbalization
         5. Seeking Guidance
+        
+        **Professional Interaction:**
         6. Cost-Effective Communication
         7. Expertise-Based Questions
         8. Avoiding Jargon
         9. Explaining Terminology
         10. Clear Role Communication
+        
+        **Collaboration Skills:**
         11. Active Listening
         12. Soliciting Perspectives
         13. Recognizing Contributions
         14. Team Respect
         15. Conflict Resolution
+        
+        **Reflection & Improvement:**
         16. Strength Reflection
         17. Challenge Reflection
         18. Improvement Identification
         """)
 
-    # Main content
-    col1, col2 = st.columns([2, 1])
+    # Main content tabs
+    tab1, tab2, tab3 = st.tabs(["🎥 Record Video", "📁 Upload Video", "📊 Results"])
     
-    with col1:
-        st.header("📹 Record or Upload Healthcare Team Video")
+    with tab1:
+        st.header("Live Video Recording")
         
-        # Tab selection for recording vs uploading
-        tab1, tab2 = st.tabs(["🎥 Record Video", "📁 Upload Video"])
+        col1, col2 = st.columns([3, 1])
         
-        with tab1:
-            st.subheader("Live Video Recording")
-            st.markdown("Click **Start Recording** to activate your webcam and begin recording a healthcare team interaction.")
+        with col1:
+            if not st.session_state.recording and not st.session_state.recorded_video_data:
+                st.info("📹 Click **Start Recording** to begin capturing your healthcare team interaction")
+            elif st.session_state.recording:
+                st.markdown('<div class="recording-status recording-active">🔴 Recording in Progress...</div>', 
+                          unsafe_allow_html=True)
+            elif st.session_state.recorded_video_data:
+                st.markdown('<div class="recording-status recording-complete">✅ Recording Complete!</div>', 
+                          unsafe_allow_html=True)
+        
+        with col2:
+            if not st.session_state.recording and not st.session_state.recorded_video_data:
+                if st.button("🔴 Start Recording", key="start_btn", use_container_width=True):
+                    st.session_state.recording = True
+                    if st.session_state.video_processor:
+                        st.session_state.video_processor.start_recording()
+                    st.rerun()
             
-            # WebRTC configuration
-            rtc_configuration = RTCConfiguration({
-                "iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]
-            })
+            elif st.session_state.recording:
+                if st.button("⏹️ Stop Recording", key="stop_btn", type="primary", use_container_width=True):
+                    st.session_state.recording = False
+                    if st.session_state.video_processor:
+                        frames = st.session_state.video_processor.stop_recording()
+                        if frames:
+                            video_bytes = save_frames_to_video(frames)
+                            st.session_state.recorded_video_data = video_bytes
+                            st.success(f"Recording saved! Captured {len(frames)} frames")
+                    st.rerun()
             
-            # Recording controls - only show when no completed recording exists
-            if not st.session_state.recorded_frames:
-                st.markdown("### 🎬 Recording Controls")
-                col_start, col_stop, col_status = st.columns([1, 1, 2])
-                
-                with col_start:
-                    if st.button("🔴 Start Recording", disabled=st.session_state.recording, type="primary", key="start_rec_btn"):
-                        try:
-                            st.session_state.recording = True
-                            st.session_state.recorded_frames = []
-                            st.session_state.webrtc_error = False
-                            # Clear the queue
-                            while not st.session_state.frame_queue.empty():
-                                try:
-                                    st.session_state.frame_queue.get_nowait()
-                                except:
-                                    break
-                            st.rerun()
-                        except Exception as e:
-                            st.error(f"❌ Failed to start recording: {str(e)}")
-                            st.session_state.recording = False
-                
-                with col_stop:
-                    if st.button("⏹️ Stop Recording", disabled=not st.session_state.recording, type="secondary", key="stop_rec_btn"):
-                        try:
-                            st.session_state.recording = False
-                            
-                            # Collect frames from queue with timeout
-                            frames_collected = []
-                            timeout_counter = 0
-                            max_timeout = 50  # 5 seconds timeout
-                            
-                            while not st.session_state.frame_queue.empty() and timeout_counter < max_timeout:
-                                try:
-                                    frame = st.session_state.frame_queue.get_nowait()
-                                    frames_collected.append(frame)
-                                except queue.Empty:
-                                    timeout_counter += 1
-                                    time.sleep(0.1)
-                                    continue
-                            
-                            st.session_state.recorded_frames = frames_collected
-                            
-                            if len(frames_collected) > 0:
-                                st.success(f"Recording stopped! Captured {len(frames_collected)} frames.")
-                            else:
-                                st.warning("⚠️ No frames were captured. Please ensure camera access is working.")
-                            
-                            # Clean up WebRTC resources
-                            cleanup_webrtc()
-                            st.rerun()
-                            
-                        except Exception as e:
-                            st.error(f"❌ Error stopping recording: {str(e)}")
-                            st.session_state.recording = False
-                
-                with col_status:
-                    if st.session_state.recording:
-                        st.markdown("🔴 **Recording in progress...**")
-                        st.markdown("*Click Stop Recording when finished*")
+            elif st.session_state.recorded_video_data:
+                if st.button("🔄 New Recording", key="new_rec_btn", use_container_width=True):
+                    st.session_state.recorded_video_data = None
+                    st.session_state.recording = False
+                    if st.session_state.video_processor:
+                        st.session_state.video_processor.frames = []
+                    st.rerun()
+        
+        # Video display area
+        if st.session_state.recorded_video_data:
+            st.subheader("📹 Recorded Video")
+            st.video(st.session_state.recorded_video_data)
+            
+            # Process button
+            col1, col2, col3 = st.columns([1, 2, 1])
+            with col2:
+                if st.button("🔍 Analyze with CICE 2.0", key="analyze_recorded", 
+                           type="primary", use_container_width=True):
+                    if not api_key:
+                        st.error("❌ Please enter your Google Gemini API key in the sidebar")
                     else:
-                        st.markdown("⚪ **Ready to record**")
-                        st.markdown("*Click Start Recording to begin*")
-            
-            # Show recording completion status
-            if st.session_state.recorded_frames and not st.session_state.recording:
-                st.markdown("### ✅ Recording Complete")
-                st.success(f"**Recording finished successfully!** Captured {len(st.session_state.recorded_frames)} frames")
-                st.info("📹 Your video is ready for analysis. Use the Process Video button below.")
-            
-            # Only show WebRTC streamer when recording is active or about to start
-            if st.session_state.recording or not st.session_state.recorded_frames:
-                try:
-                    # WebRTC configuration with more robust settings
-                    rtc_configuration = RTCConfiguration({
-                        "iceServers": [
-                            {"urls": ["stun:stun.l.google.com:19302"]},
-                            {"urls": ["stun:stun1.l.google.com:19302"]},
-                        ]
-                    })
-                    
-                    # WebRTC streamer with error handling
-                    st.session_state.webrtc_ctx = webrtc_streamer(
-                        key="video-recorder",
-                        mode=WebRtcMode.SENDONLY,
-                        rtc_configuration=rtc_configuration,
-                        video_frame_callback=video_frame_callback,
-                        media_stream_constraints={
-                            "video": {
-                                "width": {"ideal": 640, "max": 640},
-                                "height": {"ideal": 480, "max": 480},
-                                "frameRate": {"ideal": 15, "max": 20}  # Reduced frame rate
-                            },
-                            "audio": False  # Disable audio for now
-                        },
-                        async_processing=True,
-                    )
-                    
-                    # Check WebRTC connection state
-                    if st.session_state.webrtc_ctx and hasattr(st.session_state.webrtc_ctx, 'state'):
-                        if st.session_state.webrtc_ctx.state and st.session_state.webrtc_ctx.state.playing:
-                            if st.session_state.webrtc_error:
-                                st.success("✅ WebRTC connection restored!")
-                                st.session_state.webrtc_error = False
-                        elif st.session_state.recording:
-                            st.warning("⚠️ Camera connection may be unstable. If issues persist, try refreshing the page.")
-                    
-                except Exception as e:
-                    st.session_state.webrtc_error = True
-                    st.error(f"❌ WebRTC Error: Camera access failed. Please check your camera permissions or try refreshing the page.")
-                    st.info("💡 **Troubleshooting Tips:**\n- Ensure your camera is not being used by another application\n- Check browser permissions for camera access\n- Try refreshing the page\n- Use the Upload Video tab as an alternative")
-                    
-                    # Provide fallback option
-                    if st.button("🔄 Reset Camera Connection"):
-                        cleanup_webrtc()
-                        st.session_state.webrtc_error = False
-                        st.rerun()
-            
-            # Show process button only after recording is complete
-            if st.session_state.recorded_frames and not st.session_state.recording:
-                st.markdown("---")
-                st.subheader("🎯 Process Recorded Video")
-                
-                col_process, col_restart = st.columns([2, 1])
-                
-                with col_process:
-                    if st.button("🔍 Process Video with CICE 2.0", type="primary", use_container_width=True, key="process_recorded"):
-                        if not api_key:
-                            st.error("❌ Please enter your Google Gemini API key in the sidebar first")
-                        else:
-                            with st.spinner("💾 Converting recording to video file..."):
-                                video_path = save_recorded_video()
-                                if video_path:
-                                    # Read the saved video for analysis
-                                    with open(video_path, 'rb') as f:
-                                        video_bytes = f.read()
-                                    
-                                    # Create a file-like object for analysis
-                                    class VideoFile:
-                                        def __init__(self, data, name):
-                                            self.data = data
-                                            self.name = name
-                                        
-                                        def read(self):
-                                            return self.data
-                                        
-                                        def seek(self, position):
-                                            pass
-                                    
-                                    uploaded_file = VideoFile(video_bytes, "recorded_video.mp4")
-                                    
-                                    # Proceed with analysis
-                                    analyze_video(uploaded_file, api_key)
-                                    
-                                    # Clean up temporary file
-                                    os.unlink(video_path)
-                                else:
-                                    st.error("❌ Failed to save recording")
-                
-                with col_restart:
-                    if st.button("🔄 New Recording", use_container_width=True, key="restart_recording"):
                         try:
-                            # Clean up everything
-                            st.session_state.recorded_frames = []
-                            st.session_state.recording = False
-                            st.session_state.webrtc_error = False
-                            
-                            # Clear frame queue
-                            while not st.session_state.frame_queue.empty():
-                                try:
-                                    st.session_state.frame_queue.get_nowait()
-                                except:
-                                    break
+                            # Create file-like object
+                            video_file = BytesIO(st.session_state.recorded_video_data)
+                            video_file.seek(0)
                             
-                            # Clean up WebRTC
-                            cleanup_webrtc()
-                            st.rerun()
+                            assessor = CICE_Assessment(api_key)
+                            with st.spinner("🤖 Analyzing video with CICE 2.0 framework..."):
+                                assessment_result = assessor.analyze_video(video_file)
+                                st.session_state.assessment_result = assessment_result
+                                st.success("✅ Analysis complete! Check the Results tab")
+                                
                         except Exception as e:
-                            st.error(f"❌ Error restarting: {str(e)}")
+                            st.error(f"❌ Error: {str(e)}")
+        else:
+            # WebRTC streamer for recording
+            rtc_configuration = RTCConfiguration({
+                "iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]
+            })
             
-            # Add fallback information
-            st.markdown("---")
-            st.markdown("### 🆘 Having Camera Issues?")
-            st.info("""
-            **If you're experiencing camera or recording problems:**
-            
-            📱 **Alternative Solutions:**
-            - Use your phone to record the video and upload it using the "Upload Video" tab
-            - Record using your computer's built-in camera app and upload the file
-            - Use screen recording software if recording a virtual meeting
-            
-            🔧 **Troubleshooting:**
-            - Refresh the browser page
-            - Check camera permissions in your browser
-            - Close other applications using your camera
-            - Try using a different browser (Chrome recommended)
-            """)
-            
-            if st.button("🔄 Reset All Camera Settings", key="reset_all_camera"):
-                try:
-                    # Complete reset
-                    for key in ['recording', 'recorded_frames', 'frame_queue', 'webrtc_ctx', 'webrtc_error']:
-                        if key in st.session_state:
-                            if key == 'frame_queue':
-                                st.session_state[key] = queue.Queue()
-                            elif key == 'recorded_frames':
-                                st.session_state[key] = []
-                            else:
-                                st.session_state[key] = False
-                    
-                    cleanup_webrtc()
-                    st.success("✅ Camera settings reset! Please refresh the page for a clean start.")
-                except Exception as e:
-                    st.error(f"❌ Reset failed: {str(e)}")
-        
-        with tab2:
-            st.subheader("Upload Video File")
-            uploaded_file = st.file_uploader(
-                "Choose a video file",
-                type=['mp4', 'webm', 'avi', 'mov'],
-                help="Upload a video of healthcare team interaction for CICE 2.0 assessment"
+            if not st.session_state.video_processor:
+                st.session_state.video_processor = VideoProcessor()
+            
+            webrtc_ctx = webrtc_streamer(
+                key="recorder",
+                mode=WebRtcMode.SENDRECV,
+                rtc_configuration=rtc_configuration,
+                video_processor_factory=lambda: st.session_state.video_processor,
+                media_stream_constraints={
+                    "video": {
+                        "width": {"ideal": 640},
+                        "height": {"ideal": 480}
+                    },
+                    "audio": False
+                },
+                async_processing=True,
             )
+    
+    with tab2:
+        st.header("Upload Video File")
+        
+        uploaded_file = st.file_uploader(
+            "Choose a video file",
+            type=['mp4', 'webm', 'avi', 'mov'],
+            help="Upload a video of healthcare team interaction for CICE 2.0 assessment"
+        )
+        
+        if uploaded_file is not None:
+            col1, col2 = st.columns([3, 1])
             
-            if uploaded_file is not None:
-                st.success(f"✅ Video uploaded: {uploaded_file.name}")
-                
-                # Display video
+            with col1:
                 st.video(uploaded_file)
+            
+            with col2:
+                st.info(f"**File:** {uploaded_file.name}")
+                st.info(f"**Size:** {uploaded_file.size / 1024 / 1024:.2f} MB")
                 
-                # Analyze button
-                if st.button("🔍 Analyze with CICE 2.0", type="primary"):
+                if st.button("🔍 Analyze Video", key="analyze_uploaded", 
+                           type="primary", use_container_width=True):
                     if not api_key:
-                        st.error("❌ Please enter your Google Gemini API key in the sidebar")
+                        st.error("❌ Please enter your API key")
                     else:
-                        analyze_video(uploaded_file, api_key)
+                        try:
+                            assessor = CICE_Assessment(api_key)
+                            with st.spinner("🤖 Analyzing video..."):
+                                uploaded_file.seek(0)
+                                assessment_result = assessor.analyze_video(uploaded_file)
+                                st.session_state.assessment_result = assessment_result
+                                st.success("✅ Analysis complete! Check the Results tab")
+                        except Exception as e:
+                            st.error(f"❌ Error: {str(e)}")
     
-    with col2:
-        st.header("ℹ️ About CICE 2.0")
-        st.markdown("""
-        The **Collaborative Interprofessional Team Environment (CICE) 2.0** instrument evaluates healthcare team interactions across 18 key competencies.
-        
-        ### 🎯 Purpose
-        - Assess interprofessional collaboration
-        - Identify team strengths
-        - Highlight improvement areas
-        - Enhance patient care quality
-        
-        ### 📊 Scoring Levels
-        - **Exemplary** (85-100%): Outstanding collaboration
-        - **Proficient** (70-84%): Good teamwork
-        - **Developing** (50-69%): Needs improvement
-        - **Needs Improvement** (<50%): Significant gaps
-        
-        ### 🚀 Getting Started
-        1. Enter your Google Gemini API key
-        2. Upload a healthcare team video
-        3. Click "Analyze with CICE 2.0"
-        4. Review detailed results
-        5. Download assessment report
-        """)
-
-def analyze_video(uploaded_file, api_key):
-    """Analyze uploaded video with CICE 2.0 assessment"""
-    try:
-        assessor = CICE_Assessment(api_key)
-        
-        with st.spinner("🤖 Analyzing video with CICE 2.0 framework... This may take 1-2 minutes"):
-            # Reset file pointer
-            uploaded_file.seek(0)
-            assessment_result = assessor.analyze_video(uploaded_file)
-        
-        # Parse score
-        observed, percentage, level, color = parse_assessment_score(assessment_result)
-        
-        # Display summary
-        st.markdown(f"""
-        <div class="score-display">
-            <h2>CICE 2.0 Assessment Results</h2>
-            <div style="display: flex; justify-content: space-around; margin: 30px 0;">
-                <div style="text-align: center;">
-                    <div style="font-size: 48px; font-weight: bold; color: {color};">{observed}/18</div>
-                    <div style="color: #6b7280;">Competencies Observed</div>
+    with tab3:
+        if st.session_state.assessment_result:
+            assessment_result = st.session_state.assessment_result
+            
+            # Parse score
+            observed, percentage, level, color = parse_assessment_score(assessment_result)
+            
+            # Display summary
+            st.markdown(f"""
+            <div class="score-display">
+                <h2>CICE 2.0 Assessment Results</h2>
+                <div style="display: flex; justify-content: space-around; margin: 30px 0;">
+                    <div style="text-align: center;">
+                        <div style="font-size: 48px; font-weight: bold; color: {color};">{observed}/18</div>
+                        <div style="color: #6b7280;">Competencies Observed</div>
+                    </div>
+                    <div style="text-align: center;">
+                        <div style="font-size: 48px; font-weight: bold; color: {color};">{percentage:.0f}%</div>
+                        <div style="color: #6b7280;">Overall Score</div>
+                    </div>
                 </div>
-                <div style="text-align: center;">
-                    <div style="font-size: 48px; font-weight: bold; color: {color};">{percentage:.0f}%</div>
-                    <div style="color: #6b7280;">Overall Score</div>
+                <div style="text-align: center; padding: 20px; background: #f9fafb; border-radius: 10px;">
+                    <div style="font-size: 24px; font-weight: bold; color: {color};">Performance Level: {level}</div>
                 </div>
             </div>
-            <div style="text-align: center; padding: 20px; background: #f9fafb; border-radius: 10px;">
-                <div style="font-size: 24px; font-weight: bold; color: {color};">Performance Level: {level}</div>
-            </div>
-        </div>
-        """, unsafe_allow_html=True)
-        
-        # Display detailed assessment
-        st.markdown('<div class="assessment-box">', unsafe_allow_html=True)
-        st.markdown("### 📋 Detailed Assessment Report")
-        st.write(assessment_result)
-        st.markdown('</div>', unsafe_allow_html=True)
-        
-        # Generate audio feedback
-        with st.spinner("🔊 Generating audio feedback..."):
-            audio_data = assessor.generate_audio_feedback(assessment_result)
-        
-        # Create formatted text report
-        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-        formatted_report = f"""CICE 2.0 Healthcare Team Interaction Assessment
+            """, unsafe_allow_html=True)
+            
+            # Detailed assessment
+            with st.expander("📋 View Detailed Assessment Report", expanded=True):
+                st.markdown(assessment_result)
+            
+            # Generate downloads
+            assessor = CICE_Assessment(api_key) if api_key else None
+            
+            # Create formatted report
+            timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            formatted_report = f"""CICE 2.0 Healthcare Team Interaction Assessment
 {'='*60}
 Assessment Date: {timestamp}
-Video File: {getattr(uploaded_file, 'name', 'recorded_video.mp4')}
 Overall Score: {observed}/18 ({percentage:.1f}%)
 Performance Level: {level}
 {'='*60}
+
 {assessment_result}
+
 {'='*60}
 Generated by CICE 2.0 Healthcare Assessment Tool
 Powered by Google Gemini AI
 {'='*60}"""
-        
-        # Download options
-        st.markdown("### 📥 Download Options")
-        col_text, col_audio = st.columns(2)
-        
-        with col_text:
-            st.download_button(
-                label="📄 Download Text Report",
-                data=formatted_report,
-                file_name=f"cice_assessment_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt",
-                mime="text/plain",
-                help="Download the complete assessment report as a text file"
-            )
-        
-        with col_audio:
-            if audio_data:
+            
+            # Download section
+            st.markdown("### 📥 Download Assessment")
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
                 st.download_button(
-                    label="🔊 Download Audio Report",
-                    data=audio_data,
-                    file_name=f"cice_assessment_audio_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp3",
-                    mime="audio/mpeg",
-                    help="Download the assessment report as an audio file"
+                    label="📄 Download Text Report",
+                    data=formatted_report,
+                    file_name=f"cice_assessment_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt",
+                    mime="text/plain",
+                    use_container_width=True
                 )
-                
-                # Also display audio player
-                st.audio(audio_data, format='audio/mp3')
-                st.caption("🎧 Listen to the assessment report above")
-            else:
-                st.error("❌ Audio generation failed")
-        
-        # Interactive Q&A Section
-        st.markdown("### 💬 Ask Questions About the Assessment")
-        st.markdown("You can ask specific questions about the CICE competencies and assessment results.")
-        
-        # Question input
-        question = st.text_input(
-            "❓ Your question:",
-            placeholder="e.g., 'Was active listening demonstrated?' or 'How did the team handle conflicts?'",
-            help="Ask specific questions about the competencies or assessment results"
-        )
-        
-        if question and st.button("🤖 Get Answer"):
-            try:
-                with st.spinner("🤖 Analyzing your question..."):
-                    qa_prompt = f"""Based on the CICE 2.0 assessment of this healthcare team video,
-                    please answer this specific question: {question}
-                    Assessment Results:
-                    {assessment_result}
-                    Please provide a detailed answer referring to the relevant competencies from the 18-point CICE framework."""
-
-                    # Reset file pointer for Q&A
-                    uploaded_file.seek(0)
-                    temp_path = None
-                    try:
-                        # Re-upload file for Q&A
-                        with tempfile.NamedTemporaryFile(delete=False, suffix='.webm') as tmp_file:
-                            tmp_file.write(uploaded_file.read())
-                            temp_path = tmp_file.name
-                        
-                        uploaded_file_qa = genai.upload_file(path=temp_path, display_name="healthcare_interaction_qa")
-                        
-                        # Wait for processing
-                        max_wait = 60
-                        wait_time = 0
-                        while uploaded_file_qa.state.name == "PROCESSING" and wait_time < max_wait:
-                            time.sleep(2)
-                            wait_time += 2
-                            uploaded_file_qa = genai.get_file(uploaded_file_qa.name)
-                        
-                        if uploaded_file_qa.state.name == "FAILED":
-                            raise Exception("Video processing failed for Q&A")
-                        
-                        qa_response = assessor.model.generate_content([uploaded_file_qa, qa_prompt])
-                        
-                        st.markdown("#### 📝 Answer:")
-                        st.write(qa_response.text)
+            
+            with col2:
+                if assessor and api_key:
+                    with st.spinner("Generating audio..."):
+                        audio_data = assessor.generate_audio_feedback(assessment_result)
+                    
+                    if audio_data:
+                        st.download_button(
+                            label="🔊 Download Audio Report",
+                            data=audio_data,
+                            file_name=f"cice_audio_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp3",
+                            mime="audio/mpeg",
+                            use_container_width=True
+                        )
                         
-                    finally:
-                        if temp_path and os.path.exists(temp_path):
-                            os.unlink(temp_path)
+                        st.audio(audio_data, format='audio/mp3')
+            
+            # Q&A Section
+            st.markdown("---")
+            st.markdown("### 💬 Ask Questions About the Assessment")
+            
+            question = st.text_input(
+                "Your question:",
+                placeholder="e.g., 'Was active listening demonstrated?'",
+                key="question_input"
+            )
+            
+            if question and st.button("Get Answer", key="qa_btn"):
+                if assessor and api_key:
+                    try:
+                        with st.spinner("Analyzing question..."):
+                            qa_prompt = f"""Based on this CICE 2.0 assessment, answer: {question}
                             
-            except Exception as e:
-                st.error(f"❌ Error processing question: {str(e)}")
-        
-        # Example questions
-        st.markdown("**Example questions:**")
-        st.markdown("""
-        - Was active listening demonstrated by the team?
-        - How did the team handle interprofessional conflicts?
-        - What specific improvements are recommended?
-        - Which competencies were most lacking?
-        - How well did team members communicate their roles?
-        """)
-        
-    except Exception as e:
-        st.error(f"❌ Error during assessment: {str(e)}")
+                            Assessment: {assessment_result}"""
+                            
+                            response = assessor.model.generate_content(qa_prompt)
+                            st.markdown("#### Answer:")
+                            st.write(response.text)
+                    except Exception as e:
+                        st.error(f"Error: {str(e)}")
+                else:
+                    st.error("Please configure API key")
+        else:
+            st.info("No assessment results yet. Please record or upload a video and run the analysis.")
 
 if __name__ == "__main__":
-    main()
+    main()