# Complete Stress Detection System - 10 Action Units
# Real-time Multi-AU Detection with Comprehensive Analysis
# Research Assistant: [Your Name]
# Guide: Prof. Anup Nandy
# Based on Facial Action Coding System (FACS) - Ekman & Friesen

import cv2
import mediapipe as mp
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
from collections import deque
import time
from datetime import datetime
import warnings
warnings.filterwarnings('ignore')

# ==================== CONFIGURATION ====================
WINDOW_SIZE = 30
RECORDING_DURATION = 15
FPS = 30

# ==================== MediaPipe Setup ====================
mp_face_mesh = mp.solutions.face_mesh
face_mesh = mp_face_mesh.FaceMesh(
    min_detection_confidence=0.5,
    min_tracking_confidence=0.5,
    refine_landmarks=True
)

# ==================== LANDMARK INDICES (468 landmarks) ====================

# AU01 - Inner Brow Raiser (Surprise, Fear, Sadness)
AU01_LANDMARKS = {
    'left_inner_brow': 336,
    'right_inner_brow': 107,
    'nose_bridge': 6,
    'left_outer_brow': 285,
    'right_outer_brow': 55
}

# AU04 - Brow Lowerer (Anger, Sadness, Concentration)
AU04_LANDMARKS = {
    'left_inner_brow': 336,
    'right_inner_brow': 107,
    'left_mid_brow': 285,
    'right_mid_brow': 55,
    'left_eyelid': 159,
    'right_eyelid': 386,
    'nose_bridge': 6
}

# AU06 - Cheek Raiser (Genuine Smile - Duchenne)
AU06_LANDMARKS = {
    'left_cheek': 205,
    'right_cheek': 425,
    'left_lower_eyelid': 145,
    'right_lower_eyelid': 374,
    'left_eye_outer': 33,
    'right_eye_outer': 263
}

# AU07 - Lid Tightener (Concentration, Anger, Disgust)
AU07_LANDMARKS = {
    'left_upper_lid': 159,
    'right_upper_lid': 386,
    'left_lower_lid': 145,
    'right_lower_lid': 374,
    'left_eye_top': 159,
    'right_eye_top': 386
}

# AU12 - Lip Corner Puller (Happiness)
AU12_LANDMARKS = {
    'left_corner': 61,
    'right_corner': 291,
    'upper_center': 13,
    'lower_center': 14
}

# AU14 - Dimpler (Smile Intensity)
AU14_LANDMARKS = {
    'left_dimple': 206,
    'right_dimple': 426,
    'left_corner': 61,
    'right_corner': 291
}

# AU17 - Chin Raiser (Doubt, Sadness, Pouting)
AU17_LANDMARKS = {
    'chin_center': 152,
    'lower_lip': 17,
    'chin_left': 176,
    'chin_right': 400
}

# AU23 - Lip Tightener (Anger, Tension)
AU23_LANDMARKS = {
    'left_corner': 61,
    'right_corner': 291,
    'left_outer': 57,
    'right_outer': 287
}

# AU24 - Lip Pressor (Stress, Tension, Anger)
AU24_LANDMARKS = {
    'upper_lip_top': 0,
    'upper_lip_bottom': 13,
    'lower_lip_top': 14,
    'lower_lip_bottom': 17
}

# AU26 - Jaw Drop (Surprise, Shock, Mouth Opening)
AU26_LANDMARKS = {
    'upper_lip': 13,
    'lower_lip': 14,
    'chin': 152,
    'nose': 1
}

# ==================== UTILITY FUNCTIONS ====================
def calculate_distance(point1, point2):
    return np.sqrt((point1[0] - point2[0])**2 + (point1[1] - point2[1])**2)

def get_landmark_coords(landmarks, idx, frame_width, frame_height):
    lm = landmarks[idx]
    return np.array([lm.x * frame_width, lm.y * frame_height])

# ==================== AU DETECTOR CLASSES ====================

class AU01Detector:
    """AU01 - Inner Brow Raiser (Surprise, Fear, Worry)"""
    def __init__(self, window_size=30):
        self.name = "AU01_InnerBrowRaise"
        self.activation_history = deque(maxlen=window_size)
        self.intensity_history = deque(maxlen=window_size)
        
    def detect(self, landmarks, frame_width, frame_height):
        left_inner = get_landmark_coords(landmarks, AU01_LANDMARKS['left_inner_brow'], frame_width, frame_height)
        right_inner = get_landmark_coords(landmarks, AU01_LANDMARKS['right_inner_brow'], frame_width, frame_height)
        left_outer = get_landmark_coords(landmarks, AU01_LANDMARKS['left_outer_brow'], frame_width, frame_height)
        right_outer = get_landmark_coords(landmarks, AU01_LANDMARKS['right_outer_brow'], frame_width, frame_height)
        nose = get_landmark_coords(landmarks, AU01_LANDMARKS['nose_bridge'], frame_width, frame_height)
        
        # Calculate inner vs outer brow height
        inner_height = ((nose[1] - left_inner[1]) + (nose[1] - right_inner[1])) / 2
        outer_height = ((nose[1] - left_outer[1]) + (nose[1] - right_outer[1])) / 2
        
        # AU01 active when inner brows raised MORE than outer (creates worried look)
        raise_ratio = inner_height / (outer_height + 1e-6)
        
        is_active = raise_ratio > 1.15  # Inner brows 15% higher than outer
        intensity = min(100, max(0, (raise_ratio - 1.0) * 500))
        
        self.activation_history.append(int(is_active))
        self.intensity_history.append(intensity)
        
        return is_active, intensity


class AU04Detector:
    """AU04 - Brow Lowerer (Anger, Concentration, Stress)"""
    def __init__(self, window_size=30):
        self.name = "AU04_BrowLower"
        self.activation_history = deque(maxlen=window_size)
        self.intensity_history = deque(maxlen=window_size)
        
    def detect(self, landmarks, frame_width, frame_height):
        left_inner_brow = get_landmark_coords(landmarks, AU04_LANDMARKS['left_inner_brow'], frame_width, frame_height)
        right_inner_brow = get_landmark_coords(landmarks, AU04_LANDMARKS['right_inner_brow'], frame_width, frame_height)
        left_eyelid = get_landmark_coords(landmarks, AU04_LANDMARKS['left_eyelid'], frame_width, frame_height)
        right_eyelid = get_landmark_coords(landmarks, AU04_LANDMARKS['right_eyelid'], frame_width, frame_height)
        nose_bridge = get_landmark_coords(landmarks, AU04_LANDMARKS['nose_bridge'], frame_width, frame_height)
        
        left_brow_eyelid_dist = left_inner_brow[1] - left_eyelid[1]
        right_brow_eyelid_dist = right_inner_brow[1] - right_eyelid[1]
        avg_brow_eyelid_dist = (left_brow_eyelid_dist + right_brow_eyelid_dist) / 2
        
        face_height = calculate_distance(left_inner_brow, nose_bridge)
        normalized_distance = avg_brow_eyelid_dist / (face_height + 1e-6)
        
        inner_brow_distance = calculate_distance(left_inner_brow, right_inner_brow)
        outer_eye_distance = calculate_distance(left_eyelid, right_eyelid)
        brow_compression_ratio = inner_brow_distance / (outer_eye_distance + 1e-6)
        
        is_active = (normalized_distance > -0.30 or brow_compression_ratio < 0.95)
        intensity = min(100, max(0, (normalized_distance + 0.40) / 0.40 * 100))
        
        self.activation_history.append(int(is_active))
        self.intensity_history.append(intensity)
        
        return is_active, intensity


class AU06Detector:
    """AU06 - Cheek Raiser (Genuine Smile)"""
    def __init__(self, window_size=30):
        self.name = "AU06_CheekRaise"
        self.activation_history = deque(maxlen=window_size)
        self.intensity_history = deque(maxlen=window_size)
        
    def detect(self, landmarks, frame_width, frame_height):
        left_cheek = get_landmark_coords(landmarks, AU06_LANDMARKS['left_cheek'], frame_width, frame_height)
        right_cheek = get_landmark_coords(landmarks, AU06_LANDMARKS['right_cheek'], frame_width, frame_height)
        left_lower_lid = get_landmark_coords(landmarks, AU06_LANDMARKS['left_lower_eyelid'], frame_width, frame_height)
        right_lower_lid = get_landmark_coords(landmarks, AU06_LANDMARKS['right_lower_eyelid'], frame_width, frame_height)
        
        # When cheeks raise, distance between cheek and lower eyelid decreases
        left_distance = calculate_distance(left_cheek, left_lower_lid)
        right_distance = calculate_distance(right_cheek, right_lower_lid)
        avg_distance = (left_distance + right_distance) / 2
        
        # Also check if lower eyelid moves up
        left_eye_outer = get_landmark_coords(landmarks, AU06_LANDMARKS['left_eye_outer'], frame_width, frame_height)
        eye_height = abs(left_eye_outer[1] - left_lower_lid[1])
        
        cheek_raise_score = eye_height / (avg_distance + 1e-6)
        
        is_active = cheek_raise_score > 0.8
        intensity = min(100, max(0, (cheek_raise_score - 0.5) * 200))
        
        self.activation_history.append(int(is_active))
        self.intensity_history.append(intensity)
        
        return is_active, intensity


class AU07Detector:
    """AU07 - Lid Tightener (Tension, Squinting)"""
    def __init__(self, window_size=30):
        self.name = "AU07_LidTighten"
        self.activation_history = deque(maxlen=window_size)
        self.intensity_history = deque(maxlen=window_size)
        
    def detect(self, landmarks, frame_width, frame_height):
        left_upper = get_landmark_coords(landmarks, AU07_LANDMARKS['left_upper_lid'], frame_width, frame_height)
        right_upper = get_landmark_coords(landmarks, AU07_LANDMARKS['right_upper_lid'], frame_width, frame_height)
        left_lower = get_landmark_coords(landmarks, AU07_LANDMARKS['left_lower_lid'], frame_width, frame_height)
        right_lower = get_landmark_coords(landmarks, AU07_LANDMARKS['right_lower_lid'], frame_width, frame_height)
        
        # Eye opening (smaller = more tightened)
        left_eye_opening = abs(left_upper[1] - left_lower[1])
        right_eye_opening = abs(right_upper[1] - right_lower[1])
        avg_eye_opening = (left_eye_opening + right_eye_opening) / 2
        
        # Normalize by face height
        face_ref = calculate_distance(left_upper, 
                                      get_landmark_coords(landmarks, 152, frame_width, frame_height))
        normalized_opening = avg_eye_opening / (face_ref + 1e-6)
        
        is_active = normalized_opening < 0.025  # Eyes tightened/squinted
        intensity = min(100, max(0, (0.035 - normalized_opening) / 0.035 * 100))
        
        self.activation_history.append(int(is_active))
        self.intensity_history.append(intensity)
        
        return is_active, intensity


class AU12Detector:
    """AU12 - Lip Corner Puller (Smile)"""
    def __init__(self, window_size=30):
        self.name = "AU12_LipCornerPull"
        self.activation_history = deque(maxlen=window_size)
        self.intensity_history = deque(maxlen=window_size)
        
    def detect(self, landmarks, frame_width, frame_height):
        left_corner = get_landmark_coords(landmarks, AU12_LANDMARKS['left_corner'], frame_width, frame_height)
        right_corner = get_landmark_coords(landmarks, AU12_LANDMARKS['right_corner'], frame_width, frame_height)
        upper_center = get_landmark_coords(landmarks, AU12_LANDMARKS['upper_center'], frame_width, frame_height)
        lower_center = get_landmark_coords(landmarks, AU12_LANDMARKS['lower_center'], frame_width, frame_height)
        
        mouth_width = calculate_distance(left_corner, right_corner)
        mouth_height = calculate_distance(upper_center, lower_center)
        mouth_center_y = (upper_center[1] + lower_center[1]) / 2
        
        left_corner_lift = mouth_center_y - left_corner[1]
        right_corner_lift = mouth_center_y - right_corner[1]
        avg_corner_lift = (left_corner_lift + right_corner_lift) / 2
        
        mouth_ratio = mouth_width / (mouth_height + 1e-6)
        normalized_lift = avg_corner_lift / mouth_height if mouth_height > 0 else 0
        
        lift_difference = abs(left_corner_lift - right_corner_lift)
        symmetry_score = 1.0 - min(1.0, lift_difference / (mouth_height + 1e-6))
        
        is_active = (normalized_lift > 0.25 and mouth_ratio > 2.8 and symmetry_score > 0.6)
        intensity = min(100, max(0, normalized_lift * 250))
        
        self.activation_history.append(int(is_active))
        self.intensity_history.append(intensity)
        
        return is_active, intensity


class AU14Detector:
    """AU14 - Dimpler (Smile Depth Indicator)"""
    def __init__(self, window_size=30):
        self.name = "AU14_Dimpler"
        self.activation_history = deque(maxlen=window_size)
        self.intensity_history = deque(maxlen=window_size)
        
    def detect(self, landmarks, frame_width, frame_height):
        left_dimple = get_landmark_coords(landmarks, AU14_LANDMARKS['left_dimple'], frame_width, frame_height)
        right_dimple = get_landmark_coords(landmarks, AU14_LANDMARKS['right_dimple'], frame_width, frame_height)
        left_corner = get_landmark_coords(landmarks, AU14_LANDMARKS['left_corner'], frame_width, frame_height)
        right_corner = get_landmark_coords(landmarks, AU14_LANDMARKS['right_corner'], frame_width, frame_height)
        
        # Dimples appear when corners pull back and create indentation
        left_depth = calculate_distance(left_dimple, left_corner)
        right_depth = calculate_distance(right_dimple, right_corner)
        avg_depth = (left_depth + right_depth) / 2
        
        # Check corner retraction
        corner_distance = calculate_distance(left_corner, right_corner)
        dimple_score = avg_depth / (corner_distance + 1e-6)
        
        is_active = dimple_score > 0.15
        intensity = min(100, max(0, (dimple_score - 0.10) * 500))
        
        self.activation_history.append(int(is_active))
        self.intensity_history.append(intensity)
        
        return is_active, intensity


class AU17Detector:
    """AU17 - Chin Raiser (Doubt, Pouting, Sadness)"""
    def __init__(self, window_size=30):
        self.name = "AU17_ChinRaise"
        self.activation_history = deque(maxlen=window_size)
        self.intensity_history = deque(maxlen=window_size)
        
    def detect(self, landmarks, frame_width, frame_height):
        chin = get_landmark_coords(landmarks, AU17_LANDMARKS['chin_center'], frame_width, frame_height)
        lower_lip = get_landmark_coords(landmarks, AU17_LANDMARKS['lower_lip'], frame_width, frame_height)
        
        # When chin raises, distance between chin and lower lip decreases
        chin_lip_distance = calculate_distance(chin, lower_lip)
        
        # Normalize by face height
        nose = get_landmark_coords(landmarks, 1, frame_width, frame_height)
        face_height = calculate_distance(nose, chin)
        normalized_distance = chin_lip_distance / (face_height + 1e-6)
        
        is_active = normalized_distance < 0.08  # Chin pushed up
        intensity = min(100, max(0, (0.12 - normalized_distance) / 0.12 * 100))
        
        self.activation_history.append(int(is_active))
        self.intensity_history.append(intensity)
        
        return is_active, intensity


class AU23Detector:
    """AU23 - Lip Tightener (Anger, Tension)"""
    def __init__(self, window_size=30):
        self.name = "AU23_LipTighten"
        self.activation_history = deque(maxlen=window_size)
        self.intensity_history = deque(maxlen=window_size)
        
    def detect(self, landmarks, frame_width, frame_height):
        left_corner = get_landmark_coords(landmarks, AU23_LANDMARKS['left_corner'], frame_width, frame_height)
        right_corner = get_landmark_coords(landmarks, AU23_LANDMARKS['right_corner'], frame_width, frame_height)
        left_outer = get_landmark_coords(landmarks, AU23_LANDMARKS['left_outer'], frame_width, frame_height)
        right_outer = get_landmark_coords(landmarks, AU23_LANDMARKS['right_outer'], frame_width, frame_height)
        
        corner_width = calculate_distance(left_corner, right_corner)
        outer_width = calculate_distance(left_outer, right_outer)
        tightness_ratio = corner_width / (outer_width + 1e-6)
        
        is_active = (tightness_ratio < 0.85)
        intensity = min(100, max(0, (0.95 - tightness_ratio) / 0.20 * 100))
        
        self.activation_history.append(int(is_active))
        self.intensity_history.append(intensity)
        
        return is_active, intensity


class AU24Detector:
    """AU24 - Lip Pressor (Stress, Tension)"""
    def __init__(self, window_size=30):
        self.name = "AU24_LipPress"
        self.activation_history = deque(maxlen=window_size)
        self.intensity_history = deque(maxlen=window_size)
        
    def detect(self, landmarks, frame_width, frame_height):
        upper_lip_top = get_landmark_coords(landmarks, AU24_LANDMARKS['upper_lip_top'], frame_width, frame_height)
        upper_lip_bottom = get_landmark_coords(landmarks, AU24_LANDMARKS['upper_lip_bottom'], frame_width, frame_height)
        lower_lip_top = get_landmark_coords(landmarks, AU24_LANDMARKS['lower_lip_top'], frame_width, frame_height)
        lower_lip_bottom = get_landmark_coords(landmarks, AU24_LANDMARKS['lower_lip_bottom'], frame_width, frame_height)
        
        upper_lip_thickness = calculate_distance(upper_lip_top, upper_lip_bottom)
        lower_lip_thickness = calculate_distance(lower_lip_top, lower_lip_bottom)
        total_lip_thickness = upper_lip_thickness + lower_lip_thickness
        
        mouth_opening = calculate_distance(upper_lip_bottom, lower_lip_top)
        lip_press_score = mouth_opening / (total_lip_thickness + 1e-6)
        
        is_active = (lip_press_score < 0.4 and total_lip_thickness < 15)
        intensity = min(100, max(0, (0.6 - lip_press_score) / 0.6 * 100))
        
        self.activation_history.append(int(is_active))
        self.intensity_history.append(intensity)
        
        return is_active, intensity


class AU26Detector:
    """AU26 - Jaw Drop (Surprise, Shock)"""
    def __init__(self, window_size=30):
        self.name = "AU26_JawDrop"
        self.activation_history = deque(maxlen=window_size)
        self.intensity_history = deque(maxlen=window_size)
        
    def detect(self, landmarks, frame_width, frame_height):
        upper_lip = get_landmark_coords(landmarks, AU26_LANDMARKS['upper_lip'], frame_width, frame_height)
        lower_lip = get_landmark_coords(landmarks, AU26_LANDMARKS['lower_lip'], frame_width, frame_height)
        chin = get_landmark_coords(landmarks, AU26_LANDMARKS['chin'], frame_width, frame_height)
        nose = get_landmark_coords(landmarks, AU26_LANDMARKS['nose'], frame_width, frame_height)
        
        # Mouth opening
        mouth_opening = calculate_distance(upper_lip, lower_lip)
        
        # Jaw drop (distance from nose to chin increases)
        jaw_length = calculate_distance(nose, chin)
        
        # Normalize
        mouth_opening_ratio = mouth_opening / (jaw_length + 1e-6)
        
        is_active = mouth_opening_ratio > 0.15  # Mouth significantly open
        intensity = min(100, max(0, (mouth_opening_ratio - 0.10) / 0.20 * 100))
        
        self.activation_history.append(int(is_active))
        self.intensity_history.append(intensity)
        
        return is_active, intensity


# ==================== FEATURE EXTRACTOR ====================

class MultiAUFeatureExtractor:
    def __init__(self, detectors):
        self.detectors = detectors
        self.feature_log = []
        
    def extract_features(self, timestamp):
        features = {'timestamp': timestamp}
        
        for detector in self.detectors:
            is_active = detector.activation_history[-1] if detector.activation_history else 0
            intensity = detector.intensity_history[-1] if detector.intensity_history else 0
            
            activation_rate = sum(detector.activation_history) / len(detector.activation_history) if detector.activation_history else 0
            avg_intensity = np.mean(detector.intensity_history) if detector.intensity_history else 0
            max_intensity = np.max(detector.intensity_history) if detector.intensity_history else 0
            intensity_std = np.std(detector.intensity_history) if detector.intensity_history else 0
            
            features[f'{detector.name}_active'] = is_active
            features[f'{detector.name}_intensity'] = intensity
            features[f'{detector.name}_activation_rate'] = activation_rate
            features[f'{detector.name}_avg_intensity'] = avg_intensity
            features[f'{detector.name}_max_intensity'] = max_intensity
            features[f'{detector.name}_intensity_std'] = intensity_std
        
        self.feature_log.append(features)
        return features
    
    def get_dataframe(self):
        return pd.DataFrame(self.feature_log)
    
    def save_features(self, filename):
        df = self.get_dataframe()
        df.to_csv(filename, index=False)
        print(f"✓ Features saved to {filename}")


# ==================== DETECTION SESSION ====================

def run_detection_session(duration_seconds=15, save_data=True):
    # Initialize all 10 AU detectors
    au01 = AU01Detector()
    au04 = AU04Detector()
    au06 = AU06Detector()
    au07 = AU07Detector()
    au12 = AU12Detector()
    au14 = AU14Detector()
    au17 = AU17Detector()
    au23 = AU23Detector()
    au24 = AU24Detector()
    au26 = AU26Detector()
    
    detectors = [au01, au04, au06, au07, au12, au14, au17, au23, au24, au26]
    feature_extractor = MultiAUFeatureExtractor(detectors)
    
    cap = cv2.VideoCapture(0)
    
    print(f"\n{'='*70}")
    print(f"  COMPLETE 10-AU STRESS DETECTION SYSTEM")
    print(f"  Recording for {duration_seconds} seconds...")
    print(f"{'='*70}\n")
    
    start_time = time.time()
    frame_count = 0
    
    while True:
        ret, frame = cap.read()
        if not ret:
            break
        
        current_time = time.time()
        elapsed = current_time - start_time
        
        if elapsed >= duration_seconds:
            break
        
        frame = cv2.flip(frame, 1)
        frame_height, frame_width = frame.shape[:2]
        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        
        results = face_mesh.process(rgb_frame)
        
        if results.multi_face_landmarks:
            landmarks = results.multi_face_landmarks[0].landmark
            
            # Detect all 10 AUs
            au01_active, au01_intensity = au01.detect(landmarks, frame_width, frame_height)
            au04_active, au04_intensity = au04.detect(landmarks, frame_width, frame_height)
            au06_active, au06_intensity = au06.detect(landmarks, frame_width, frame_height)
            au07_active, au07_intensity = au07.detect(landmarks, frame_width, frame_height)
            au12_active, au12_intensity = au12.detect(landmarks, frame_width, frame_height)
            au14_active, au14_intensity = au14.detect(landmarks, frame_width, frame_height)
            au17_active, au17_intensity = au17.detect(landmarks, frame_width, frame_height)
            au23_active, au23_intensity = au23.detect(landmarks, frame_width, frame_height)
            au24_active, au24_intensity = au24.detect(landmarks, frame_width, frame_height)
            au26_active, au26_intensity = au26.detect(landmarks, frame_width, frame_height)
            
            features = feature_extractor.extract_features(elapsed)
            
            # Display (2 columns)
            y_offset = 25
            col1_x = 10
            col2_x = frame_width // 2 + 10
            
            # Header
            cv2.putText(frame, f"Time: {elapsed:.1f}s / {duration_seconds}s", 
                       (10, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
            
            y_offset += 35
            
            # Column 1: Stress Indicators
            cv2.putText(frame, "STRESS INDICATORS:", (col1_x, y_offset), 
                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
            y_offset += 25
            
            stress_aus = [
                (au01_active, au01_intensity, "AU01-BrowRaise"),
                (au04_active, au04_intensity, "AU04-BrowLower"),
                (au07_active, au07_intensity, "AU07-LidTight"),
                (au17_active, au17_intensity, "AU17-ChinRaise"),
                (au23_active, au23_intensity, "AU23-LipTight"),
                (au24_active, au24_intensity, "AU24-LipPress")
            ]
            
            for active, intensity, name in stress_aus:
                color = (0, 0, 255) if active else (100, 100, 100)
                cv2.putText(frame, f"{name}: {intensity:.0f}%", 
                           (col1_x, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.4, color, 1)
                y_offset += 20
            
            # Column 2: Positive Indicators
            y_offset = 60
            cv2.putText(frame, "POSITIVE INDICATORS:", (col2_x, y_offset), 
                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
            y_offset += 25
            
            positive_aus = [
                (au06_active, au06_intensity, "AU06-CheekRaise"),
                (au12_active, au12_intensity, "AU12-SmilePull"),
                (au14_active, au14_intensity, "AU14-Dimpler"),
                (au26_active, au26_intensity, "AU26-JawDrop")
            ]
            
            for active, intensity, name in positive_aus:
                color = (0, 255, 0) if active else (100, 100, 100)
                cv2.putText(frame, f"{name}: {intensity:.0f}%", 
                           (col2_x, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.4, color, 1)
                y_offset += 20
            
            # Bottom summary
            stress_count = sum([au01_active, au04_active, au07_active, au17_active, au23_active, au24_active])
            positive_count = sum([au06_active, au12_active, au14_active])
            
            cv2.rectangle(frame, (10, frame_height - 60), (frame_width - 10, frame_height - 10), (50, 50, 50), -1)
            cv2.putText(frame, f"Stress AUs: {stress_count}/6  |  Positive AUs: {positive_count}/4", 
                       (20, frame_height - 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
            
        cv2.imshow('Complete 10-AU Stress Detection', frame)
        frame_count += 1
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    cap.release()
    cv2.destroyAllWindows()
    
    if save_data:
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"complete_au_features_{timestamp}.csv"
        feature_extractor.save_features(filename)
    
    print(f"\n✓ Session complete! Processed {frame_count} frames")
    print(f"✓ Average FPS: {frame_count/duration_seconds:.1f}")
    
    return feature_extractor.get_dataframe()


# ==================== ADVANCED ANALYSIS ====================

def calculate_comprehensive_stress_score(df):
    """
    Research-based stress scoring using all 10 AUs
    Weights based on affective computing literature
    """
    
    # STRESS INDICATORS (weighted by research evidence)
    # AU04 (Brow Lower) - Primary anger/stress indicator
    au04_score = (df['AU04_BrowLower_intensity'].mean() / 100) * (df['AU04_BrowLower_activation_rate'].mean()) * 25
    
    # AU01 (Inner Brow Raise) - Worry/sadness indicator
    au01_score = (df['AU01_InnerBrowRaise_intensity'].mean() / 100) * (df['AU01_InnerBrowRaise_activation_rate'].mean()) * 15
    
    # AU07 (Lid Tighten) - Tension indicator
    au07_score = (df['AU07_LidTighten_intensity'].mean() / 100) * (df['AU07_LidTighten_activation_rate'].mean()) * 12
    
    # AU24 (Lip Press) - Stress/tension
    au24_score = (df['AU24_LipPress_intensity'].mean() / 100) * (df['AU24_LipPress_activation_rate'].mean()) * 15
    
    # AU23 (Lip Tighten) - Anger/tension
    au23_score = (df['AU23_LipTighten_intensity'].mean() / 100) * (df['AU23_LipTighten_activation_rate'].mean()) * 12
    
    # AU17 (Chin Raise) - Doubt/sadness
    au17_score = (df['AU17_ChinRaise_intensity'].mean() / 100) * (df['AU17_ChinRaise_activation_rate'].mean()) * 8
    
    # POSITIVE INDICATORS (reduce stress score)
    # AU06 + AU12 (Duchenne Smile - genuine happiness)
    duchenne_smile = ((df['AU06_CheekRaise_active'] == 1) & (df['AU12_LipCornerPull_active'] == 1)).sum() / len(df)
    positive_reduction = duchenne_smile * 15
    
    # AU12 alone (social smile - may mask stress)
    social_smile = ((df['AU12_LipCornerPull_active'] == 1) & (df['AU06_CheekRaise_active'] == 0)).sum() / len(df)
    masking_indicator = social_smile * 5  # Adds to stress if smiling without cheek raise
    
    # TEMPORAL PATTERNS
    # Sustained stress (continuous activation 3+ seconds)
    sustained_stress = 0
    for au_name in ['AU04_BrowLower', 'AU24_LipPress', 'AU23_LipTighten']:
        streak = 0
        for val in df[f'{au_name}_active']:
            if val == 1:
                streak += 1
                if streak >= 90:  # 3 seconds at 30fps
                    sustained_stress += 1
                    break
            else:
                streak = 0
    sustained_score = min(10, sustained_stress * 3)
    
    # Co-occurrence of multiple stress AUs
    stress_cols = ['AU01_InnerBrowRaise_active', 'AU04_BrowLower_active', 
                   'AU07_LidTighten_active', 'AU23_LipTighten_active', 
                   'AU24_LipPress_active', 'AU17_ChinRaise_active']
    co_occurrence = (df[stress_cols].sum(axis=1) >= 3).sum() / len(df)
    co_occurrence_score = co_occurrence * 8
    
    # COMBINED STRESS SCORE
    raw_stress = (au04_score + au01_score + au07_score + au24_score + 
                  au23_score + au17_score + sustained_score + 
                  co_occurrence_score + masking_indicator - positive_reduction)
    
    stress_score = min(100, max(0, raw_stress))
    
    # Classification
    if stress_score < 25:
        classification = "NOT STRESSED"
        color = "🟢"
    elif stress_score < 55:
        classification = "POSSIBLY STRESSED"
        color = "🟡"
    else:
        classification = "STRESSED"
        color = "🔴"
    
    return {
        'classification': classification,
        'color': color,
        'stress_score': stress_score,
        'components': {
            'au04': au04_score,
            'au01': au01_score,
            'au07': au07_score,
            'au24': au24_score,
            'au23': au23_score,
            'au17': au17_score,
            'sustained': sustained_score,
            'co_occurrence': co_occurrence_score,
            'duchenne_smile': duchenne_smile,
            'social_smile_masking': masking_indicator
        },
        'activation_percentages': {
            'AU01': (df['AU01_InnerBrowRaise_active'].sum() / len(df)) * 100,
            'AU04': (df['AU04_BrowLower_active'].sum() / len(df)) * 100,
            'AU06': (df['AU06_CheekRaise_active'].sum() / len(df)) * 100,
            'AU07': (df['AU07_LidTighten_active'].sum() / len(df)) * 100,
            'AU12': (df['AU12_LipCornerPull_active'].sum() / len(df)) * 100,
            'AU14': (df['AU14_Dimpler_active'].sum() / len(df)) * 100,
            'AU17': (df['AU17_ChinRaise_active'].sum() / len(df)) * 100,
            'AU23': (df['AU23_LipTighten_active'].sum() / len(df)) * 100,
            'AU24': (df['AU24_LipPress_active'].sum() / len(df)) * 100,
            'AU26': (df['AU26_JawDrop_active'].sum() / len(df)) * 100
        }
    }


# ==================== COMPREHENSIVE VISUALIZATION ====================

def plot_comprehensive_analysis(df):
    """Create 10 publication-quality plots"""
    
    fig = plt.figure(figsize=(20, 16))
    gs = GridSpec(5, 3, figure=fig, hspace=0.35, wspace=0.3)
    
    fig.suptitle('Comprehensive 10-AU Facial Expression Analysis\nStress Detection System', 
                 fontsize=18, fontweight='bold', y=0.995)
    
    # Plot 1: All AU Activations Over Time
    ax1 = fig.add_subplot(gs[0, :2])
    stress_aus = ['AU01_InnerBrowRaise', 'AU04_BrowLower', 'AU07_LidTighten', 
                  'AU17_ChinRaise', 'AU23_LipTighten', 'AU24_LipPress']
    colors_stress = ['orange', 'red', 'darkred', 'brown', 'purple', 'magenta']
    
    for au, color in zip(stress_aus, colors_stress):
        ax1.plot(df['timestamp'], df[f'{au}_active'], label=au.split('_')[1], 
                color=color, linewidth=1.5, alpha=0.7)
    
    ax1.set_xlabel('Time (seconds)', fontweight='bold')
    ax1.set_ylabel('Activation (Binary)', fontweight='bold')
    ax1.set_title('Stress-Related AU Temporal Patterns')
    ax1.legend(loc='upper right', ncol=3, fontsize=8)
    ax1.grid(True, alpha=0.3)
    ax1.set_ylim(-0.1, 1.1)
    
    # Plot 2: Positive AUs Over Time
    ax2 = fig.add_subplot(gs[0, 2])
    positive_aus = ['AU06_CheekRaise', 'AU12_LipCornerPull', 'AU14_Dimpler', 'AU26_JawDrop']
    colors_pos = ['lightgreen', 'green', 'darkgreen', 'blue']
    
    for au, color in zip(positive_aus, colors_pos):
        ax2.plot(df['timestamp'], df[f'{au}_active'], label=au.split('_')[1], 
                color=color, linewidth=1.5, alpha=0.7)
    
    ax2.set_xlabel('Time (s)', fontweight='bold')
    ax2.set_ylabel('Activation', fontweight='bold')
    ax2.set_title('Positive AU Patterns')
    ax2.legend(fontsize=7)
    ax2.grid(True, alpha=0.3)
    ax2.set_ylim(-0.1, 1.1)
    
    # Plot 3: Intensity Heatmap (All 10 AUs)
    ax3 = fig.add_subplot(gs[1, :])
    all_aus = ['AU01_InnerBrowRaise', 'AU04_BrowLower', 'AU06_CheekRaise', 
               'AU07_LidTighten', 'AU12_LipCornerPull', 'AU14_Dimpler',
               'AU17_ChinRaise', 'AU23_LipTighten', 'AU24_LipPress', 'AU26_JawDrop']
    
    intensity_data = df[[f'{au}_intensity' for au in all_aus]].T
    im = ax3.imshow(intensity_data, aspect='auto', cmap='RdYlGn_r', interpolation='nearest')
    ax3.set_yticks(range(10))
    ax3.set_yticklabels([au.split('_')[0] for au in all_aus])
    ax3.set_xlabel('Frame Number', fontweight='bold')
    ax3.set_title('Complete AU Intensity Heatmap (All 10 Action Units)')
    plt.colorbar(im, ax=ax3, label='Intensity (%)')
    
    # Plot 4: AU Activation Frequency Bar Chart
    ax4 = fig.add_subplot(gs[2, 0])
    result = calculate_comprehensive_stress_score(df)
    au_names = list(result['activation_percentages'].keys())
    au_values = list(result['activation_percentages'].values())
    colors = ['red' if 'AU04' in au or 'AU24' in au or 'AU23' in au 
              else 'orange' if 'AU01' in au or 'AU07' in au or 'AU17' in au
              else 'green' for au in au_names]
    
    bars = ax4.barh(au_names, au_values, color=colors, alpha=0.7)
    ax4.set_xlabel('Activation Percentage (%)', fontweight='bold')
    ax4.set_title('AU Activation Frequencies')
    ax4.grid(True, alpha=0.3, axis='x')
    
    # Plot 5: Duchenne vs Non-Duchenne Smile Detection
    ax5 = fig.add_subplot(gs[2, 1])
    duchenne = ((df['AU06_CheekRaise_active'] == 1) & (df['AU12_LipCornerPull_active'] == 1)).sum()
    non_duchenne = ((df['AU12_LipCornerPull_active'] == 1) & (df['AU06_CheekRaise_active'] == 0)).sum()
    no_smile = len(df) - duchenne - non_duchenne
    
    labels = ['Genuine\n(Duchenne)', 'Social\n(Masking)', 'No Smile']
    sizes = [duchenne, non_duchenne, no_smile]
    colors_pie = ['green', 'yellow', 'lightgray']
    
    ax5.pie(sizes, labels=labels, colors=colors_pie, autopct='%1.1f%%', startangle=90)
    ax5.set_title('Smile Type Distribution')
    
    # Plot 6: Stress vs Positive Balance
    ax6 = fig.add_subplot(gs[2, 2])
    stress_intensity_avg = df[['AU01_InnerBrowRaise_intensity', 'AU04_BrowLower_intensity',
                                'AU07_LidTighten_intensity', 'AU23_LipTighten_intensity',
                                'AU24_LipPress_intensity', 'AU17_ChinRaise_intensity']].mean(axis=1)
    positive_intensity_avg = df[['AU06_CheekRaise_intensity', 'AU12_LipCornerPull_intensity',
                                  'AU14_Dimpler_intensity']].mean(axis=1)
    
    ax6.plot(df['timestamp'], stress_intensity_avg, color='red', linewidth=2, label='Stress AUs')
    ax6.plot(df['timestamp'], positive_intensity_avg, color='green', linewidth=2, label='Positive AUs')
    ax6.fill_between(df['timestamp'], stress_intensity_avg, alpha=0.3, color='red')
    ax6.fill_between(df['timestamp'], positive_intensity_avg, alpha=0.3, color='green')
    ax6.set_xlabel('Time (seconds)', fontweight='bold')
    ax6.set_ylabel('Average Intensity (%)', fontweight='bold')
    ax6.set_title('Stress vs Positive Affect Balance')
    ax6.legend()
    ax6.grid(True, alpha=0.3)
    
    # Plot 7: Correlation Matrix (All AUs)
    ax7 = fig.add_subplot(gs[3, :2])
    correlation_cols = [f'{au}_intensity' for au in all_aus]
    corr_matrix = df[correlation_cols].corr()
    
    im = ax7.imshow(corr_matrix, cmap='coolwarm', vmin=-1, vmax=1, aspect='auto')
    ax7.set_xticks(range(10))
    ax7.set_yticks(range(10))
    ax7.set_xticklabels([au.split('_')[0] for au in all_aus], rotation=45, ha='right')
    ax7.set_yticklabels([au.split('_')[0] for au in all_aus])
    ax7.set_title('Complete AU Correlation Matrix')
    
    # Add correlation values
    for i in range(10):
        for j in range(10):
            if abs(corr_matrix.iloc[i, j]) > 0.3:  # Only show strong correlations
                ax7.text(j, i, f'{corr_matrix.iloc[i, j]:.2f}',
                        ha="center", va="center", color="black", fontsize=7)
    
    plt.colorbar(im, ax=ax7)
    
    # Plot 8: Time-Windowed Stress Evolution
    ax8 = fig.add_subplot(gs[3, 2])
    window_size = 90  # 3 seconds
    windowed_stress = []
    window_times = []
    
    for i in range(0, len(df) - window_size, window_size // 2):
        window_df = df.iloc[i:i+window_size]
        if len(window_df) > 0:
            window_result = calculate_comprehensive_stress_score(window_df)
            windowed_stress.append(window_result['stress_score'])
            window_times.append(window_df['timestamp'].mean())
    
    ax8.plot(window_times, windowed_stress, color='red', linewidth=2, marker='o')
    ax8.fill_between(window_times, windowed_stress, alpha=0.3, color='red')
    ax8.axhline(y=25, color='green', linestyle='--', label='Low threshold', alpha=0.5)
    ax8.axhline(y=55, color='orange', linestyle='--', label='High threshold', alpha=0.5)
    ax8.set_xlabel('Time (seconds)', fontweight='bold')
    ax8.set_ylabel('Stress Score', fontweight='bold')
    ax8.set_title('Stress Score Evolution (3s windows)')
    ax8.legend()
    ax8.grid(True, alpha=0.3)
    
    # Plot 9: AU Co-occurrence Matrix
    ax9 = fig.add_subplot(gs[4, 0])
    stress_au_cols = [f'{au}_active' for au in stress_aus]
    co_occur_matrix = np.zeros((6, 6))
    
    for i in range(6):
        for j in range(6):
            co_occur = ((df[stress_au_cols[i]] == 1) & (df[stress_au_cols[j]] == 1)).sum()
            co_occur_matrix[i, j] = co_occur / len(df) * 100
    
    im = ax9.imshow(co_occur_matrix, cmap='Reds', aspect='auto')
    ax9.set_xticks(range(6))
    ax9.set_yticks(range(6))
    ax9.set_xticklabels([au.split('_')[0] for au in stress_aus], rotation=45, ha='right')
    ax9.set_yticklabels([au.split('_')[0] for au in stress_aus])
    ax9.set_title('Stress AU Co-occurrence (%)')
    plt.colorbar(im, ax=ax9)
    
    # Plot 10: Comprehensive Summary Report
    ax10 = fig.add_subplot(gs[4, 1:])
    ax10.axis('off')
    
    result = calculate_comprehensive_stress_score(df)
    
    summary_text = f"""
╔═══════════════════════════════════════════════════════════════════════════════════════════════╗
║                        COMPREHENSIVE STRESS ASSESSMENT REPORT                                 ║
╠═══════════════════════════════════════════════════════════════════════════════════════════════╣
║                                                                                               ║
║  CLASSIFICATION: {result['color']} {result['classification']:<25}  |  STRESS SCORE: {result['stress_score']:.1f}/100        ║
║                                                                                               ║
╠═══════════════════════════════════════════════════════════════════════════════════════════════╣
║  COMPONENT CONTRIBUTIONS:                                                                     ║
║    • AU04 (Brow Lower):      {result['components']['au04']:.2f}  / 25.0  [{result['activation_percentages']['AU04']:5.1f}% active]          ║
║    • AU01 (Inner Brow):      {result['components']['au01']:.2f}  / 15.0  [{result['activation_percentages']['AU01']:5.1f}% active]          ║
║    • AU07 (Lid Tighten):     {result['components']['au07']:.2f}  / 12.0  [{result['activation_percentages']['AU07']:5.1f}% active]          ║
║    • AU24 (Lip Press):       {result['components']['au24']:.2f}  / 15.0  [{result['activation_percentages']['AU24']:5.1f}% active]          ║
║    • AU23 (Lip Tighten):     {result['components']['au23']:.2f}  / 12.0  [{result['activation_percentages']['AU23']:5.1f}% active]          ║
║    • AU17 (Chin Raise):      {result['components']['au17']:.2f}  / 8.0   [{result['activation_percentages']['AU17']:5.1f}% active]          ║
║    • Sustained Activation:   {result['components']['sustained']:.2f}  / 10.0                                               ║
║    • Co-occurrence Pattern:  {result['components']['co_occurrence']:.2f}  / 8.0                                                ║
║    • Smile Masking Effect:   {result['components']['social_smile_masking']:.2f}  (adds stress if present)                          ║
║    • Duchenne Smile Bonus:   -{result['components']['duchenne_smile']*15:.2f}  (reduces stress)                                  ║
║                                                                                               ║
╠═══════════════════════════════════════════════════════════════════════════════════════════════╣
║  POSITIVE AFFECT INDICATORS:                                                                  ║
║    • AU06 (Cheek Raise):     {result['activation_percentages']['AU06']:5.1f}% active                                             ║
║    • AU12 (Lip Pull):        {result['activation_percentages']['AU12']:5.1f}% active                                             ║
║    • AU14 (Dimpler):         {result['activation_percentages']['AU14']:5.1f}% active                                             ║
║    • Duchenne Smile Rate:    {result['components']['duchenne_smile']*100:.1f}%                                                   ║
║                                                                                               ║
╠═══════════════════════════════════════════════════════════════════════════════════════════════╣
║  RESEARCH BASIS:                                                                              ║
║  Weights based on Facial Action Coding System (FACS) research:                               ║
║  • AU04 highest weight (Ekman & Friesen, 1978) - primary anger/stress indicator              ║
║  • AU06+AU12 combination identifies genuine happiness (Duchenne marker)                       ║
║  • Sustained activation and co-occurrence patterns enhance stress detection accuracy          ║
║  • Temporal windowing allows detection of acute stress episodes vs chronic patterns           ║
╚═══════════════════════════════════════════════════════════════════════════════════════════════╝
    """
    
    ax10.text(0.05, 0.5, summary_text, fontsize=8, family='monospace',
             verticalalignment='center',
             bbox=dict(boxstyle='round', facecolor='lightgray', alpha=0.2))
    
    plt.tight_layout()
    return fig, result


# ==================== MAIN EXECUTION ====================

if __name__ == "__main__":
    print("\n" + "="*70)
    print("  COMPLETE 10-AU STRESS DETECTION SYSTEM")
    print("  Based on Facial Action Coding System (FACS)")
    print("  Research Guide: Prof. Anup Nandy")
    print("="*70)
    
    print("\n  Action Units Detected:")
    print("  STRESS: AU01, AU04, AU07, AU17, AU23, AU24")
    print("  POSITIVE: AU06, AU12, AU14, AU26")
    print("\n  Press Enter to start 15-second recording...")
    
    input()
    
    df = run_detection_session(duration_seconds=15, save_data=True)
    
    print("\n" + "="*70)
    print("  Generating comprehensive analysis...")
    print("="*70 + "\n")
    
    fig, result = plot_comprehensive_analysis(df)
    
    print(f"\n{result['color']} FINAL ASSESSMENT: {result['classification']}")
    print(f"  Stress Score: {result['stress_score']:.1f}/100")
    print(f"\n  Data saved with {len(df)} frames")
    print(f"  Total features per frame: {len(df.columns) - 1}")
    print("\n" + "="*70)
    
    plt.show()
    
    print("\n✓ Analysis complete!")