app.py

import gradio as gr
import spaces
import torch
import numpy as np
from transformers import AutoModelForSequenceClassification, AutoTokenizer, pipeline as hf_pipeline
import re
import matplotlib.pyplot as plt
import io
from PIL import Image
from datetime import datetime
from torch.nn.functional import sigmoid
from collections import Counter
import logging
import traceback


# Set up logging
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)

# Device configuration
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
logger.info(f"Using device: {device}")
# Set up custom logging
# Set up custom logging
class CustomFormatter(logging.Formatter):
    """Custom formatter with colors and better formatting"""
    grey = "\x1b[38;21m"
    blue = "\x1b[38;5;39m"
    yellow = "\x1b[38;5;226m"
    red = "\x1b[38;5;196m"
    bold_red = "\x1b[31;1m"
    reset = "\x1b[0m"

    def format(self, record):
        # Remove the logger name from the output
        if record.levelno == logging.DEBUG:
            return f"{self.blue}{record.getMessage()}{self.reset}"
        elif record.levelno == logging.INFO:
            return f"{self.grey}{record.getMessage()}{self.reset}"
        elif record.levelno == logging.WARNING:
            return f"{self.yellow}{record.getMessage()}{self.reset}"
        elif record.levelno == logging.ERROR:
            return f"{self.red}{record.getMessage()}{self.reset}"
        elif record.levelno == logging.CRITICAL:
            return f"{self.bold_red}{record.getMessage()}{self.reset}"
        return record.getMessage()

# Setup logger
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)

# Remove any existing handlers
logger.handlers = []

# Create console handler with custom formatter
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
ch.setFormatter(CustomFormatter())
logger.addHandler(ch)

# Suppress matplotlib font debugging
matplotlib_logger = logging.getLogger('matplotlib.font_manager')
matplotlib_logger.setLevel(logging.WARNING)

# Also suppress the UserWarning about tight layout
import warnings
warnings.filterwarnings("ignore", message="Tight layout not applied")


# Model initialization
model_name = "SamanthaStorm/tether-multilabel-v4"
model = AutoModelForSequenceClassification.from_pretrained(model_name).to(device)
tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=False)

# sentiment model - add no_cache=True and force_download=True
# Model initialization
model_name = "SamanthaStorm/tether-multilabel-v4"
model = AutoModelForSequenceClassification.from_pretrained(model_name).to(device)
tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=False)

# sentiment model
sentiment_model = AutoModelForSequenceClassification.from_pretrained(
    "SamanthaStorm/tether-sentiment-v3", 
    force_download=True,
    local_files_only=False
).to(device)
sentiment_tokenizer = AutoTokenizer.from_pretrained(
    "SamanthaStorm/tether-sentiment-v3", 
    use_fast=False,
    force_download=True,
    local_files_only=False
)

# After loading the sentiment model
logger.debug(f"\nSentiment Model Config:")
logger.debug(f"Model name: {sentiment_model.config.name_or_path}")
logger.debug(f"Last modified: {sentiment_model.config._name_or_path}")



emotion_pipeline = hf_pipeline(
    "text-classification",
    model="j-hartmann/emotion-english-distilroberta-base",
    return_all_scores=True,  # Get all emotion scores
    top_k=None,  # Don't limit to top k predictions
    truncation=True,
    device=0 if torch.cuda.is_available() else -1
)
# DARVO model
darvo_model = AutoModelForSequenceClassification.from_pretrained("SamanthaStorm/tether-darvo-regressor-v1").to(device)
darvo_tokenizer = AutoTokenizer.from_pretrained("SamanthaStorm/tether-darvo-regressor-v1", use_fast=False)
darvo_model.eval()

# Constants and Labels
LABELS = [
    "recovery phase", "control", "gaslighting", "guilt tripping", "dismissiveness", 
    "blame shifting", "nonabusive", "projection", "insults", 
    "contradictory statements", "obscure language"
]

SENTIMENT_LABELS = ["supportive", "undermining"]

THRESHOLDS = {
    "recovery phase": 0.324,
    "control": 0.33,
    "gaslighting": 0.285,
    "guilt tripping": 0.267,
    "dismissiveness": 0.123,
    "blame shifting": 0.116,
    "projection": 0.425,
    "insults": 0.347,
    "contradictory statements": 0.378,
    "obscure language": 0.206,
    "nonabusive": 0.094
}


PATTERN_WEIGHTS = {
    "recovery phase": 0.7,
    "control": 1.4,
    "gaslighting": 1.3,
    "guilt tripping": 1.2,
    "dismissiveness": 0.9,
    "blame shifting": 1.0,  # Increased from 0.8
    "projection": 0.5,
    "insults": 1.4,        # Reduced from 2.1
    "contradictory statements": 1.0,
    "obscure language": 0.9,
    "nonabusive": 0.0
}
ESCALATION_QUESTIONS = [
    ("Partner has access to firearms or weapons", 4),
    ("Partner threatened to kill you", 3),
    ("Partner threatened you with a weapon", 3),
    ("Partner has ever choked you, even if you considered it consensual at the time", 4),
    ("Partner injured or threatened your pet(s)", 3),
    ("Partner has broken your things, punched or kicked walls, or thrown things ", 2),
    ("Partner forced or coerced you into unwanted sexual acts", 3),
    ("Partner threatened to take away your children", 2),
    ("Violence has increased in frequency or severity", 3),
    ("Partner monitors your calls/GPS/social media", 2)
]

RISK_STAGE_LABELS = {
    1: "🌀 Risk Stage: Tension-Building\nThis message reflects rising emotional pressure or subtle control attempts.",
    2: "🔥 Risk Stage: Escalation\nThis message includes direct or aggressive patterns, suggesting active harm.",
    3: "🌧️ Risk Stage: Reconciliation\nThis message reflects a reset attempt—apologies or emotional repair without accountability.",
    4: "🌸 Risk Stage: Calm / Honeymoon\nThis message appears supportive but may follow prior harm, minimizing it."
}

THREAT_MOTIFS = [
    "i'll kill you", "i'm going to hurt you", "you're dead", "you won't survive this",
    "i'll break your face", "i'll bash your head in", "i'll snap your neck",
    "i'll come over there and make you shut up", "i'll knock your teeth out",
    "you're going to bleed", "you want me to hit you?", "i won't hold back next time",
    "i swear to god i'll beat you", "next time, i won't miss", "i'll make you scream",
    "i know where you live", "i'm outside", "i'll be waiting", "i saw you with him",
    "you can't hide from me", "i'm coming to get you", "i'll find you", "i know your schedule",
    "i watched you leave", "i followed you home", "you'll regret this", "you'll be sorry",
    "you're going to wish you hadn't", "you brought this on yourself", "don't push me",
    "you have no idea what i'm capable of", "you better watch yourself",
    "i don't care what happens to you anymore", "i'll make you suffer", "you'll pay for this",
    "i'll never let you go", "you're nothing without me", "if you leave me, i'll kill myself",
    "i'll ruin you", "i'll tell everyone what you did", "i'll make sure everyone knows",
    "i'm going to destroy your name", "you'll lose everyone", "i'll expose you", 
    "your friends will hate you", "i'll post everything", "you'll be cancelled",
    "you'll lose everything", "i'll take the house", "i'll drain your account",
    "you'll never see a dime", "you'll be broke when i'm done", "i'll make sure you lose your job",
    "i'll take your kids", "i'll make sure you have nothing", "you can't afford to leave me",
    "don't make me do this", "you know what happens when i'm mad", "you're forcing my hand",
    "if you just behaved, this wouldn't happen", "this is your fault",
    "you're making me hurt you", "i warned you", "you should have listened"
]

def get_emotion_profile(text):
    """Get emotion profile from text with all scores"""
    try:
        logger.debug("\n🎭 EMOTION ANALYSIS")
        logger.debug(f"Analyzing text: {text}")
        
        emotions = emotion_pipeline(text)
        logger.debug(f"Raw emotion pipeline output: {emotions}")
        
        if isinstance(emotions, list) and isinstance(emotions[0], list):
            # Extract all scores from the first prediction
            emotion_scores = emotions[0]
            
            # Log raw scores
            logger.debug("\nRaw emotion scores:")
            for e in emotion_scores:
                logger.debug(f"  • {e['label']}: {e['score']:.3f}")
            
            # Convert to dictionary
            emotion_dict = {e['label'].lower(): round(e['score'], 3) for e in emotion_scores}
            
            # Log final processed emotions
            logger.debug("\nProcessed emotion profile:")
            for emotion, score in emotion_dict.items():
                logger.debug(f"  • {emotion}: {score:.3f}")
                
            return emotion_dict
            
        logger.debug("No valid emotions detected, returning empty dict")
        return {}
        
    except Exception as e:
        logger.error(f"Error in get_emotion_profile: {e}")
        logger.error(f"Traceback: {traceback.format_exc()}")
        default_emotions = {
            "sadness": 0.0,
            "joy": 0.0,
            "neutral": 0.0,
            "disgust": 0.0,
            "anger": 0.0,
            "fear": 0.0
        }
        logger.debug(f"Returning default emotions: {default_emotions}")
        return default_emotions


def get_emotional_tone_tag(text, sentiment, patterns, abuse_score):
    """Get emotional tone tag based on emotions and patterns"""
    emotions = get_emotion_profile(text)
    
    sadness = emotions.get("sadness", 0)
    joy = emotions.get("joy", 0)
    neutral = emotions.get("neutral", 0)
    disgust = emotions.get("disgust", 0)
    anger = emotions.get("anger", 0)
    fear = emotions.get("fear", 0)

    # Direct Threat (New)
    text_lower = text.lower()
    threat_indicators = [
        "if you", "i'll make", "don't forget", "remember", "regret",
        "i control", "i'll take", "you'll lose", "make sure",
        "never see", "won't let"
    ]
    if (
        any(indicator in text_lower for indicator in threat_indicators) and
        any(p in patterns for p in ["control", "insults"]) and
        (anger > 0.2 or disgust > 0.2 or abuse_score > 70)
    ):
        return "direct threat"

        # Prophetic Punishment (New)
    text_lower = text.lower()
    future_consequences = [
        "will end up", "you'll be", "you will be", "going to be",
        "will become", "will find yourself", "will realize",
        "you'll regret", "you'll see", "will learn", "truly will",
        "end up alone", "end up miserable" 
    ]
    dismissive_endings = [
        "i'm out", "i'm done", "whatever", "good luck",
        "your choice", "your problem", "regardless", 
        "keep", "keep on"
    ]
    
    if (
        (any(phrase in text_lower for phrase in future_consequences) or
         any(end in text_lower for end in dismissive_endings)) and
        any(p in ["dismissiveness", "control"] for p in patterns) and
        (disgust > 0.2 or neutral > 0.3 or anger > 0.2)  # Lowered thresholds
    ):
        return "predictive punishment"
    
    if (
        (any(phrase in text_lower for phrase in future_consequences) or
         any(end in text_lower for end in dismissive_endings)) and
        any(p in ["dismissiveness", "control"] for p in patterns) and
        sadness > 0.6 and
        all(e < 0.1 for e in [anger, disgust, neutral])
    ):
        return "predictive punishment"

    # 1. Performative Regret
    if (
        sadness > 0.3 and
        any(p in patterns for p in ["blame shifting", "guilt tripping", "recovery"]) and
        (sentiment == "undermining" or abuse_score > 40)
    ):
        return "performative regret"

    # 2. Coercive Warmth
    if (
        (joy > 0.2 or sadness > 0.3) and
        any(p in patterns for p in ["control", "gaslighting"]) and
        sentiment == "undermining"
    ):
        return "coercive warmth"

    # 3. Cold Invalidation
    if (
        (neutral + disgust) > 0.4 and
        any(p in patterns for p in ["dismissiveness", "projection", "obscure language"]) and
        sentiment == "undermining"
    ):
        return "cold invalidation"

    # 4. Genuine Vulnerability
    if (
        (sadness + fear) > 0.4 and
        sentiment == "supportive" and
        all(p in ["recovery"] for p in patterns)
    ):
        return "genuine vulnerability"

    # 5. Emotional Threat
    if (
        (anger + disgust) > 0.4 and
        any(p in patterns for p in ["control", "insults", "dismissiveness"]) and
        sentiment == "undermining"
    ):
        return "emotional threat"

    # 6. Weaponized Sadness
    if (
        sadness > 0.5 and
        any(p in patterns for p in ["guilt tripping", "projection"]) and
        sentiment == "undermining"
    ):
        return "weaponized sadness"

    # 7. Toxic Resignation
    if (
        neutral > 0.4 and
        any(p in patterns for p in ["dismissiveness", "obscure language"]) and
        sentiment == "undermining"
    ):
        return "toxic resignation"

    # 8. Aggressive Dismissal
    if (
        anger > 0.4 and
        any(p in patterns for p in ["insults", "control"]) and
        sentiment == "undermining"
    ):
        return "aggressive dismissal"

    # 9. Deflective Hostility
    if (
        (0.15 < anger < 0.6 or 0.15 < disgust < 0.6) and
        any(p in patterns for p in ["projection"]) and
        sentiment == "undermining"
    ):
        return "deflective hostility"

    # 10. Contradictory Gaslight
    if (
        (joy + anger + sadness) > 0.4 and
        any(p in patterns for p in ["gaslighting", "contradictory statements"]) and
        sentiment == "undermining"
    ):
        return "contradictory gaslight"

    # 11. Forced Accountability Flip
    if (
        (anger + disgust) > 0.4 and
        any(p in patterns for p in ["blame shifting", "projection"]) and
        sentiment == "undermining"
    ):
        return "forced accountability flip"

    # Emotional Instability Fallback
    if (
        (anger + sadness + disgust) > 0.5 and
        sentiment == "undermining"
    ):
        return "emotional instability"

    return "neutral"
@spaces.GPU
def predict_darvo_score(text):
    """Predict DARVO score for given text"""
    try:
        inputs = darvo_tokenizer(text, return_tensors="pt", truncation=True, padding=True)
        inputs = {k: v.to(device) for k, v in inputs.items()}
        with torch.no_grad():
            logits = darvo_model(**inputs).logits
        return round(sigmoid(logits.cpu()).item(), 4)
    except Exception as e:
        logger.error(f"Error in DARVO prediction: {e}")
        return 0.0

def detect_weapon_language(text):
    """Detect weapon-related language in text"""
    weapon_keywords = ["knife", "gun", "bomb", "weapon", "kill", "stab"]
    t = text.lower()
    return any(w in t for w in weapon_keywords)

def get_risk_stage(patterns, sentiment):
    """Determine risk stage based on patterns and sentiment"""
    try:
        if "insults" in patterns:
            return 2
        elif "recovery" in patterns:
            return 3
        elif "control" in patterns or "guilt tripping" in patterns:
            return 1
        elif sentiment == "supportive" and any(p in patterns for p in ["projection", "dismissiveness"]):
            return 4
        return 1
    except Exception as e:
        logger.error(f"Error determining risk stage: {e}")
        return 1
def detect_threat_pattern(text, patterns):
    """Detect if a message contains threat patterns"""
    # Threat indicators in text
    threat_words = [
        "regret", "sorry", "pay", "hurt", "suffer", "destroy", "ruin",
        "expose", "tell everyone", "never see", "take away", "lose",
        "control", "make sure", "won't let", "force", "warn", "never",
        "punish", "teach you", "learn", "show you", "remember",
        "if you", "don't forget", "i control", "i'll make sure",  # Added these specific phrases
        "bank account", "phone", "money", "access"  # Added financial control indicators
    ]
    
    # Check for conditional threats (if/then structures)
    text_lower = text.lower()
    conditional_threat = (
        "if" in text_lower and 
        any(word in text_lower for word in ["regret", "make sure", "control"])
    )
    
    has_threat_words = any(word in text_lower for word in threat_words)
    
    # Check for threat patterns
    threat_patterns = {"control", "gaslighting", "blame shifting", "insults"}
    has_threat_patterns = any(p in threat_patterns for p in patterns)
    
    return has_threat_words or has_threat_patterns or conditional_threat



def detect_compound_threat(text, patterns):
    """Detect compound threats in a single message"""
    try:
        # Rule A: Single Message Multiple Patterns
        high_risk_patterns = {"control", "gaslighting", "blame shifting", "insults"}
        high_risk_count = sum(1 for p in patterns if p in high_risk_patterns)
        
        has_threat = detect_threat_pattern(text, patterns)
        
        # Special case for control + threats
        has_control = "control" in patterns
        has_conditional_threat = "if" in text.lower() and any(word in text.lower() 
            for word in ["regret", "make sure", "control"])
        
        # Single message compound threat
        if (has_threat and high_risk_count >= 2) or (has_control and has_conditional_threat):
            return True, "single_message"
            
        return False, None
    except Exception as e:
        logger.error(f"Error in compound threat detection: {e}")
        return False, None


def analyze_message_batch_threats(messages, results):
    """Analyze multiple messages for compound threats"""
    threat_messages = []
    support_messages = []
    
    for i, (msg, (result, _)) in enumerate(zip(messages, results)):
        if not msg.strip():  # Skip empty messages
            continue
            
        patterns = result[1]    # Get detected patterns
        
        # Check for threat in this message
        if detect_threat_pattern(msg, patterns):
            threat_messages.append(i)
            
        # Check for supporting patterns
        if any(p in {"control", "gaslighting", "blame shifting"} for p in patterns):
            support_messages.append(i)
    
    # Rule B: Multi-Message Accumulation
    if len(threat_messages) >= 2:
        return True, "multiple_threats"
    elif len(threat_messages) == 1 and len(support_messages) >= 2:
        return True, "threat_with_support"
        
    return False, None


@spaces.GPU
def compute_abuse_score(matched_scores, sentiment):
    """Compute abuse score from matched patterns and sentiment"""
    try:
        if not matched_scores:
            logger.debug("No matched scores, returning 0")
            return 0.0
            
        # Calculate weighted score
        total_weight = sum(weight for _, _, weight in matched_scores)
        if total_weight == 0:
            logger.debug("Total weight is 0, returning 0")
            return 0.0
        
        # Get highest pattern scores
        pattern_scores = [(label, score) for label, score, _ in matched_scores]
        sorted_scores = sorted(pattern_scores, key=lambda x: x[1], reverse=True)
        logger.debug(f"Sorted pattern scores: {sorted_scores}")
        
        # Base score calculation
        weighted_sum = sum(score * weight for _, score, weight in matched_scores)
        base_score = (weighted_sum / total_weight) * 100
        logger.debug(f"Initial base score: {base_score:.1f}")
        
        # Cap maximum score based on pattern severity
        max_score = 85.0  # Set maximum possible score
        if any(label in {'control', 'gaslighting'} for label, _, _ in matched_scores):
            max_score = 90.0
            logger.debug(f"Increased max score to {max_score} due to high severity patterns")
        
        # Apply diminishing returns for multiple patterns
        if len(matched_scores) > 1:
            multiplier = 1 + (0.1 * (len(matched_scores) - 1))
            base_score *= multiplier
            logger.debug(f"Applied multiplier {multiplier:.2f} for {len(matched_scores)} patterns")
            
        # Apply sentiment modifier
        if sentiment == "supportive":
            base_score *= 0.85
            logger.debug("Applied 15% reduction for supportive sentiment")
        
        final_score = min(round(base_score, 1), max_score)
        logger.debug(f"Final abuse score: {final_score}")
        return final_score

    except Exception as e:
        logger.error(f"Error computing abuse score: {e}")
        return 0.0


@spaces.GPU
def analyze_single_message(text, thresholds):
    """Analyze a single message for abuse patterns"""
    logger.debug("\n=== DEBUG START ===")
    logger.debug(f"Input text: {text}")
    
    try:
        if not text.strip():
            logger.debug("Empty text, returning zeros")
            return 0.0, [], [], {"label": "none"}, 1, 0.0, None

        # Check for explicit abuse
        explicit_abuse_words = ['fuck', 'bitch', 'shit', 'ass', 'dick']
        explicit_abuse = any(word in text.lower() for word in explicit_abuse_words)
        logger.debug(f"Explicit abuse detected: {explicit_abuse}")
        
        # Abuse model inference 
        inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True)
        inputs = {k: v.to(device) for k, v in inputs.items()}
        
        with torch.no_grad():
            outputs = model(**inputs)
        raw_scores = torch.sigmoid(outputs.logits.squeeze(0)).cpu().numpy()
        
        # Log raw model outputs
        logger.debug("\nRaw model scores:")
        for label, score in zip(LABELS, raw_scores):
            logger.debug(f"{label}: {score:.3f}")

        # Get predictions and sort them
        predictions = list(zip(LABELS, raw_scores))
        sorted_predictions = sorted(predictions, key=lambda x: x[1], reverse=True)
        logger.debug("\nTop 3 predictions:")
        for label, score in sorted_predictions[:3]:
            logger.debug(f"{label}: {score:.3f}")
        
        # Apply thresholds
        threshold_labels = []
        if explicit_abuse:
            threshold_labels.append("insults")
            logger.debug("\nForced inclusion of 'insults' due to explicit abuse")
            
        for label, score in sorted_predictions:
            base_threshold = thresholds.get(label, 0.25)
            if explicit_abuse:
                base_threshold *= 0.5
            if score > base_threshold:
                if label not in threshold_labels:
                    threshold_labels.append(label)
        
        logger.debug("\nLabels that passed thresholds:", threshold_labels)

        # Calculate matched scores
        matched_scores = []
        for label in threshold_labels:
            score = raw_scores[LABELS.index(label)]
            weight = PATTERN_WEIGHTS.get(label, 1.0)
            if explicit_abuse and label == "insults":
                weight *= 1.5
            matched_scores.append((label, score, weight))

        # In analyze_single_message, modify the sentiment section:
        # Get sentiment
        sent_inputs = sentiment_tokenizer(text, return_tensors="pt", truncation=True, padding=True)
        sent_inputs = {k: v.to(device) for k, v in sent_inputs.items()}
        with torch.no_grad():
            sent_logits = sentiment_model(**sent_inputs).logits[0]
            sent_probs = torch.softmax(sent_logits, dim=-1).cpu().numpy()
    
        # Add detailed logging
        logger.debug("\n🎭 SENTIMENT ANALYSIS DETAILS")
        logger.debug(f"Raw logits: {sent_logits}")
        logger.debug(f"Probabilities: undermining={sent_probs[0]:.3f}, supportive={sent_probs[1]:.3f}")
    
        sentiment = SENTIMENT_LABELS[int(np.argmax(sent_probs))]
        logger.debug(f"Selected sentiment: {sentiment}")

        # Calculate abuse score
        abuse_score = compute_abuse_score(matched_scores, sentiment)
        if explicit_abuse:
            abuse_score = max(abuse_score, 70.0)

        # Check for compound threats
        compound_threat_flag, threat_type = detect_compound_threat(
        text, threshold_labels
    )

        if compound_threat_flag:
            logger.debug(f"⚠️ Compound threat detected in message: {threat_type}")
            abuse_score = max(abuse_score, 85.0)  # Force high score for compound threats


        # Get DARVO score
        darvo_score = predict_darvo_score(text)

        # Get tone using emotion-based approach
        tone_tag = get_emotional_tone_tag(text, sentiment, threshold_labels, abuse_score)
         # Check for the specific combination
        highest_pattern = max(matched_scores, key=lambda x: x[1])[0] if matched_scores else None  # Get highest pattern
        if sentiment == "supportive" and tone_tag == "neutral" and highest_pattern == "obscure language":
            logger.debug("Message classified as likely non-abusive (supportive, neutral, and obscure language). Returning low risk.")
            return 0.0, [], [], {"label": "supportive"}, 1, 0.0, "neutral"  # Return non-abusive values

        # Set stage
        stage = 2 if explicit_abuse or abuse_score > 70 else 1
        
        logger.debug("=== DEBUG END ===\n")

        return abuse_score, threshold_labels, matched_scores, {"label": sentiment}, stage, darvo_score, tone_tag

    except Exception as e:
        logger.error(f"Error in analyze_single_message: {e}")
        return 0.0, [], [], {"label": "error"}, 1, 0.0, None
def generate_abuse_score_chart(dates, scores, patterns):
    """Generate a timeline chart of abuse scores"""
    try:
        plt.figure(figsize=(10, 6))
        plt.clf()
        
        # Create new figure
        fig, ax = plt.subplots(figsize=(10, 6))
        
        # Plot points and lines
        x = range(len(scores))
        plt.plot(x, scores, 'bo-', linewidth=2, markersize=8)
        
        # Add labels for each point with highest scoring pattern
        for i, (score, pattern) in enumerate(zip(scores, patterns)):
            # Get the pattern and its score
            plt.annotate(
                f'{pattern}\n{score:.0f}%',
                (i, score),
                textcoords="offset points",
                xytext=(0, 10),
                ha='center',
                bbox=dict(
                    boxstyle='round,pad=0.5',
                    fc='white',
                    ec='gray',
                    alpha=0.8
                )
            )
        
        # Customize the plot
        plt.ylim(-5, 105)
        plt.grid(True, linestyle='--', alpha=0.7)
        plt.title('Abuse Pattern Timeline', pad=20, fontsize=12)
        plt.ylabel('Abuse Score %')
        
        # X-axis labels
        plt.xticks(x, dates, rotation=45)
        
        # Risk level bands with better colors
        plt.axhspan(0, 50, color='#90EE90', alpha=0.2)   # light green - Low Risk
        plt.axhspan(50, 70, color='#FFD700', alpha=0.2)  # gold - Moderate Risk
        plt.axhspan(70, 85, color='#FFA500', alpha=0.2)  # orange - High Risk
        plt.axhspan(85, 100, color='#FF6B6B', alpha=0.2) # light red - Critical Risk
        
        # Add risk level labels
        plt.text(-0.2, 25, 'Low Risk', rotation=90, va='center')
        plt.text(-0.2, 60, 'Moderate Risk', rotation=90, va='center')
        plt.text(-0.2, 77.5, 'High Risk', rotation=90, va='center')
        plt.text(-0.2, 92.5, 'Critical Risk', rotation=90, va='center')
        
        # Adjust layout
        plt.tight_layout()
        
        # Convert plot to image
        buf = io.BytesIO()
        plt.savefig(buf, format='png', bbox_inches='tight')
        buf.seek(0)
        plt.close('all')  # Close all figures to prevent memory leaks
        
        return Image.open(buf)
    except Exception as e:
        logger.error(f"Error generating abuse score chart: {e}")
        return None


def analyze_composite(msg1, msg2, msg3, *answers_and_none):
    """Analyze multiple messages and checklist responses"""
    logger.debug("\n🔄 STARTING NEW ANALYSIS")
    logger.debug("=" * 50)
    
    # Define severity categories at the start
    high = {'control'}
    moderate = {'gaslighting', 'dismissiveness', 'obscure language', 'insults', 
               'contradictory statements', 'guilt tripping'}
    low = {'blame shifting', 'projection', 'recovery'}
    
    try:
        # Process checklist responses
        logger.debug("\n📋 CHECKLIST PROCESSING")
        logger.debug("=" * 50)
        none_selected_checked = answers_and_none[-1]
        responses_checked = any(answers_and_none[:-1])
        none_selected = not responses_checked and none_selected_checked
        
        logger.debug("Checklist Status:")
        logger.debug(f"  • None Selected Box: {'✓' if none_selected_checked else '✗'}")
        logger.debug(f"  • Has Responses: {'✓' if responses_checked else '✗'}")
        logger.debug(f"  • Final Status: {'None Selected' if none_selected else 'Has Selections'}")

        if none_selected:
            escalation_score = 0
            escalation_note = "Checklist completed: no danger items reported."
            escalation_completed = True
            logger.debug("\n✓ Checklist: No items selected")
        elif responses_checked:
            escalation_score = sum(w for (_, w), a in zip(ESCALATION_QUESTIONS, answers_and_none[:-1]) if a)
            escalation_note = "Checklist completed."
            escalation_completed = True
            logger.debug(f"\n📊 Checklist Score: {escalation_score}")
            
            # Log checked items
            logger.debug("\n⚠️ Selected Risk Factors:")
            for (q, w), a in zip(ESCALATION_QUESTIONS, answers_and_none[:-1]):
                if a:
                    logger.debug(f"  • [{w} points] {q}")
        else:
            escalation_score = None
            escalation_note = "Checklist not completed."
            escalation_completed = False
            logger.debug("\n❗ Checklist: Not completed")

        # Process messages
        logger.debug("\n📝 MESSAGE PROCESSING")
        logger.debug("=" * 50)
        messages = [msg1, msg2, msg3]
        active = [(m, f"Message {i+1}") for i, m in enumerate(messages) if m.strip()]
        logger.debug(f"Active Messages: {len(active)} of 3")
        
        if not active:
            logger.debug("❌ Error: No messages provided")
            return "Please enter at least one message.", None

        # Detect threats
        logger.debug("\n🚨 THREAT DETECTION")
        logger.debug("=" * 50)
        
        def normalize(text):
            import unicodedata
            text = text.lower().strip()
            text = unicodedata.normalize("NFKD", text)
            text = text.replace("'", "'")
            return re.sub(r"[^a-z0-9 ]", "", text)

        def detect_threat_motifs(message, motif_list):
            norm_msg = normalize(message)
            return [motif for motif in motif_list if normalize(motif) in norm_msg]

        # Analyze threats and patterns
        immediate_threats = [detect_threat_motifs(m, THREAT_MOTIFS) for m, _ in active]
        flat_threats = [t for sublist in immediate_threats for t in sublist]
        threat_risk = "Yes" if flat_threats else "No"
                # Analyze each message
        logger.debug("\n🔍 INDIVIDUAL MESSAGE ANALYSIS")
        logger.debug("=" * 50)
        results = []
        for m, d in active:
            logger.debug(f"\n📝 ANALYZING {d}")
            logger.debug("-" * 40)  # Separator for each message
            result = analyze_single_message(m, THRESHOLDS.copy())

            # Check for non-abusive classification and skip further analysis
            if result[0] == 0.0 and result[1] == [] and result[3] == {"label": "supportive"} and result[4] == 1 and result[5] == 0.0 and result[6] == "neutral":
                logger.debug(f"✓ {d} classified as non-abusive, skipping further analysis.")
                # Option to include in final output (uncomment if needed):
                # results.append(({"abuse_score": 0.0, "patterns": [], "sentiment": {"label": "supportive"}, "stage": 1, "darvo_score": 0.0, "tone": "neutral"}, d))
                continue  # Skip to the next message

            results.append((result, d))
            # Log the detailed results for the current message (if not skipped)
            abuse_score, patterns, matched_scores, sentiment, stage, darvo_score, tone = result
            logger.debug(f"\n📊 Results for {d}:")
            logger.debug(f"  • Abuse Score: {abuse_score:.1f}%")
            logger.debug(f"  • DARVO Score: {darvo_score:.3f}")
            logger.debug(f"  • Risk Stage: {stage}")
            logger.debug(f"  • Sentiment: {sentiment['label']}")
            logger.debug(f"  • Tone: {tone}")
            if patterns:
                logger.debug("  • Patterns: " + ", ".join(patterns))

            
            # Unpack results for cleaner logging
            abuse_score, patterns, matched_scores, sentiment, stage, darvo_score, tone = result
            
            # Log core metrics
            logger.debug("\n📊 CORE METRICS")
            logger.debug(f"  • Abuse Score: {abuse_score:.1f}%")
            logger.debug(f"  • DARVO Score: {darvo_score:.3f}")
            logger.debug(f"  • Risk Stage: {stage}")
            logger.debug(f"  • Sentiment: {sentiment['label']}")
            logger.debug(f"  • Tone: {tone}")

            # Log detected patterns with scores
            if patterns:
                logger.debug("\n🎯 DETECTED PATTERNS")
                for label, score, weight in matched_scores:
                    severity = "❗HIGH" if label in high else "⚠️ MODERATE" if label in moderate else "📝 LOW"
                    logger.debug(f"  • {severity} | {label}: {score:.3f} (weight: {weight})")
            else:
                logger.debug("\n✓ No abuse patterns detected")

        # Extract scores and metadata
        abuse_scores = [r[0][0] for r in results]
        stages = [r[0][4] for r in results]
        darvo_scores = [r[0][5] for r in results]
        tone_tags = [r[0][6] for r in results]
        dates_used = [r[1] for r in results]

        # Pattern Analysis Summary
        logger.debug("\n📈 PATTERN ANALYSIS SUMMARY")
        logger.debug("=" * 50)
        predicted_labels = [label for r in results for label in r[0][1]]
        
        if predicted_labels:
            logger.debug("Detected Patterns Across All Messages:")
            pattern_counts = Counter(predicted_labels)
            
            # Log high severity patterns first
            high_patterns = [p for p in pattern_counts if p in high]
            if high_patterns:
                logger.debug("\n❗ HIGH SEVERITY PATTERNS:")
                for p in high_patterns:
                    logger.debug(f"  • {p} (×{pattern_counts[p]})")
            
            # Then moderate
            moderate_patterns = [p for p in pattern_counts if p in moderate]
            if moderate_patterns:
                logger.debug("\n⚠️ MODERATE SEVERITY PATTERNS:")
                for p in moderate_patterns:
                    logger.debug(f"  • {p} (×{pattern_counts[p]})")
            
            # Then low
            low_patterns = [p for p in pattern_counts if p in low]
            if low_patterns:
                logger.debug("\n📝 LOW SEVERITY PATTERNS:")
                for p in low_patterns:
                    logger.debug(f"  • {p} (×{pattern_counts[p]})")
        else:
            logger.debug("✓ No patterns detected across messages")

        # Pattern Severity Analysis
        logger.debug("\n⚖️ SEVERITY ANALYSIS")
        logger.debug("=" * 50)
        counts = {'high': 0, 'moderate': 0, 'low': 0}
        for label in predicted_labels:
            if label in high:
                counts['high'] += 1
            elif label in moderate:
                counts['moderate'] += 1
            elif label in low:
                counts['low'] += 1

        logger.debug("Pattern Distribution:")
        if counts['high'] > 0:
            logger.debug(f"  ❗ High Severity: {counts['high']}")
        if counts['moderate'] > 0:
            logger.debug(f"  ⚠️ Moderate Severity: {counts['moderate']}")
        if counts['low'] > 0:
            logger.debug(f"  📝 Low Severity: {counts['low']}")
        
        total_patterns = sum(counts.values())
        if total_patterns > 0:
            logger.debug(f"\nSeverity Percentages:")
            logger.debug(f"  • High: {(counts['high']/total_patterns)*100:.1f}%")
            logger.debug(f"  • Moderate: {(counts['moderate']/total_patterns)*100:.1f}%")
            logger.debug(f"  • Low: {(counts['low']/total_patterns)*100:.1f}%")
        # Risk Assessment
        logger.debug("\n🎯 RISK ASSESSMENT")
        logger.debug("=" * 50)
        if counts['high'] >= 2 and counts['moderate'] >= 2:
            pattern_escalation_risk = "Critical"
            logger.debug("❗❗ CRITICAL RISK")
            logger.debug("  • Multiple high and moderate patterns detected")
            logger.debug(f"  • High patterns: {counts['high']}")
            logger.debug(f"  • Moderate patterns: {counts['moderate']}")
        elif (counts['high'] >= 2 and counts['moderate'] >= 1) or \
             (counts['moderate'] >= 3) or \
             (counts['high'] >= 1 and counts['moderate'] >= 2):
            pattern_escalation_risk = "High"
            logger.debug("❗ HIGH RISK")
            logger.debug("  • Significant pattern combination detected")
            logger.debug(f"  • High patterns: {counts['high']}")
            logger.debug(f"  • Moderate patterns: {counts['moderate']}")
        elif (counts['moderate'] == 2) or \
             (counts['high'] == 1 and counts['moderate'] == 1) or \
             (counts['moderate'] == 1 and counts['low'] >= 2) or \
             (counts['high'] == 1 and sum(counts.values()) == 1):
            pattern_escalation_risk = "Moderate"
            logger.debug("⚠️ MODERATE RISK")
            logger.debug("  • Concerning pattern combination detected")
            logger.debug(f"  • Pattern distribution: H:{counts['high']}, M:{counts['moderate']}, L:{counts['low']}")
        else:
            pattern_escalation_risk = "Low"
            logger.debug("📝 LOW RISK")
            logger.debug("  • Limited pattern severity detected")
            logger.debug(f"  • Pattern distribution: H:{counts['high']}, M:{counts['moderate']}, L:{counts['low']}")

        # Checklist Risk Assessment
        logger.debug("\n📋 CHECKLIST RISK ASSESSMENT")
        logger.debug("=" * 50)
        checklist_escalation_risk = "Unknown" if escalation_score is None else (
            "Critical" if escalation_score >= 20 else
            "Moderate" if escalation_score >= 10 else
            "Low"
        )
        if escalation_score is not None:
            logger.debug(f"Score: {escalation_score}/29")
            logger.debug(f"Risk Level: {checklist_escalation_risk}")
            if escalation_score >= 20:
                logger.debug("❗❗ CRITICAL: Score indicates severe risk")
            elif escalation_score >= 10:
                logger.debug("⚠️ MODERATE: Score indicates concerning risk")
            else:
                logger.debug("📝 LOW: Score indicates limited risk")
        else:
            logger.debug("❓ Risk Level: Unknown (checklist not completed)")

        # Escalation Analysis
        logger.debug("\n📈 ESCALATION ANALYSIS")
        logger.debug("=" * 50)
        escalation_bump = 0
        for result, msg_id in results:
            abuse_score, _, _, sentiment, stage, darvo_score, tone_tag = result
            logger.debug(f"\n🔍 Message {msg_id} Risk Factors:")
            
            factors = []
            if darvo_score > 0.65:
                escalation_bump += 3
                factors.append(f"▲ +3: High DARVO score ({darvo_score:.3f})")
            if tone_tag in ["forced accountability flip", "emotional threat"]:
                escalation_bump += 2
                factors.append(f"▲ +2: Concerning tone ({tone_tag})")
            if abuse_score > 80:
                escalation_bump += 2
                factors.append(f"▲ +2: High abuse score ({abuse_score:.1f}%)")
            if stage == 2:
                escalation_bump += 3
                factors.append("▲ +3: Escalation stage")
                
            if factors:
                for factor in factors:
                    logger.debug(f"  {factor}")
            else:
                logger.debug("  ✓ No escalation factors")

        logger.debug(f"\n📊 Total Escalation Bump: +{escalation_bump}")
        # Check for compound threats across messages
        compound_threat_flag, threat_type = analyze_message_batch_threats(
            [msg1, msg2, msg3], results
        )

        if compound_threat_flag:
            logger.debug(f"⚠️ Compound threat detected across messages: {threat_type}")
            pattern_escalation_risk = "Critical"  # Override risk level
            logger.debug("Risk level elevated to CRITICAL due to compound threats")

        # Combined Risk Calculation
        logger.debug("\n🎯 FINAL RISK CALCULATION")
        logger.debug("=" * 50)
        def rank(label):
            return {"Low": 0, "Moderate": 1, "High": 2, "Critical": 3, "Unknown": 0}.get(label, 0)

        combined_score = rank(pattern_escalation_risk) + rank(checklist_escalation_risk) + escalation_bump
        logger.debug("Risk Components:")
        logger.debug(f"  • Pattern Risk ({pattern_escalation_risk}): +{rank(pattern_escalation_risk)}")
        logger.debug(f"  • Checklist Risk ({checklist_escalation_risk}): +{rank(checklist_escalation_risk)}")
        logger.debug(f"  • Escalation Bump: +{escalation_bump}")
        logger.debug(f"  = Combined Score: {combined_score}")
        
        escalation_risk = (
            "Critical" if combined_score >= 6 else
            "High" if combined_score >= 4 else
            "Moderate" if combined_score >= 2 else
            "Low"
        )
        logger.debug(f"\n⚠️ Final Escalation Risk: {escalation_risk}")
        # Generate Output Text
        logger.debug("\n📝 GENERATING OUTPUT")
        logger.debug("=" * 50)
        if escalation_score is None:
            escalation_text = (
                "🚫 **Escalation Potential: Unknown** (Checklist not completed)\n"
                "⚠️ This section was not completed. Escalation potential is estimated using message data only.\n"
            )
            hybrid_score = 0
            logger.debug("Generated output for incomplete checklist")
        elif escalation_score == 0:
            escalation_text = (
                "✅ **Escalation Checklist Completed:** No danger items reported.\n"
                "🧭 **Escalation potential estimated from detected message patterns only.**\n"
                f"• Pattern Risk: {pattern_escalation_risk}\n"
                f"• Checklist Risk: None reported\n"
                f"• Escalation Bump: +{escalation_bump} (from DARVO, tone, intensity, etc.)"
            )
            hybrid_score = escalation_bump
            logger.debug("Generated output for no-risk checklist")
        else:
            hybrid_score = escalation_score + escalation_bump
            escalation_text = (
                f"📈 **Escalation Potential: {escalation_risk} ({hybrid_score}/29)**\n"
                "📋 This score combines your safety checklist answers *and* detected high-risk behavior.\n"
                f"• Pattern Risk: {pattern_escalation_risk}\n"
                f"• Checklist Risk: {checklist_escalation_risk}\n"
                f"• Escalation Bump: +{escalation_bump} (from DARVO, tone, intensity, etc.)"
            )
            logger.debug(f"Generated output with hybrid score: {hybrid_score}/29")

        # Final Metrics
        logger.debug("\n📊 FINAL METRICS")
        logger.debug("=" * 50)
        composite_abuse = int(round(sum(abuse_scores) / len(abuse_scores)))
        logger.debug(f"Composite Abuse Score: {composite_abuse}%")
        
        most_common_stage = max(set(stages), key=stages.count)
        logger.debug(f"Most Common Stage: {most_common_stage}")
        
        avg_darvo = round(sum(darvo_scores) / len(darvo_scores), 3)
        logger.debug(f"Average DARVO Score: {avg_darvo}")

        # Generate Final Report
        logger.debug("\n📄 GENERATING FINAL REPORT")
        logger.debug("=" * 50)
        out = f"Abuse Intensity: {composite_abuse}%\n"
        # Add detected patterns to output
        if predicted_labels:
            out += "🔍 Detected Patterns:\n"
            if high_patterns:
                patterns_str = ", ".join(f"{p} ({pattern_counts[p]}x)" for p in high_patterns)
                out += f"❗ High Severity: {patterns_str}\n"
            if moderate_patterns:
                patterns_str = ", ".join(f"{p} ({pattern_counts[p]}x)" for p in moderate_patterns)
                out += f"⚠️ Moderate Severity: {patterns_str}\n"
            if low_patterns:
                patterns_str = ", ".join(f"{p} ({pattern_counts[p]}x)" for p in low_patterns)
                out += f"📝 Low Severity: {patterns_str}\n"
        out += "\n"

        out += "📊 This reflects the strength and severity of detected abuse patterns in the message(s).\n\n"
        

        # Risk Level Assessment
        risk_level = (
            "Critical" if composite_abuse >= 85 or hybrid_score >= 20 else
            "High" if composite_abuse >= 70 or hybrid_score >= 15 else
            "Moderate" if composite_abuse >= 50 or hybrid_score >= 10 else
            "Low"
        )
        logger.debug(f"Final Risk Level: {risk_level}")

        # Add Risk Description
        risk_descriptions = {
            "Critical": (
                "🚨 **Risk Level: Critical**\n"
                "Multiple severe abuse patterns detected. This situation shows signs of "
                "dangerous escalation and immediate intervention may be needed."
            ),
            "High": (
                "⚠️ **Risk Level: High**\n"
                "Strong abuse patterns detected. This situation shows concerning "
                "signs of manipulation and control."
            ),
            "Moderate": (
                "⚡ **Risk Level: Moderate**\n"
                "Concerning patterns detected. While not severe, these behaviors "
                "indicate unhealthy relationship dynamics."
            ),
            "Low": (
                "📝 **Risk Level: Low**\n"
                "Minor concerning patterns detected. While present, the detected "
                "behaviors are subtle or infrequent."
            )
        }
        
        out += risk_descriptions[risk_level]
        out += f"\n\n{RISK_STAGE_LABELS[most_common_stage]}"
        logger.debug("Added risk description and stage information")

        # Add DARVO Analysis
        if avg_darvo > 0.25:
            level = "moderate" if avg_darvo < 0.65 else "high"
            out += f"\n\n🎭 **DARVO Score: {avg_darvo}** → This indicates a **{level} likelihood** of narrative reversal (DARVO), where the speaker may be denying, attacking, or reversing blame."
            logger.debug(f"Added DARVO analysis ({level} level)")

        # Add Emotional Tones
        logger.debug("\n🎭 Adding Emotional Tones")
        out += "\n\n🎭 **Emotional Tones Detected:**\n"
        for i, tone in enumerate(tone_tags):
            out += f"• Message {i+1}: *{tone or 'none'}*\n"
            logger.debug(f"Message {i+1} tone: {tone}")

        # Add Threats Section
        logger.debug("\n⚠️ Adding Threat Analysis")
        if flat_threats:
            out += "\n\n🚨 **Immediate Danger Threats Detected:**\n"
            for t in set(flat_threats):
                out += f"• \"{t}\"\n"
            out += "\n⚠️ These phrases may indicate an imminent risk to physical safety."
            logger.debug(f"Added {len(set(flat_threats))} unique threat warnings")
        else:
            out += "\n\n🧩 **Immediate Danger Threats:** None explicitly detected.\n"
            out += "This does *not* rule out risk, but no direct threat phrases were matched."
            logger.debug("No threats to add")

        # Generate Timeline
        logger.debug("\n📈 Generating Timeline")
        pattern_labels = []
        for result, _ in results:
            matched_scores = result[2]  # Get the matched_scores from the result tuple
            if matched_scores:
                # Sort matched_scores by score and get the highest scoring pattern
                highest_pattern = max(matched_scores, key=lambda x: x[1])
                pattern_labels.append(highest_pattern[0])  # Add the pattern name
            else:
                pattern_labels.append("none")

        logger.debug("Pattern labels for timeline:")
        for i, (pattern, score) in enumerate(zip(pattern_labels, abuse_scores)):
            logger.debug(f"Message {i+1}: {pattern} ({score:.1f}%)")

        timeline_image = generate_abuse_score_chart(dates_used, abuse_scores, pattern_labels)
        logger.debug("Timeline generated successfully")
        
        # Add Escalation Text
        out += "\n\n" + escalation_text
        logger.debug("Added escalation text to output")
        
        logger.debug("\n✅ ANALYSIS COMPLETE")
        logger.debug("=" * 50)
        return out, timeline_image

    except Exception as e:
        logger.error("\n❌ ERROR IN ANALYSIS")
        logger.error("=" * 50)
        logger.error(f"Error type: {type(e).__name__}")
        logger.error(f"Error message: {str(e)}")
        logger.error(f"Traceback:\n{traceback.format_exc()}")
        return "An error occurred during analysis.", None




# Gradio Interface Setup
def create_interface():
    try:
        textbox_inputs = [gr.Textbox(label=f"Message {i+1}") for i in range(3)]
        quiz_boxes = [gr.Checkbox(label=q) for q, _ in ESCALATION_QUESTIONS]
        none_box = gr.Checkbox(label="None of the above")

        demo = gr.Interface(
            fn=analyze_composite,
            inputs=textbox_inputs + quiz_boxes + [none_box],
            outputs=[
                gr.Textbox(label="Results"),
                gr.Image(label="Abuse Score Timeline", type="pil")
            ],
            title="Abuse Pattern Detector + Escalation Quiz",
            description=(
                "Enter up to three messages that concern you. "
                "For the most accurate results, include messages from a recent emotionally intense period."
            ),
            flagging_mode="manual"
        )
        return demo
    except Exception as e:
        logger.error(f"Error creating interface: {e}")
        raise

# Main execution
if __name__ == "__main__":
    try:
        demo = create_interface()
        demo.launch(
            server_name="0.0.0.0",
            server_port=7860,
            share=False
        )
    except Exception as e:
        logger.error(f"Failed to launch app: {e}")
        raise