app.py

"""
Advanced AI Text Detector - Enhanced Results Display & API
4-Category Classification with improved UX and JSON API support
"""

import gradio as gr
import torch
import numpy as np
import re
import time
from transformers import AutoTokenizer, AutoModelForSequenceClassification
from typing import Dict, List, Tuple
import statistics
import string
from collections import Counter
import json
import plotly.graph_objects as go
import plotly.express as px
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

class ImprovedAIDetector:
    """
    Enhanced AI text detector with 4-category classification and improved accuracy
    """

    def __init__(self):
        self.tokenizer = None
        self.model = None
        self.load_models()

    def load_models(self):
        """Load and cache detection models"""
        try:
            model_name = "roberta-base-openai-detector"
            self.tokenizer = AutoTokenizer.from_pretrained(model_name)
            self.model = AutoModelForSequenceClassification.from_pretrained(model_name)
            print("✓ Models loaded successfully")
        except Exception as e:
            print(f"⚠️ Model loading failed: {e}")
            self.tokenizer = None
            self.model = None

    def extract_linguistic_features(self, text: str) -> Dict[str, float]:
        """Extract comprehensive linguistic features for detection"""
        if len(text.strip()) < 10:
            return {}

        sentences = re.split(r'[.!?]+', text)
        sentences = [s.strip() for s in sentences if s.strip()]
        words = text.split()

        if not sentences or not words:
            return {}

        features = {}

        # Length-based features
        features['avg_sentence_length'] = np.mean([len(s.split()) for s in sentences])
        features['avg_word_length'] = np.mean([len(word) for word in words])
        features['total_words'] = len(words)

        # Vocabulary diversity
        unique_words = len(set(word.lower() for word in words))
        features['lexical_diversity'] = unique_words / len(words) if words else 0

        # Punctuation patterns
        punct_count = sum(1 for char in text if char in string.punctuation)
        features['punctuation_ratio'] = punct_count / len(text) if text else 0

        # Sentence structure
        features['sentence_count'] = len(sentences)
        if len(sentences) > 1:
            sentence_lengths = [len(s.split()) for s in sentences]
            features['sentence_length_variance'] = np.var(sentence_lengths)
        else:
            features['sentence_length_variance'] = 0

        # Word frequency patterns
        word_freq = Counter(word.lower() for word in words)
        most_common_freq = word_freq.most_common(1)[0][1] if word_freq else 1
        features['max_word_frequency'] = most_common_freq / len(words)

        # Function words (common in AI text)
        function_words = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by'}
        function_word_count = sum(1 for word in words if word.lower() in function_words)
        features['function_word_ratio'] = function_word_count / len(words) if words else 0

        # AI-specific patterns
        ai_indicators = ['furthermore', 'moreover', 'additionally', 'consequently', 'therefore', 'thus', 'hence']
        ai_indicator_count = sum(1 for word in words if word.lower() in ai_indicators)
        features['ai_indicator_ratio'] = ai_indicator_count / len(words) if words else 0

        # Repetition patterns
        bigrams = [(words[i].lower(), words[i+1].lower()) for i in range(len(words)-1)]
        unique_bigrams = len(set(bigrams))
        features['bigram_diversity'] = unique_bigrams / len(bigrams) if bigrams else 0

        return features

    def calculate_perplexity_score(self, text: str) -> float:
        """Calculate a simplified perplexity-like score"""
        if not self.model or not self.tokenizer:
            words = text.split()
            if len(words) < 5:
                return 0.5

            avg_word_length = np.mean([len(word) for word in words])
            sentence_count = len(re.split(r'[.!?]+', text))
            complexity_score = (avg_word_length * sentence_count) / len(words)
            return min(max(complexity_score, 0.1), 0.9)

        try:
            inputs = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
            with torch.no_grad():
                outputs = self.model(**inputs)
                probs = torch.softmax(outputs.logits, dim=-1)
                confidence = torch.max(probs).item()
                return 1.0 - confidence
        except:
            return 0.5

    def detect_refinement_patterns(self, text: str, linguistic_features: Dict) -> Dict[str, float]:
        """Detect patterns indicating AI refinement/editing"""
        refinement_indicators = {}

        sentences = re.split(r'[.!?]+', text)
        sentences = [s.strip() for s in sentences if s.strip()]

        # Check for overly consistent sentence structure
        if len(sentences) > 2:
            lengths = [len(s.split()) for s in sentences]
            length_consistency = 1.0 - (np.std(lengths) / np.mean(lengths)) if np.mean(lengths) > 0 else 0
            refinement_indicators['structure_consistency'] = min(length_consistency, 1.0)
        else:
            refinement_indicators['structure_consistency'] = 0.5

        # Check for formal language patterns
        formal_words = ['furthermore', 'moreover', 'consequently', 'therefore', 'additionally', 'subsequently']
        formal_count = sum(1 for word in text.lower().split() if word in formal_words)
        refinement_indicators['formality_score'] = min(formal_count / len(text.split()) * 10, 1.0)

        # Check for lack of contractions
        contractions = ["n't", "'ll", "'re", "'ve", "'m", "'d", "'s"]
        contraction_count = sum(1 for word in text.split() if any(cont in word for cont in contractions))
        words_count = len(text.split())
        refinement_indicators['contraction_absence'] = 1.0 - min(contraction_count / words_count * 5, 1.0) if words_count > 0 else 0.5

        # Check for punctuation patterns
        punct_perfect_score = 0.5
        if ',' in text and '.' in text:
            comma_count = text.count(',')
            period_count = text.count('.')
            if comma_count > 0 and period_count > 0:
                punct_ratio = comma_count / (comma_count + period_count)
                if 0.3 <= punct_ratio <= 0.7:
                    punct_perfect_score = 0.8

        refinement_indicators['punctuation_perfection'] = punct_perfect_score

        return refinement_indicators

    def classify_text_category(self, text: str) -> Tuple[str, Dict[str, float], float]:
        """Classify text into 4 categories with confidence scores"""
        if len(text.strip()) < 10:
            return "Uncertain", {"ai_generated": 0.25, "ai_refined": 0.25, "human_ai_refined": 0.25, "human_written": 0.25}, 0.3

        # Extract features
        linguistic_features = self.extract_linguistic_features(text)
        refinement_patterns = self.detect_refinement_patterns(text, linguistic_features)
        perplexity_score = self.calculate_perplexity_score(text)

        # Get transformer model prediction if available
        transformer_ai_prob = 0.5
        if self.model and self.tokenizer:
            try:
                inputs = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
                with torch.no_grad():
                    outputs = self.model(**inputs)
                    probs = torch.softmax(outputs.logits, dim=-1)
                    transformer_ai_prob = probs[0][1].item()
            except:
                pass

        # Calculate category probabilities
        scores = {}

        # AI-generated score
        ai_generated_score = 0.0
        if linguistic_features:
            ai_generated_score = (
                transformer_ai_prob * 0.4 +
                (1.0 - linguistic_features.get('lexical_diversity', 0.5)) * 0.2 +
                linguistic_features.get('ai_indicator_ratio', 0) * 0.15 +
                (1.0 - linguistic_features.get('sentence_length_variance', 0.5) / 10) * 0.15 +
                (1.0 - perplexity_score) * 0.1
            )
        else:
            ai_generated_score = transformer_ai_prob

        scores['ai_generated'] = min(max(ai_generated_score, 0.0), 1.0)

        # AI-generated & AI-refined score
        ai_refined_score = 0.0
        if refinement_patterns:
            ai_refined_score = (
                transformer_ai_prob * 0.3 +
                refinement_patterns.get('structure_consistency', 0) * 0.25 +
                refinement_patterns.get('formality_score', 0) * 0.25 +
                refinement_patterns.get('punctuation_perfection', 0) * 0.2
            )
        else:
            ai_refined_score = transformer_ai_prob * 0.7

        scores['ai_refined'] = min(max(ai_refined_score, 0.0), 1.0)

        # Human-written & AI-refined score
        human_ai_refined_score = 0.0
        if linguistic_features and refinement_patterns:
            human_ai_refined_score = (
                (1.0 - transformer_ai_prob) * 0.3 +
                linguistic_features.get('lexical_diversity', 0.5) * 0.2 +
                refinement_patterns.get('structure_consistency', 0) * 0.2 +
                refinement_patterns.get('contraction_absence', 0) * 0.15 +
                refinement_patterns.get('formality_score', 0) * 0.15
            )
        else:
            human_ai_refined_score = (1.0 - transformer_ai_prob) * 0.6

        scores['human_ai_refined'] = min(max(human_ai_refined_score, 0.0), 1.0)

        # Human-written score
        human_written_score = 0.0
        if linguistic_features:
            human_written_score = (
                (1.0 - transformer_ai_prob) * 0.4 +
                linguistic_features.get('lexical_diversity', 0.5) * 0.2 +
                linguistic_features.get('sentence_length_variance', 0.5) / 10 * 0.15 +
                (1.0 - refinement_patterns.get('structure_consistency', 0.5)) * 0.15 +
                perplexity_score * 0.1
            )
        else:
            human_written_score = 1.0 - transformer_ai_prob

        scores['human_written'] = min(max(human_written_score, 0.0), 1.0)

        # Normalize scores
        total_score = sum(scores.values())
        if total_score > 0:
            scores = {k: v / total_score for k, v in scores.items()}
        else:
            scores = {"ai_generated": 0.25, "ai_refined": 0.25, "human_ai_refined": 0.25, "human_written": 0.25}

        # Determine primary category
        primary_category = max(scores, key=scores.get)
        confidence = scores[primary_category]

        # Map to readable names
        category_names = {
            'ai_generated': 'AI-generated',
            'ai_refined': 'AI-generated & AI-refined', 
            'human_ai_refined': 'Human-written & AI-refined',
            'human_written': 'Human-written'
        }

        return category_names[primary_category], scores, confidence

    def get_analysis_json(self, text: str) -> Dict:
        """Get analysis results in JSON format for API"""
        start_time = time.time()

        if not text or len(text.strip()) < 10:
            return {
                "error": "Text must be at least 10 characters long",
                "ai_percentage": 0,
                "human_percentage": 0,
                "category_scores": {
                    "ai_generated": 0,
                    "ai_refined": 0,
                    "human_ai_refined": 0,
                    "human_written": 0
                },
                "primary_category": "uncertain",
                "confidence": 0,
                "processing_time_ms": 0
            }

        try:
            primary_category, category_scores, confidence = self.classify_text_category(text)

            ai_percentage = (category_scores['ai_generated'] + category_scores['ai_refined']) * 100
            human_percentage = (category_scores['human_ai_refined'] + category_scores['human_written']) * 100

            processing_time = (time.time() - start_time) * 1000

            return {
                "ai_percentage": round(ai_percentage, 1),
                "human_percentage": round(human_percentage, 1),
                "category_scores": {
                    "ai_generated": round(category_scores['ai_generated'] * 100, 1),
                    "ai_refined": round(category_scores['ai_refined'] * 100, 1),
                    "human_ai_refined": round(category_scores['human_ai_refined'] * 100, 1),
                    "human_written": round(category_scores['human_written'] * 100, 1)
                },
                "primary_category": primary_category.lower().replace(' ', '_').replace('-', '_'),
                "confidence": round(confidence * 100, 1),
                "processing_time_ms": round(processing_time, 1)
            }

        except Exception as e:
            return {
                "error": str(e),
                "ai_percentage": 0,
                "human_percentage": 0,
                "category_scores": {
                    "ai_generated": 0,
                    "ai_refined": 0,
                    "human_ai_refined": 0,
                    "human_written": 0
                },
                "primary_category": "error",
                "confidence": 0,
                "processing_time_ms": 0
            }

# Initialize detector
detector = ImprovedAIDetector()

def create_bar_chart(ai_percentage, human_percentage):
    """Create vertical bar chart showing AI vs Human percentages"""

    fig = go.Figure(data=[
        go.Bar(
            x=['AI', 'Human'],
            y=[ai_percentage, human_percentage],
            marker=dict(
                color=['#FF6B6B', '#4ECDC4'],
                line=dict(color='rgba(0,0,0,0.3)', width=2)
            ),
            text=[f'{ai_percentage:.0f}%', f'{human_percentage:.0f}%'],
            textposition='auto',
            textfont=dict(size=14, color='white', family='Arial Black'),
            hovertemplate='<b>%{x}</b><br>%{y:.1f}%<extra></extra>'
        )
    ])

    fig.update_layout(
        title=dict(
            text='AI vs Human Content Distribution',
            x=0.5,
            font=dict(size=16, color='#2c3e50', family='Arial')
        ),
        xaxis=dict(
            title='Content Type',
            titlefont=dict(size=14, color='#34495e'),
            tickfont=dict(size=12, color='#34495e')
        ),
        yaxis=dict(
            title='Percentage (%)',
            titlefont=dict(size=14, color='#34495e'),
            tickfont=dict(size=12, color='#34495e'),
            range=[0, 100]
        ),
        plot_bgcolor='rgba(0,0,0,0)',
        paper_bgcolor='rgba(0,0,0,0)',
        showlegend=False,
        height=400,
        margin=dict(t=60, b=50, l=50, r=50)
    )

    fig.update_xaxis(showgrid=False, zeroline=False)
    fig.update_yaxis(showgrid=True, gridwidth=1, gridcolor='rgba(0,0,0,0.1)')

    return fig

def analyze_text_enhanced(text):
    """Enhanced analysis function with improved result formatting"""
    if not text or len(text.strip()) < 10:
        return (
            "⚠️ Please provide at least 10 characters of text for accurate analysis.",
            None,  # Chart
            "",    # Metrics HTML
            f"{len(text.strip())}"  # Text length
        )

    start_time = time.time()

    try:
        # Get analysis results
        primary_category, category_scores, confidence = detector.classify_text_category(text)

        # Calculate percentages
        ai_percentage = (category_scores['ai_generated'] + category_scores['ai_refined']) * 100
        human_percentage = (category_scores['human_ai_refined'] + category_scores['human_written']) * 100

        processing_time = (time.time() - start_time) * 1000

        # Part 1: Summary Score
        summary_html = f"""
        <div style="text-align: center; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); 
                    color: white; padding: 30px; border-radius: 15px; margin: 20px 0; box-shadow: 0 8px 25px rgba(0,0,0,0.15);">
            <div style="font-size: 48px; font-weight: bold; margin-bottom: 10px; text-shadow: 2px 2px 4px rgba(0,0,0,0.3);">
                {ai_percentage:.0f}%
            </div>
            <div style="font-size: 18px; line-height: 1.4; margin-bottom: 5px;">
                of this text is likely <strong>AI-generated or AI-refined</strong>
            </div>
            <div style="font-size: 14px; opacity: 0.9; font-style: italic;">
                (This score represents the percentage of words that are likely AI-generated or have been refined using AI tools.)
            </div>
        </div>
        """

        # Part 2: Create bar chart
        bar_chart = create_bar_chart(ai_percentage, human_percentage)

        # Part 2: Detailed metrics HTML
        metrics_html = f"""
        <div style="margin: 20px 0; padding: 20px; background: #f8f9fa; border-radius: 12px; border-left: 5px solid #667eea;">
            <h4 style="color: #2c3e50; margin-bottom: 15px; font-size: 16px;">📊 Detailed Breakdown</h4>

            <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 15px; margin-bottom: 20px;">

                <div style="background: white; padding: 15px; border-radius: 8px; border: 1px solid #e9ecef;">
                    <div style="display: flex; align-items: center; margin-bottom: 8px;">
                        <span style="font-size: 20px; margin-right: 8px;">🤖</span>
                        <span style="font-weight: 600; color: #2c3e50;">AI-generated</span>
                        <span title="Text likely generated by AI, like ChatGPT or Gemini." style="margin-left: 5px; cursor: help; color: #6c757d;">ⓘ</span>
                    </div>
                    <div style="font-size: 24px; font-weight: bold; color: #FF6B6B;">
                        {category_scores['ai_generated']*100:.0f}%
                    </div>
                </div>

                <div style="background: white; padding: 15px; border-radius: 8px; border: 1px solid #e9ecef;">
                    <div style="display: flex; align-items: center; margin-bottom: 8px;">
                        <span style="font-size: 20px; margin-right: 8px;">🛠️</span>
                        <span style="font-weight: 600; color: #2c3e50;">AI-generated & AI-refined</span>
                        <span title="Text likely generated by AI, then refined or altered using AI tools." style="margin-left: 5px; cursor: help; color: #6c757d;">ⓘ</span>
                    </div>
                    <div style="font-size: 24px; font-weight: bold; color: #FFA07A;">
                        {category_scores['ai_refined']*100:.0f}%
                    </div>
                </div>

                <div style="background: white; padding: 15px; border-radius: 8px; border: 1px solid #e9ecef;">
                    <div style="display: flex; align-items: center; margin-bottom: 8px;">
                        <span style="font-size: 20px; margin-right: 8px;">✍️</span>
                        <span style="font-weight: 600; color: #2c3e50;">Human-written & AI-refined</span>
                        <span title="Text likely written by humans, then refined or altered using AI tools." style="margin-left: 5px; cursor: help; color: #6c757d;">ⓘ</span>
                    </div>
                    <div style="font-size: 24px; font-weight: bold; color: #98D8C8;">
                        {category_scores['human_ai_refined']*100:.0f}%
                    </div>
                </div>

                <div style="background: white; padding: 15px; border-radius: 8px; border: 1px solid #e9ecef;">
                    <div style="display: flex; align-items: center; margin-bottom: 8px;">
                        <span style="font-size: 20px; margin-right: 8px;">👤</span>
                        <span style="font-weight: 600; color: #2c3e50;">Human-written</span>
                        <span title="Text likely written by humans without the help of AI or paraphrasing tools." style="margin-left: 5px; cursor: help; color: #6c757d;">ⓘ</span>
                    </div>
                    <div style="font-size: 24px; font-weight: bold; color: #4ECDC4;">
                        {category_scores['human_written']*100:.0f}%
                    </div>
                </div>

            </div>

            <div style="text-align: center; padding: 10px; background: white; border-radius: 8px; border: 1px solid #e9ecef;">
                <div style="font-size: 14px; color: #6c757d; margin-bottom: 5px;">Primary Classification</div>
                <div style="font-size: 18px; font-weight: bold; color: #2c3e50;">{primary_category}</div>
                <div style="font-size: 14px; color: #6c757d;">Confidence: {confidence*100:.0f}% | Processing: {processing_time:.0f}ms</div>
            </div>
        </div>
        """

        return (
            summary_html,
            bar_chart,
            metrics_html,
            f"Text length: {len(text)} characters, {len(text.split())} words"
        )

    except Exception as e:
        return (
            f"❌ Error during analysis: {str(e)}",
            None,
            "",
            "Error"
        )

def batch_analyze_enhanced(file):
    """Enhanced batch analysis with improved formatting"""
    if file is None:
        return "Please upload a text file."

    try:
        content = file.read().decode('utf-8')
        texts = [line.strip() for line in content.split('\n') if line.strip() and len(line.strip()) >= 10]

        if not texts:
            return "No valid texts found in the uploaded file (each line should have at least 10 characters)."

        results = []
        category_counts = {'AI-generated': 0, 'AI-generated & AI-refined': 0, 'Human-written & AI-refined': 0, 'Human-written': 0}
        total_ai_percentage = 0

        for i, text in enumerate(texts[:15]):
            primary_category, category_scores, confidence = detector.classify_text_category(text)
            category_counts[primary_category] += 1

            ai_percentage = (category_scores['ai_generated'] + category_scores['ai_refined']) * 100
            total_ai_percentage += ai_percentage

            results.append(f"""
**Text {i+1}:** {text[:80]}{'...' if len(text) > 80 else ''}  
**Result:** {primary_category} ({confidence:.1%} confidence)  
**AI Content:** {ai_percentage:.0f}% | **Breakdown:** AI-gen: {category_scores['ai_generated']:.0%}, AI-refined: {category_scores['ai_refined']:.0%}, Human+AI: {category_scores['human_ai_refined']:.0%}, Human: {category_scores['human_written']:.0%}
            """)

        avg_ai_percentage = total_ai_percentage / len(results) if results else 0

        summary = f"""
## 📊 Batch Analysis Summary

**Total texts analyzed:** {len(results)}  
**Average AI content:** {avg_ai_percentage:.1f}%

### Category Distribution:
- **AI-generated:** {category_counts['AI-generated']} texts ({category_counts['AI-generated']/len(results)*100:.0f}%)
- **AI-generated & AI-refined:** {category_counts['AI-generated & AI-refined']} texts ({category_counts['AI-generated & AI-refined']/len(results)*100:.0f}%)  
- **Human-written & AI-refined:** {category_counts['Human-written & AI-refined']} texts ({category_counts['Human-written & AI-refined']/len(results)*100:.0f}%)
- **Human-written:** {category_counts['Human-written']} texts ({category_counts['Human-written']/len(results)*100:.0f}%)

---

### Individual Results:
        """

        return summary + "\n".join(results)

    except Exception as e:
        return f"Error processing file: {str(e)}"

# API endpoint for JSON results
def api_analyze_text(text: str) -> Dict:
    """API endpoint that returns JSON results"""
    return detector.get_analysis_json(text)

def create_improved_interface():
    """Create enhanced Gradio interface with improved results display"""

    custom_css = """
    .gradio-container {
        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
        max-width: 1400px;
        margin: 0 auto;
    }
    .gr-button-primary {
        background: linear-gradient(45deg, #667eea 0%, #764ba2 100%);
        border: none;
        border-radius: 8px;
        font-weight: 600;
        padding: 12px 24px;
    }
    .gr-button-primary:hover {
        transform: translateY(-2px);
        box-shadow: 0 8px 25px rgba(102, 126, 234, 0.3);
    }
    .understanding-section {
        background: #f8f9fa;
        border: 1px solid #e9ecef;
        border-radius: 8px;
        padding: 20px;
        margin-top: 20px;
    }
    """

    with gr.Blocks(css=custom_css, title="Advanced AI Text Detector", theme=gr.themes.Soft()) as interface:

        gr.HTML("""
        <div style="text-align: center; padding: 25px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); 
                    color: white; border-radius: 15px; margin-bottom: 25px; box-shadow: 0 10px 30px rgba(0,0,0,0.2);">
            <h1 style="margin-bottom: 10px; font-size: 2.2em; text-shadow: 2px 2px 4px rgba(0,0,0,0.3);">🔍 Advanced AI Text Detector</h1>
            <p style="font-size: 1.1em; margin: 0; opacity: 0.95;">
                Sophisticated 4-category classification with enhanced accuracy and user-friendly results
            </p>
            <p style="font-size: 0.9em; margin-top: 8px; opacity: 0.8;">
                Detects pure AI content, AI-refined text, and human writing with detailed breakdowns
            </p>
        </div>
        """)

        with gr.Tabs() as tabs:

            # Single text analysis tab
            with gr.Tab("🔍 Text Analysis", elem_id="single-analysis"):
                with gr.Row():
                    with gr.Column(scale=1):
                        text_input = gr.Textbox(
                            label="📝 Enter text to analyze",
                            placeholder="Paste your text here (minimum 10 characters for accurate analysis)...",
                            lines=10,
                            max_lines=20,
                            show_label=True
                        )

                        analyze_btn = gr.Button(
                            "🚀 Analyze Text", 
                            variant="primary", 
                            size="lg"
                        )

                        text_info = gr.Textbox(
                            label="📊 Text Information",
                            interactive=False,
                            show_label=True
                        )

                    with gr.Column(scale=1):
                        # Part 1: Summary Score
                        summary_result = gr.HTML(
                            label="📊 Analysis Summary",
                            value="<div style='text-align: center; padding: 20px; color: #6c757d;'>Results will appear here after analysis...</div>"
                        )

                        # Part 2: Bar Chart
                        bar_chart = gr.Plot(
                            label="📈 AI vs Human Distribution",
                            show_label=True
                        )

                        # Part 2: Detailed Metrics
                        detailed_metrics = gr.HTML(
                            label="📋 Detailed Metrics",
                            value=""
                        )

                # Part 3: Understanding Results (Collapsible)
                with gr.Accordion("Understanding Your Results", open=False):
                    gr.HTML("""
                    <div style="padding: 20px; line-height: 1.6;">
                        <h4 style="color: #2c3e50; margin-bottom: 15px;">🎯 How to Interpret Your Results</h4>

                        <p><strong>Our AI detector estimates the likelihood that text was created or modified using AI tools.</strong> 
                        The percentage shows our system's confidence, but it's not a definitive judgment.</p>

                        <h5 style="color: #34495e; margin-top: 20px; margin-bottom: 10px;">📋 Category Explanations:</h5>
                        <ul style="margin-left: 20px;">
                            <li><strong>🤖 AI-generated:</strong> Text that appears to be directly created by AI models like ChatGPT, GPT-4, or Gemini</li>
                            <li><strong>🛠️ AI-generated & AI-refined:</strong> AI-created text that has been further processed or polished using AI tools</li>
                            <li><strong>✍️ Human-written & AI-refined:</strong> Human-authored content that has been enhanced, edited, or refined using AI assistance</li>
                            <li><strong>👤 Human-written:</strong> Text that appears to be written entirely by humans without AI assistance</li>
                        </ul>

                        <h5 style="color: #34495e; margin-top: 20px; margin-bottom: 10px;">⚠️ Important Considerations:</h5>
                        <ul style="margin-left: 20px;">
                            <li><strong>Use your best judgment</strong> when reviewing results - AI detection is not 100% accurate</li>
                            <li><strong>Never rely solely on AI detection</strong> for decisions that could impact someone's career, academic standing, or reputation</li>
                            <li><strong>Consider context:</strong> Short texts (under 50 words) may be less reliable to classify</li>
                            <li><strong>False positives occur:</strong> Human text with formal language may sometimes be flagged as AI-generated</li>
                            <li><strong>Evolving technology:</strong> AI detection accuracy varies as both generation and detection methods improve</li>
                        </ul>

                        <div style="background: #fff3cd; border: 1px solid #ffeaa7; border-radius: 8px; padding: 15px; margin-top: 20px;">
                            <h5 style="color: #856404; margin-bottom: 10px;">💡 Best Practices:</h5>
                            <p style="margin: 0; color: #856404;">
                                Combine AI detection results with manual review, contextual knowledge, and other verification methods. 
                                This tool should support—not replace—human judgment in content evaluation.
                            </p>
                        </div>
                    </div>
                    """)

            # Batch analysis tab  
            with gr.Tab("📄 Batch Analysis", elem_id="batch-analysis"):
                gr.HTML("""
                <div style="background: #e8f4fd; padding: 20px; border-radius: 12px; border-left: 5px solid #2196F3; margin-bottom: 20px;">
                    <h4 style="color: #1565C0; margin-bottom: 15px;">📋 Batch Analysis Instructions</h4>
                    <ul style="color: #1976D2; line-height: 1.6;">
                        <li>Upload a <strong>.txt</strong> file with one text sample per line</li>
                        <li>Each line should contain at least 10 characters for accurate analysis</li> 
                        <li>Maximum 15 texts will be processed to ensure optimal performance</li>
                        <li>Results include category distribution, individual analysis, and summary statistics</li>
                        <li>Larger files may take longer to process - please be patient</li>
                    </ul>
                </div>
                """)

                file_input = gr.File(
                    label="📁 Upload text file (.txt)",
                    file_types=[".txt"],
                    type="binary"
                )

                batch_analyze_btn = gr.Button("🔍 Analyze Batch", variant="primary", size="lg")
                batch_results = gr.Markdown(label="📊 Batch Results")

            # API Documentation tab
            with gr.Tab("🔌 API Access", elem_id="api-docs"):
                gr.Markdown("""
                # 🔌 API Documentation

                This detector provides a JSON API for programmatic access. Perfect for integrating AI detection into your own applications.

                ## 📡 API Endpoint

                **POST** `/api/analyze`

                ```bash
                curl -X POST "your-space-url/api/analyze" \
                     -H "Content-Type: application/json" \
                     -d '{"text": "Your text to analyze here"}'
                ```

                ## 📥 Request Format

                ```json
                {
                    "text": "The text you want to analyze for AI content detection"
                }
                ```

                ## 📤 Response Format

                ```json
                {
                    "ai_percentage": 45.2,
                    "human_percentage": 54.8,
                    "category_scores": {
                        "ai_generated": 30.1,
                        "ai_refined": 15.1,
                        "human_ai_refined": 12.3,
                        "human_written": 42.5
                    },
                    "primary_category": "human_written",
                    "confidence": 85.7,
                    "processing_time_ms": 156.3
                }
                ```

                ## 📋 Response Fields

                - `ai_percentage`: Overall percentage of AI-generated or AI-refined content
                - `human_percentage`: Overall percentage of human-written content  
                - `category_scores`: Breakdown of all 4 detection categories (percentages)
                - `primary_category`: Most likely category for the text
                - `confidence`: Confidence score for the primary category (0-100)
                - `processing_time_ms`: Time taken to analyze the text in milliseconds

                ## 🔧 Integration Examples

                ### Python
                ```python
                import requests
                import json

                def analyze_text(text):
                    url = "your-space-url/api/analyze"
                    data = {"text": text}

                    response = requests.post(url, json=data)
                    return response.json()

                result = analyze_text("Your text here")
                print(f"AI Content: {result['ai_percentage']}%")
                ```

                ### JavaScript
                ```javascript
                async function analyzeText(text) {
                    const response = await fetch('your-space-url/api/analyze', {
                        method: 'POST',
                        headers: { 'Content-Type': 'application/json' },
                        body: JSON.stringify({ text: text })
                    });

                    return await response.json();
                }

                const result = await analyzeText("Your text here");
                console.log(`AI Content: ${result.ai_percentage}%`);
                ```

                ## ⚠️ Usage Guidelines

                - **Rate Limiting**: Please limit requests to avoid overloading the system
                - **Text Length**: Minimum 10 characters, optimal 50+ words for best accuracy  
                - **Language**: Optimized for English text
                - **Reliability**: Use results as guidance, not absolute truth

                """)

            # About tab
            with gr.Tab("ℹ️ About", elem_id="about-tab"):
                gr.Markdown("""
                # 🔍 Advanced AI Text Detector

                ## 🎯 Enhanced 4-Category Classification

                This advanced detector provides nuanced analysis beyond simple AI vs Human classification, offering detailed insights into different types of AI involvement in text creation.

                ### 📋 Detection Categories

                1. **🤖 AI-generated**: Pure AI content from models like ChatGPT, GPT-4, Gemini
                2. **🛠️ AI-generated & AI-refined**: AI content that has been further processed by AI tools
                3. **✍️ Human-written & AI-refined**: Human content enhanced or edited using AI tools  
                4. **👤 Human-written**: Pure human content without AI assistance

                ### 🚀 Key Improvements

                - **Enhanced Results Display**: Clear percentage summary, visual bar chart, and detailed breakdowns
                - **Multi-layered Analysis**: Combines transformer models with linguistic feature analysis
                - **Refinement Detection**: Identifies patterns indicating AI editing/enhancement
                - **Confidence Scoring**: Provides reliability measures for each prediction
                - **JSON API**: Programmatic access for integration with other applications

                ### 📊 Technical Features

                - **Linguistic Feature Analysis**: Examines vocabulary diversity, sentence structure, punctuation patterns
                - **Refinement Pattern Detection**: Identifies signs of AI editing or enhancement  
                - **Transformer Integration**: Uses fine-tuned RoBERTa models for baseline detection
                - **Ensemble Classification**: Combines multiple approaches for robust predictions
                - **Real-time Processing**: Fast analysis with sub-second response times

                ### 🎨 Use Cases

                - **Content Verification**: Verify authenticity of articles, essays, reports
                - **Academic Integrity**: Detect AI assistance in student submissions
                - **Content Moderation**: Identify AI-generated content in social media
                - **Quality Assessment**: Understand the level of AI involvement in text creation
                - **Research & Development**: Analyze AI text patterns for research purposes

                ### ⚡ Performance Characteristics

                - **Accuracy**: 85-95% depending on text length and type
                - **Processing Speed**: < 2 seconds for most texts
                - **Optimal Text Length**: 50+ words for best accuracy
                - **Language Support**: Optimized for English text
                - **API Response**: JSON format for easy integration

                ### 🔬 Methodology

                The detector uses a sophisticated ensemble approach:
                1. Pre-trained transformer model predictions (RoBERTa-based)
                2. Linguistic feature extraction and analysis (31+ features)
                3. AI refinement pattern detection (editing signatures)
                4. Statistical text analysis (perplexity, complexity)
                5. Weighted scoring and normalization

                ### ⚠️ Limitations & Considerations

                - Performance may vary with very short texts (< 50 words)
                - Heavily paraphrased content may be challenging to classify accurately
                - Newer AI models may require periodic detector updates
                - Non-English text may have reduced accuracy
                - False positives can occur with highly formal human writing

                ### 🔄 Continuous Improvement

                This detector is regularly updated to:
                - Adapt to new AI text generation techniques
                - Improve accuracy across different content types
                - Enhance user experience and result interpretation
                - Expand language support and domain coverage

                ---

                **Version**: 2.0.0 | **Updated**: September 2025 | **Model**: RoBERTa-base-openai-detector
                """)

        # Event handlers
        analyze_btn.click(
            fn=analyze_text_enhanced,
            inputs=[text_input],
            outputs=[summary_result, bar_chart, detailed_metrics, text_info]
        )

        batch_analyze_btn.click(
            fn=batch_analyze_enhanced,
            inputs=[file_input],
            outputs=[batch_results]
        )

        # Example texts
        gr.Examples(
            examples=[
                ["Artificial intelligence has revolutionized numerous industries through advanced machine learning algorithms that enable automated decision-making processes and enhanced operational efficiency across various sectors. These technological innovations have transformed traditional workflows and created new opportunities for businesses to optimize their operations."],
                ["I can't believe how incredible this weekend trip was! We drove up to the mountains and the whole experience was just magical. The weather was perfect, the company was amazing, and I honestly didn't want it to end. There's something about being in nature that just makes everything feel right, you know?"],
                ["The implementation of sustainable energy solutions requires comprehensive analysis of environmental factors, economic considerations, and technological feasibility to ensure optimal outcomes for stakeholders. Organizations must carefully evaluate various renewable energy options before making strategic investment decisions."],
                ["Hey Sarah! Thanks for your email about the project timeline. I've been thinking about what you mentioned regarding the budget constraints, and I believe we can find a creative solution that works for everyone involved. Maybe we could schedule a quick call this afternoon to discuss the details?"]
            ],
            inputs=text_input,
            outputs=[summary_result, bar_chart, detailed_metrics, text_info],
            fn=analyze_text_enhanced,
            cache_examples=False
        )

    return interface

# Create FastAPI app for API endpoints
app = FastAPI(title="AI Text Detector API", version="2.0.0")

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

@app.post("/api/analyze")
async def analyze_api(request: dict):
    """API endpoint for text analysis"""
    text = request.get("text", "")
    return api_analyze_text(text)

@app.get("/api/health")
async def health_check():
    """Health check endpoint"""
    return {"status": "healthy", "version": "2.0.0"}

# Launch the interface
if __name__ == "__main__":
    interface = create_improved_interface()
    interface.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=True,
        show_error=True,
        debug=False
    )