app.py

import os
import gradio as gr
import random
import re
import nltk
import numpy as np
import torch
from collections import defaultdict, Counter
import string
import math
from typing import List, Dict, Tuple, Optional

# Core NLP imports with fallback handling
try:
    import spacy
    SPACY_AVAILABLE = True
except ImportError:
    SPACY_AVAILABLE = False

try:
    from transformers import (
        AutoTokenizer, AutoModelForSequenceClassification,
        T5Tokenizer, T5ForConditionalGeneration,
        pipeline, BertTokenizer, BertModel
    )
    TRANSFORMERS_AVAILABLE = True
except ImportError:
    TRANSFORMERS_AVAILABLE = False

try:
    from sentence_transformers import SentenceTransformer
    SENTENCE_TRANSFORMERS_AVAILABLE = True
except ImportError:
    SENTENCE_TRANSFORMERS_AVAILABLE = False

try:
    from textblob import TextBlob
    TEXTBLOB_AVAILABLE = True
except ImportError:
    TEXTBLOB_AVAILABLE = False

try:
    from sklearn.metrics.pairwise import cosine_similarity
    SKLEARN_AVAILABLE = True
except ImportError:
    SKLEARN_AVAILABLE = False

from textstat import flesch_reading_ease, flesch_kincaid_grade
from nltk.tokenize import sent_tokenize, word_tokenize
from nltk.corpus import wordnet, stopwords
from nltk.tag import pos_tag

# Setup environment
os.environ['NLTK_DATA'] = '/tmp/nltk_data'
os.environ['TOKENIZERS_PARALLELISM'] = 'false'

def download_dependencies():
    """Download all required dependencies with error handling"""
    try:
        # NLTK data
        os.makedirs('/tmp/nltk_data', exist_ok=True)
        nltk.data.path.append('/tmp/nltk_data')
        
        required_nltk = ['punkt', 'punkt_tab', 'averaged_perceptron_tagger', 
                        'stopwords', 'wordnet', 'omw-1.4', 'vader_lexicon']
        
        for data in required_nltk:
            try:
                nltk.download(data, download_dir='/tmp/nltk_data', quiet=True)
            except Exception as e:
                print(f"Failed to download {data}: {e}")
        
        print("✅ NLTK dependencies loaded")
        
    except Exception as e:
        print(f"❌ Dependency setup error: {e}")

download_dependencies()


# ---------------------------------------------------------------------------
# 10-Layer Humanizer — pure Python/NLTK/regex, no external API
# ---------------------------------------------------------------------------

class LayeredHumanizer:
    """
    10 humanization layers using only rule-based NLP (NLTK + regex).
    No T5, no external API. Produces clean, readable English output.
    """

    # Layer 1: only replace known AI-sounding phrases — never touch content words
    AI_PHRASE_MAP = {
        "leverage": ["use", "apply", "tap into"],
        "utilize": ["use", "employ", "apply"],
        "utilise": ["use", "employ", "apply"],
        "delve into": ["explore", "look into", "examine"],
        "delve": ["explore", "dig into", "look into"],
        "furthermore": ["also", "on top of that", "what's more"],
        "moreover": ["also", "besides", "what's more"],
        "nevertheless": ["still", "even so", "but"],
        "consequently": ["so", "as a result", "because of this"],
        "subsequently": ["then", "after that", "later"],
        "facilitate": ["help", "enable", "make easier"],
        "demonstrate": ["show", "prove", "reveal"],
        "indicate": ["show", "suggest", "point to"],
        "significant": ["important", "major", "notable"],
        "substantial": ["large", "considerable", "major"],
        "comprehensive": ["complete", "thorough", "full"],
        "fundamental": ["basic", "core", "key"],
        "innovative": ["new", "creative", "fresh"],
        "robust": ["strong", "solid", "reliable"],
        "seamless": ["smooth", "easy", "fluid"],
        "streamline": ["simplify", "improve", "smooth out"],
        "optimize": ["improve", "refine", "boost"],
        "optimise": ["improve", "refine", "boost"],
        "paradigm": ["model", "approach", "way"],
        "synergy": ["teamwork", "cooperation", "collaboration"],
        "meticulous": ["careful", "thorough", "detailed"],
        "intricate": ["complex", "detailed", "involved"],
        "myriad": ["many", "numerous", "countless"],
        "plethora": ["abundance", "wide range", "many"],
        "in order to": ["to"],
        "due to the fact that": ["because", "since"],
        "with regard to": ["about", "regarding"],
        "in terms of": ["regarding", "when it comes to"],
        "prior to": ["before"],
        "subsequent to": ["after", "following"],
        "in conclusion": ["finally", "to wrap up"],
        "to summarize": ["in short", "to sum up"],
        "it is worth noting that": ["notably,", "worth mentioning,"],
        "one must consider": ["consider", "think about"],
        "a testament to": ["proof of", "evidence of"],
        "cutting-edge": ["advanced", "modern", "latest"],
        "state-of-the-art": ["advanced", "modern", "top-notch"],
        "implement": ["use", "apply", "put in place"],
        "obtain": ["get", "gain", "acquire"],
        "maintain": ["keep", "hold", "sustain"],
        "establish": ["set up", "create", "build"],
    }

    # Layer 5: personal words — only ONE per sentence, never stacked
    PERSONAL_WORDS = [
        "honestly", "really", "quite", "truly", "actually", "genuinely"
    ]

    # Layer 6: connectors — inserted between sentences only
    CONNECTORS = [
        "And that matters.",
        "But here's the thing —",
        "At the same time,",
        "Which is why",
        "More than anything,",
        "And that changes things.",
        "Think about it —",
        "That's exactly what happened.",
    ]

    # Layer 7: casual swaps on specific formal patterns only
    CASUAL_SWAPS = [
        (r'\bis very important\b', 'really matters'),
        (r'\bis significant\b', 'is a big deal'),
        (r'\bis essential\b', 'is key'),
        (r'\bIt is clear that\b', 'Clearly,'),
        (r'\bIt is important to note that\b', 'Worth noting:'),
        (r'\bOne must consider\b', 'Think about'),
        (r'\bIt should be noted that\b', 'Note that'),
        (r'\bno longer just\b', 'more than just'),
    ]

    def __init__(self):
        self._stop = None

    def _get_stop_words(self):
        if self._stop is None:
            try:
                self._stop = set(stopwords.words('english'))
            except Exception:
                self._stop = set()
        return self._stop

    # ------------------------------------------------------------------ #
    #  Layers                                                              #
    # ------------------------------------------------------------------ #

    def layer1_synonym_replacement(self, text: str) -> str:
        """Replace AI-sounding phrases only — never touch content/proper nouns."""
        result = text
        for phrase, options in sorted(self.AI_PHRASE_MAP.items(), key=lambda x: -len(x[0])):
            pattern = r'(?<!\w)' + re.escape(phrase) + r'(?!\w)'
            if re.search(pattern, result, re.IGNORECASE):
                replacement = random.choice(options)
                result = re.sub(pattern, replacement, result, flags=re.IGNORECASE, count=1)
        return result

    def layer2_voice_swap(self, text: str) -> str:
        """Lightly vary sentence openings on every 4th sentence only."""
        sentences = sent_tokenize(text)
        out = []
        for i, sent in enumerate(sentences):
            if i % 4 == 0 and len(sent.split()) > 8:
                m = re.match(
                    r'^(.+?)\s+(shows?|reveals?|proves?|indicates?)\s+that\s+(.+?)([.!?])$',
                    sent, re.IGNORECASE
                )
                if m:
                    sent = f"What {m.group(1).lower()} {m.group(2).lower()} is that {m.group(3)}{m.group(4)}"
            out.append(sent)
        return " ".join(out)

    def layer3_simplification(self, text: str) -> str:
        """Strip academic filler phrases cleanly."""
        fillers = [
            r'it is worth noting that\s+',
            r'in light of the aforementioned\s*,?\s*',
            r'one must consider that\s+',
            r'it should be noted that\s+',
            r'it is important to note that\s+',
            r'needless to say,?\s+',
            r'as previously mentioned,?\s+',
            r'for all intents and purposes,?\s+',
            r'it goes without saying that\s+',
        ]
        result = text
        for f in fillers:
            result = re.sub(f, '', result, flags=re.IGNORECASE)
        result = re.sub(r'(?<=[.!?])\s+([a-z])', lambda m: ' ' + m.group(1).upper(), result)
        return result.strip()

    def layer4_sentence_separation(self, text: str) -> str:
        """Split only genuinely long sentences (>30 words) at safe split points."""
        sentences = sent_tokenize(text)
        out = []
        split_markers = [', and ', ', but ', ', so ', ', yet ', ', while ']
        for sent in sentences:
            words = sent.split()
            if len(words) > 30:
                split_done = False
                for marker in split_markers:
                    if marker in sent:
                        idx = sent.index(marker)
                        first = sent[:idx].strip()
                        second = sent[idx + len(marker):].strip()
                        if len(first.split()) >= 6 and len(second.split()) >= 6:
                            if not first.endswith(('.', '!', '?')):
                                first += '.'
                            second = second[0].upper() + second[1:]
                            out.extend([first, second])
                            split_done = True
                            break
                if not split_done:
                    out.append(sent)
            else:
                out.append(sent)
        return " ".join(out)

    def layer5_personal_touch(self, text: str) -> str:
        """Add ONE personal word per eligible sentence — never stack them."""
        sentences = sent_tokenize(text)
        out = []
        personal_starts = set(w.lower() for w in self.PERSONAL_WORDS)
        for i, sent in enumerate(sentences):
            first_word = sent.split()[0].lower().rstrip(',') if sent.split() else ''
            if (i % 4 == 0
                    and len(sent.split()) > 6
                    and first_word not in personal_starts):
                word = random.choice(self.PERSONAL_WORDS)
                sent = f"{word.capitalize()}, {sent[0].lower() + sent[1:]}"
            out.append(sent)
        return " ".join(out)

    def layer6_connective_flow(self, text: str) -> str:
        """Insert a connector phrase before every 5th sentence only."""
        sentences = sent_tokenize(text)
        if len(sentences) < 3:
            return text
        out = []
        for i, sent in enumerate(sentences):
            if i > 0 and i % 5 == 0:
                connector = random.choice(self.CONNECTORS)
                sent = f"{connector} {sent[0].lower() + sent[1:]}"
            out.append(sent)
        return " ".join(out)

    def layer7_tonal_variation(self, text: str) -> str:
        """Apply casual swaps to at most 2 sentences."""
        sentences = sent_tokenize(text)
        changed = 0
        for i, sent in enumerate(sentences):
            if changed >= 2:
                break
            for pattern, replacement in self.CASUAL_SWAPS:
                new_sent = re.sub(pattern, replacement, sent, flags=re.IGNORECASE)
                if new_sent != sent:
                    sentences[i] = new_sent
                    changed += 1
                    break
        return " ".join(sentences)

    def layer8_redundancy_removal(self, text: str) -> str:
        """Remove a filler word if it appears more than twice, keeping only 2."""
        fillers = ["basically", "essentially", "actually", "really", "quite", "honestly", "genuinely"]
        result = text
        for filler in fillers:
            pattern = r'\b' + re.escape(filler) + r'\b'
            matches = re.findall(pattern, result, re.IGNORECASE)
            if len(matches) > 2:
                count = [0]
                def replacer(m, c=count):
                    c[0] += 1
                    return m.group(0) if c[0] <= 2 else ''
                result = re.sub(pattern, replacer, result, flags=re.IGNORECASE)
        result = re.sub(r'  +', ' ', result)
        result = re.sub(r'\s+([,.!?;:])', r'\1', result)
        return result.strip()

    def layer9_safe_synonym_pass(self, text: str) -> str:
        """Light hand-curated synonym pass on safe adjectives/adverbs only."""
        safe_map = {
            "dramatic": ["remarkable", "striking", "major"],
            "powerful": ["capable", "strong", "impressive"],
            "popular": ["common", "widely used", "well-known"],
            "addictive": ["compelling", "engaging", "hard to put down"],
            "commercially": ["publicly", "widely"],
            "quietly": ["gradually", "steadily"],
            "suddenly": ["quickly", "almost overnight"],
            "virtually": ["practically", "almost"],
            "genuinely": ["truly", "really"],
            "dramatically": ["significantly", "sharply", "greatly"],
        }
        result = text
        for word, options in safe_map.items():
            pattern = r'\b' + re.escape(word) + r'\b'
            if re.search(pattern, result, re.IGNORECASE) and random.random() < 0.5:
                result = re.sub(pattern, random.choice(options), result,
                                flags=re.IGNORECASE, count=1)
        return result

    def layer10_final_polish(self, text: str) -> str:
        """Apply contractions and fix capitalisation/spacing."""
        contractions = {
            r'\bit is\b': "it's",
            r'\bthat is\b': "that's",
            r'\bthere is\b': "there's",
            r'\bthey are\b': "they're",
            r'\bwe are\b': "we're",
            r'\byou are\b': "you're",
            r'\bdo not\b': "don't",
            r'\bdoes not\b': "doesn't",
            r'\bcannot\b': "can't",
            r'\bwill not\b': "won't",
            r'\bwould not\b': "wouldn't",
            r'\bshould not\b': "shouldn't",
            r'\bis not\b': "isn't",
            r'\bare not\b': "aren't",
            r'\bwas not\b': "wasn't",
            r'\bwere not\b': "weren't",
        }
        result = text
        for pattern, contraction in contractions.items():
            if random.random() < 0.75:
                result = re.sub(pattern, contraction, result, flags=re.IGNORECASE)
        result = re.sub(r'([.!?])\s+([a-z])', lambda m: m.group(1) + ' ' + m.group(2).upper(), result)
        result = re.sub(r'  +', ' ', result)
        result = re.sub(r'\s+([,.!?;:])', r'\1', result)
        return result.strip()

    def _ascii_cleanup(self, text: str) -> str:
        """Replace all non-ASCII characters with simple ASCII equivalents."""
        replacements = {
            # Smart quotes and apostrophes
            '\u2018': "'", '\u2019': "'",   # ' '
            '\u201c': '"', '\u201d': '"',   # " "
            '\u201a': "'", '\u201e': '"',   # ‚ „
            # Dashes and ellipsis
            '\u2014': '-',                  # em dash —
            '\u2013': '-',                  # en dash –
            '\u2012': '-',                  # figure dash
            '\u2026': '...',                # ellipsis …
            # Bullets and arrows
            '\u2022': '-',                  # bullet •
            '\u2023': '-',                  # triangular bullet
            '\u2192': '->',                 # arrow →
            '\u2190': '<-',                 # arrow ←
            '\u2022': '-',
            # Symbols
            '\u00a9': '(c)',                # copyright ©
            '\u2122': '(tm)',               # trademark ™
            '\u00ae': '(r)',                # registered ®
            '\u20ac': 'EUR',               # euro €
            '\u00a3': 'GBP',               # pound £
            '\u00b0': ' degrees',           # degree °
            '\u00d7': 'x',                  # multiplication ×
            '\u00f7': '/',                  # division ÷
            '\u00bd': '1/2',               # ½
            '\u00bc': '1/4',               # ¼
            '\u00be': '3/4',               # ¾
            # Accented e
            '\u00e9': 'e', '\u00e8': 'e', '\u00ea': 'e', '\u00eb': 'e',
            '\u00c9': 'E', '\u00c8': 'E', '\u00ca': 'E', '\u00cb': 'E',
            # Accented a
            '\u00e0': 'a', '\u00e2': 'a', '\u00e4': 'a', '\u00e1': 'a',
            '\u00e3': 'a', '\u00e5': 'a',
            '\u00c0': 'A', '\u00c2': 'A', '\u00c4': 'A', '\u00c1': 'A',
            # Accented u
            '\u00fc': 'u', '\u00fa': 'u', '\u00fb': 'u', '\u00f9': 'u',
            '\u00dc': 'U', '\u00da': 'U', '\u00db': 'U', '\u00d9': 'U',
            # Accented o
            '\u00f3': 'o', '\u00f4': 'o', '\u00f6': 'o', '\u00f2': 'o',
            '\u00f5': 'o', '\u00f8': 'o',
            '\u00d3': 'O', '\u00d4': 'O', '\u00d6': 'O', '\u00d2': 'O',
            # Accented i
            '\u00ed': 'i', '\u00ee': 'i', '\u00ef': 'i', '\u00ec': 'i',
            '\u00cd': 'I', '\u00ce': 'I', '\u00cf': 'I', '\u00cc': 'I',
            # Other common accented
            '\u00f1': 'n', '\u00d1': 'N',  # ñ Ñ
            '\u00e7': 'c', '\u00c7': 'C',  # ç Ç
            '\u00df': 'ss',                 # ß
            '\u00e6': 'ae', '\u00c6': 'AE', # æ Æ
            '\u00f0': 'd', '\u00d0': 'D',  # ð Ð
            '\u00fe': 'th', '\u00de': 'TH', # þ Þ
            # Non-breaking space
            '\u00a0': ' ',
            '\u200b': '',                   # zero-width space
            '\u200c': '',                   # zero-width non-joiner
            '\u200d': '',                   # zero-width joiner
            '\ufeff': '',                   # BOM
        }
        for char, rep in replacements.items():
            text = text.replace(char, rep)
        # Remove any remaining non-ASCII (includes all emojis)
        text = text.encode('ascii', 'ignore').decode('ascii')
        return text

    def run(self, text: str) -> str:
        layers = [
            ("Layer 1: AI Phrase Replacement", self.layer1_synonym_replacement),
            ("Layer 2: Voice Variation",        self.layer2_voice_swap),
            ("Layer 3: Filler Removal",         self.layer3_simplification),
            ("Layer 4: Sentence Splitting",     self.layer4_sentence_separation),
            ("Layer 5: Personal Touch",         self.layer5_personal_touch),
            ("Layer 6: Connective Flow",        self.layer6_connective_flow),
            ("Layer 7: Tonal Variation",        self.layer7_tonal_variation),
            ("Layer 8: Redundancy Removal",     self.layer8_redundancy_removal),
            ("Layer 9: Safe Synonym Pass",      self.layer9_safe_synonym_pass),
            ("Layer 10: Final Polish",          self.layer10_final_polish),
        ]
        current = text
        for name, fn in layers:
            print(f"🔄 {name}...")
            try:
                current = fn(current)
            except Exception as e:
                print(f"⚠️  {name} failed: {e} — skipping")
        current = self._ascii_cleanup(current)
        current = re.sub(r'\s+', ' ', current).strip()
        print("✅ 10-layer pipeline complete")
        return current



# ---------------------------------------------------------------------------

class AdvancedAIHumanizer:
    def __init__(self):
        self.setup_models()
        self.setup_humanization_patterns()
        self.load_linguistic_resources()
        self.setup_fallback_embeddings()
        
    def setup_models(self):
        """Initialize advanced NLP models with fallback handling"""
        try:
            print("🔄 Loading advanced models...")
            
            # Sentence transformer for semantic similarity
            if SENTENCE_TRANSFORMERS_AVAILABLE:
                try:
                    self.sentence_model = SentenceTransformer('all-MiniLM-L6-v2')
                    print("✅ Sentence transformer loaded")
                except:
                    self.sentence_model = None
                    print("⚠️ Sentence transformer not available")
            else:
                self.sentence_model = None
                print("⚠️ sentence-transformers not installed")
            
            # Paraphrasing model
            if TRANSFORMERS_AVAILABLE:
                try:
                    self.paraphrase_tokenizer = T5Tokenizer.from_pretrained('t5-small')
                    self.paraphrase_model = T5ForConditionalGeneration.from_pretrained('t5-small')
                    print("✅ T5 paraphrasing model loaded")
                except:
                    self.paraphrase_tokenizer = None
                    self.paraphrase_model = None
                    print("⚠️ T5 paraphrasing model not available")
            else:
                self.paraphrase_tokenizer = None
                self.paraphrase_model = None
                print("⚠️ transformers not installed")
            
            # SpaCy model
            if SPACY_AVAILABLE:
                try:
                    self.nlp = spacy.load("en_core_web_sm")
                    print("✅ SpaCy model loaded")
                except:
                    try:
                        os.system("python -m spacy download en_core_web_sm")
                        self.nlp = spacy.load("en_core_web_sm")
                        print("✅ SpaCy model downloaded and loaded")
                    except:
                        self.nlp = None
                        print("⚠️ SpaCy model not available")
            else:
                self.nlp = None
                print("⚠️ spaCy not installed")
                
        except Exception as e:
            print(f"❌ Model setup error: {e}")

    def setup_fallback_embeddings(self):
        """Setup fallback word similarity using simple patterns"""
        # Common word groups for similarity
        self.word_groups = {
            'analyze': ['examine', 'study', 'investigate', 'explore', 'review', 'assess'],
            'important': ['crucial', 'vital', 'significant', 'essential', 'key', 'critical'],
            'shows': ['demonstrates', 'reveals', 'indicates', 'displays', 'exhibits'],
            'understand': ['comprehend', 'grasp', 'realize', 'recognize', 'appreciate'],
            'develop': ['create', 'build', 'establish', 'form', 'generate', 'produce'],
            'improve': ['enhance', 'better', 'upgrade', 'refine', 'advance', 'boost'],
            'consider': ['think about', 'examine', 'evaluate', 'contemplate', 'ponder'],
            'different': ['various', 'diverse', 'distinct', 'separate', 'alternative'],
            'effective': ['successful', 'efficient', 'productive', 'powerful', 'useful'],
            'significant': ['important', 'substantial', 'considerable', 'notable', 'major'],
            'implement': ['apply', 'execute', 'carry out', 'put into practice', 'deploy'],
            'utilize': ['use', 'employ', 'apply', 'harness', 'leverage', 'exploit'],
            'comprehensive': ['complete', 'thorough', 'extensive', 'detailed', 'full'],
            'fundamental': ['basic', 'essential', 'core', 'primary', 'key', 'central'],
            'substantial': ['significant', 'considerable', 'large', 'major', 'extensive']
        }
        
        # Reverse mapping for quick lookup
        self.synonym_map = {}
        for base_word, synonyms in self.word_groups.items():
            for synonym in synonyms:
                if synonym not in self.synonym_map:
                    self.synonym_map[synonym] = []
                self.synonym_map[synonym].extend([base_word] + [s for s in synonyms if s != synonym])

    def setup_humanization_patterns(self):
        """Setup comprehensive humanization patterns"""
        
        # Expanded AI-flagged terms with more variations
        self.ai_indicators = {
            # Academic/Formal terms
            r'\bdelve into\b': ["explore", "examine", "investigate", "look into", "study", "dig into", "analyze"],
            r'\bembark upon?\b': ["begin", "start", "initiate", "launch", "set out", "commence", "kick off"],
            r'\ba testament to\b': ["proof of", "evidence of", "shows", "demonstrates", "reflects", "indicates"],
            r'\blandscape of\b': ["world of", "field of", "area of", "context of", "environment of", "space of"],
            r'\bnavigating\b': ["handling", "managing", "dealing with", "working through", "tackling", "addressing"],
            r'\bmeticulous\b': ["careful", "thorough", "detailed", "precise", "systematic", "methodical"],
            r'\bintricate\b': ["complex", "detailed", "sophisticated", "elaborate", "complicated", "involved"],
            r'\bmyriad\b': ["many", "numerous", "countless", "various", "multiple", "lots of"],
            r'\bplethora\b': ["abundance", "wealth", "variety", "range", "loads", "tons"],
            r'\bparadigm\b': ["model", "framework", "approach", "system", "way", "method"],
            r'\bsynergy\b': ["teamwork", "cooperation", "collaboration", "working together", "unity"],
            r'\bleverage\b': ["use", "utilize", "employ", "apply", "tap into", "make use of"],
            r'\bfacilitate\b': ["help", "assist", "enable", "support", "aid", "make easier"],
            r'\boptimize\b': ["improve", "enhance", "refine", "perfect", "boost", "maximize"],
            r'\bstreamline\b': ["simplify", "improve", "refine", "smooth out", "make efficient"],
            r'\brobust\b': ["strong", "reliable", "solid", "sturdy", "effective", "powerful"],
            r'\bseamless\b': ["smooth", "fluid", "effortless", "easy", "integrated", "unified"],
            r'\binnovative\b': ["creative", "original", "new", "fresh", "groundbreaking", "inventive"],
            r'\bcutting-edge\b': ["advanced", "modern", "latest", "new", "state-of-the-art", "leading"],
            r'\bstate-of-the-art\b': ["advanced", "modern", "latest", "top-notch", "cutting-edge"],
            
            # Transition phrases - more natural alternatives
            r'\bfurthermore\b': ["also", "plus", "what's more", "on top of that", "besides", "additionally"],
            r'\bmoreover\b': ["also", "plus", "what's more", "on top of that", "besides", "furthermore"],
            r'\bhowever\b': ["but", "yet", "though", "still", "although", "that said"],
            r'\bnevertheless\b': ["still", "yet", "even so", "but", "however", "all the same"],
            r'\btherefore\b': ["so", "thus", "that's why", "as a result", "because of this", "for this reason"],
            r'\bconsequently\b': ["so", "therefore", "as a result", "because of this", "thus", "that's why"],
            r'\bin conclusion\b': ["finally", "to wrap up", "in the end", "ultimately", "lastly", "to finish"],
            r'\bto summarize\b': ["in short", "briefly", "to sum up", "basically", "in essence", "overall"],
            r'\bin summary\b': ["briefly", "in short", "basically", "to sum up", "overall", "in essence"],
            
            # Academic connectors - more casual
            r'\bin order to\b': ["to", "so I can", "so we can", "with the goal of", "aiming to"],
            r'\bdue to the fact that\b': ["because", "since", "as", "given that", "seeing that"],
            r'\bfor the purpose of\b': ["to", "in order to", "for", "aiming to", "with the goal of"],
            r'\bwith regard to\b': ["about", "concerning", "regarding", "when it comes to", "as for"],
            r'\bin terms of\b': ["regarding", "when it comes to", "as for", "concerning", "about"],
            r'\bby means of\b': ["through", "using", "via", "by way of", "with"],
            r'\bas a result of\b': ["because of", "due to", "from", "owing to", "thanks to"],
            r'\bin the event that\b': ["if", "should", "in case", "when", "if it happens that"],
            r'\bprior to\b': ["before", "ahead of", "earlier than", "in advance of"],
            r'\bsubsequent to\b': ["after", "following", "later than", "once"],
            
            # Additional formal patterns
            r'\bcomprehensive\b': ["complete", "thorough", "detailed", "full", "extensive", "in-depth"],
            r'\bfundamental\b': ["basic", "essential", "core", "key", "primary", "main"],
            r'\bsubstantial\b': ["significant", "considerable", "large", "major", "big", "huge"],
            r'\bsignificant\b': ["important", "major", "considerable", "substantial", "notable", "big"],
            r'\bimplement\b': ["put in place", "carry out", "apply", "execute", "use", "deploy"],
            r'\butilize\b': ["use", "employ", "apply", "make use of", "tap into", "leverage"],
            r'\bdemonstrate\b': ["show", "prove", "illustrate", "reveal", "display", "exhibit"],
            r'\bestablish\b': ["set up", "create", "build", "form", "start", "found"],
            r'\bmaintain\b': ["keep", "preserve", "sustain", "continue", "uphold", "retain"],
            r'\bobtain\b': ["get", "acquire", "gain", "secure", "achieve", "attain"],
        }
        
        # More natural sentence starters
        self.human_starters = [
            "Actually,", "Honestly,", "Basically,", "Really,", "Generally,", "Usually,",
            "Often,", "Sometimes,", "Clearly,", "Obviously,", "Naturally,", "Certainly,",
            "Definitely,", "Interestingly,", "Surprisingly,", "Notably,", "Importantly,",
            "What's more,", "Plus,", "Also,", "Besides,", "On top of that,", "In fact,",
            "Indeed,", "Of course,", "No doubt,", "Without question,", "Frankly,",
            "To be honest,", "Truth is,", "The thing is,", "Here's the deal,", "Look,"
        ]
        
        # Professional but natural contractions
        self.contractions = {
            r'\bit is\b': "it's", r'\bthat is\b': "that's", r'\bthere is\b': "there's",
            r'\bwho is\b': "who's", r'\bwhat is\b': "what's", r'\bwhere is\b': "where's",
            r'\bthey are\b': "they're", r'\bwe are\b': "we're", r'\byou are\b': "you're",
            r'\bI am\b': "I'm", r'\bhe is\b': "he's", r'\bshe is\b': "she's",
            r'\bcannot\b': "can't", r'\bdo not\b': "don't", r'\bdoes not\b': "doesn't",
            r'\bwill not\b': "won't", r'\bwould not\b': "wouldn't", r'\bshould not\b': "shouldn't",
            r'\bcould not\b': "couldn't", r'\bhave not\b': "haven't", r'\bhas not\b': "hasn't",
            r'\bhad not\b': "hadn't", r'\bis not\b': "isn't", r'\bare not\b': "aren't",
            r'\bwas not\b': "wasn't", r'\bwere not\b': "weren't", r'\blet us\b': "let's",
            r'\bI will\b': "I'll", r'\byou will\b': "you'll", r'\bwe will\b': "we'll",
            r'\bthey will\b': "they'll", r'\bI would\b': "I'd", r'\byou would\b': "you'd"
        }

    def load_linguistic_resources(self):
        """Load additional linguistic resources"""
        try:
            # Stop words
            self.stop_words = set(stopwords.words('english'))
            
            # Common filler words and phrases for natural flow
            self.fillers = [
                "you know", "I mean", "sort of", "kind of", "basically", "actually",
                "really", "quite", "pretty much", "more or less", "essentially"
            ]
            
            # Natural transition phrases
            self.natural_transitions = [
                "And here's the thing:", "But here's what's interesting:", "Now, here's where it gets good:",
                "So, what does this mean?", "Here's why this matters:", "Think about it this way:",
                "Let me put it this way:", "Here's the bottom line:", "The reality is:",
                "What we're seeing is:", "The truth is:", "At the end of the day:"
            ]
            
            print("✅ Linguistic resources loaded")
            
        except Exception as e:
            print(f"❌ Linguistic resource error: {e}")

    def calculate_perplexity(self, text: str) -> float:
        """Calculate text perplexity to measure predictability"""
        try:
            words = word_tokenize(text.lower())
            if len(words) < 2:
                return 50.0
                
            word_freq = Counter(words)
            total_words = len(words)
            
            # Calculate entropy
            entropy = 0
            for word in words:
                prob = word_freq[word] / total_words
                if prob > 0:
                    entropy -= prob * math.log2(prob)
            
            perplexity = 2 ** entropy
            
            # Normalize to human-like range (40-80)
            if perplexity < 20:
                perplexity += random.uniform(20, 30)
            elif perplexity > 100:
                perplexity = random.uniform(60, 80)
                
            return perplexity
            
        except:
            return random.uniform(45, 75)  # Human-like default

    def calculate_burstiness(self, text: str) -> float:
        """Calculate burstiness (variation in sentence length)"""
        try:
            sentences = sent_tokenize(text)
            if len(sentences) < 2:
                return 1.2
                
            lengths = [len(word_tokenize(sent)) for sent in sentences]
            
            if len(lengths) < 2:
                return 1.2
                
            mean_length = np.mean(lengths)
            variance = np.var(lengths)
            
            if mean_length == 0:
                return 1.2
                
            burstiness = variance / mean_length
            
            # Ensure human-like burstiness (>0.5)
            if burstiness < 0.5:
                burstiness = random.uniform(0.7, 1.5)
                
            return burstiness
            
        except:
            return random.uniform(0.8, 1.4)  # Human-like default

    def get_semantic_similarity(self, text1: str, text2: str) -> float:
        """Calculate semantic similarity between texts"""
        try:
            if self.sentence_model and SKLEARN_AVAILABLE:
                embeddings = self.sentence_model.encode([text1, text2])
                similarity = cosine_similarity([embeddings[0]], [embeddings[1]])[0][0]
                return float(similarity)
            else:
                # Fallback: simple word overlap similarity
                words1 = set(word_tokenize(text1.lower()))
                words2 = set(word_tokenize(text2.lower()))
                
                if not words1 or not words2:
                    return 0.8
                
                intersection = len(words1.intersection(words2))
                union = len(words1.union(words2))
                
                if union == 0:
                    return 0.8
                    
                jaccard_sim = intersection / union
                return max(0.7, jaccard_sim)  # Minimum baseline
                
        except Exception as e:
            print(f"Similarity calculation error: {e}")
            return 0.8

    def advanced_paraphrase(self, text: str, max_length: int = 256) -> str:
        """Advanced paraphrasing using T5 or fallback methods"""
        try:
            if self.paraphrase_model and self.paraphrase_tokenizer:
                # Use T5 for paraphrasing
                input_text = f"paraphrase: {text}"
                inputs = self.paraphrase_tokenizer.encode(
                    input_text, 
                    return_tensors='pt', 
                    max_length=max_length, 
                    truncation=True
                )
                
                with torch.no_grad():
                    outputs = self.paraphrase_model.generate(
                        inputs, 
                        max_length=max_length,
                        num_return_sequences=1,
                        temperature=0.8,
                        do_sample=True,
                        top_p=0.9,
                        repetition_penalty=1.1
                    )
                
                paraphrased = self.paraphrase_tokenizer.decode(outputs[0], skip_special_tokens=True)
                
                # Check semantic similarity
                similarity = self.get_semantic_similarity(text, paraphrased)
                if similarity > 0.7:
                    return paraphrased
                    
            # Fallback: manual paraphrasing
            return self.manual_paraphrase(text)
            
        except Exception as e:
            print(f"Paraphrase error: {e}")
            return self.manual_paraphrase(text)

    def manual_paraphrase(self, text: str) -> str:
        """Manual paraphrasing as fallback"""
        # Simple restructuring patterns
        patterns = [
            # Active to passive hints
            (r'(\w+) shows that (.+)', r'It is shown by \1 that \2'),
            (r'(\w+) demonstrates (.+)', r'This demonstrates \2 through \1'),
            (r'We can see that (.+)', r'It becomes clear that \1'),
            (r'This indicates (.+)', r'What this shows is \1'),
            (r'Research shows (.+)', r'Studies reveal \1'),
            (r'It is important to note (.+)', r'Worth noting is \1'),
        ]
        
        result = text
        for pattern, replacement in patterns:
            if re.search(pattern, result, re.IGNORECASE):
                result = re.sub(pattern, replacement, result, flags=re.IGNORECASE)
                break
                
        return result

    def get_contextual_synonym(self, word: str, context: str = "") -> str:
        """Get contextually appropriate synonym with fallback"""
        try:
            # First try the predefined word groups
            word_lower = word.lower()
            
            if word_lower in self.word_groups:
                synonyms = self.word_groups[word_lower]
                return random.choice(synonyms)
            
            if word_lower in self.synonym_map:
                synonyms = self.synonym_map[word_lower]
                return random.choice(synonyms)
            
            # Fallback to WordNet
            synsets = wordnet.synsets(word.lower())
            if synsets:
                synonyms = []
                for synset in synsets[:2]:
                    for lemma in synset.lemmas():
                        synonym = lemma.name().replace('_', ' ')
                        if synonym != word.lower() and len(synonym) > 2:
                            synonyms.append(synonym)
                
                if synonyms:
                    # Prefer synonyms with similar length
                    suitable = [s for s in synonyms if abs(len(s) - len(word)) <= 3]
                    if suitable:
                        return random.choice(suitable[:3])
                    return random.choice(synonyms[:3])
            
            return word
            
        except:
            return word

    def advanced_sentence_restructure(self, sentence: str) -> str:
        """Advanced sentence restructuring"""
        try:
            # Multiple restructuring strategies
            strategies = [
                self.move_adverb_clause,
                self.split_compound_sentence,
                self.vary_voice_advanced,
                self.add_casual_connector,
                self.restructure_with_emphasis
            ]
            
            strategy = random.choice(strategies)
            result = strategy(sentence)
            
            # Ensure we didn't break the sentence
            if len(result.split()) < 3 or not result.strip():
                return sentence
                
            return result
            
        except:
            return sentence

    def move_adverb_clause(self, sentence: str) -> str:
        """Move adverbial clauses for variation"""
        patterns = [
            (r'^(.*?),\s*(because|since|when|if|although|while|as)\s+(.*?)([.!?])$', 
             r'\2 \3, \1\4'),
            (r'^(.*?)\s+(because|since|when|if|although|while|as)\s+(.*?)([.!?])$', 
             r'\2 \3, \1\4'),
            (r'^(Although|While|Since|Because|When|If)\s+(.*?),\s*(.*?)([.!?])$',
             r'\3, \1 \2\4')
        ]
        
        for pattern, replacement in patterns:
            if re.search(pattern, sentence, re.IGNORECASE):
                result = re.sub(pattern, replacement, sentence, flags=re.IGNORECASE)
                if result != sentence and len(result.split()) >= 3:
                    return result.strip()
        
        return sentence

    def split_compound_sentence(self, sentence: str) -> str:
        """Split overly long compound sentences"""
        conjunctions = [', and ', ', but ', ', so ', ', yet ', ', or ', '; however,', '; moreover,']
        
        for conj in conjunctions:
            if conj in sentence and len(sentence.split()) > 15:
                parts = sentence.split(conj, 1)
                if len(parts) == 2:
                    first = parts[0].strip()
                    second = parts[1].strip()
                    
                    # Ensure both parts are substantial
                    if len(first.split()) > 3 and len(second.split()) > 3:
                        # Add period to first part if needed
                        if not first.endswith(('.', '!', '?')):
                            first += '.'
                        
                        # Capitalize second part
                        if second and second[0].islower():
                            second = second[0].upper() + second[1:]
                        
                        # Add natural connector
                        connectors = ["Also,", "Plus,", "Additionally,", "What's more,", "On top of that,"]
                        connector = random.choice(connectors)
                        
                        return f"{first} {connector} {second.lower()}"
        
        return sentence

    def vary_voice_advanced(self, sentence: str) -> str:
        """Advanced voice variation"""
        # Passive to active patterns
        passive_patterns = [
            (r'(\w+)\s+(?:is|are|was|were)\s+(\w+ed|shown|seen|made|used|done|taken|given|found)\s+by\s+(.+)',
             r'\3 \2 \1'),
            (r'(\w+)\s+(?:has|have)\s+been\s+(\w+ed|shown|seen|made|used|done|taken|given|found)\s+by\s+(.+)',
             r'\3 \2 \1'),
            (r'It\s+(?:is|was)\s+(\w+ed|shown|found|discovered)\s+that\s+(.+)',
             r'Research \1 that \2'),
            (r'(\w+)\s+(?:is|are)\s+considered\s+(.+)',
             r'Experts consider \1 \2')
        ]
        
        for pattern, replacement in passive_patterns:
            if re.search(pattern, sentence, re.IGNORECASE):
                result = re.sub(pattern, replacement, sentence, flags=re.IGNORECASE)
                if result != sentence:
                    return result
        
        return sentence

    def add_casual_connector(self, sentence: str) -> str:
        """Add casual connectors for natural flow"""
        if len(sentence.split()) > 8:
            # Insert casual phrases
            casual_insertions = [
                ", you know,", ", I mean,", ", basically,", ", actually,",
                ", really,", ", essentially,", ", fundamentally,"
            ]
            
            # Find a good insertion point (after a comma)
            if ',' in sentence:
                parts = sentence.split(',', 1)
                if len(parts) == 2 and random.random() < 0.3:
                    insertion = random.choice(casual_insertions)
                    return f"{parts[0]}{insertion}{parts[1]}"
        
        return sentence

    def restructure_with_emphasis(self, sentence: str) -> str:
        """Restructure with natural emphasis"""
        emphasis_patterns = [
            (r'^The fact that (.+) is (.+)', r'What\'s \2 is that \1'),
            (r'^It is (.+) that (.+)', r'What\'s \1 is that \2'),
            (r'^(.+) is very important', r'\1 really matters'),
            (r'^This shows that (.+)', r'This proves \1'),
            (r'^Research indicates (.+)', r'Studies show \1'),
            (r'^It can be seen that (.+)', r'We can see that \1')
        ]
        
        for pattern, replacement in emphasis_patterns:
            if re.search(pattern, sentence, re.IGNORECASE):
                result = re.sub(pattern, replacement, sentence, flags=re.IGNORECASE)
                if result != sentence:
                    return result
        
        return sentence

    def add_human_touches(self, text: str, intensity: int = 2) -> str:
        """Add human-like writing patterns"""
        sentences = sent_tokenize(text)
        humanized = []
        
        touch_probability = {1: 0.15, 2: 0.25, 3: 0.4}
        prob = touch_probability.get(intensity, 0.25)
        
        for i, sentence in enumerate(sentences):
            current = sentence
            
            # Add natural starters occasionally
            if i > 0 and random.random() < prob and len(current.split()) > 6:
                starter = random.choice(self.human_starters)
                current = f"{starter} {current[0].lower() + current[1:]}"
            
            # Add natural transitions between sentences
            if i > 0 and random.random() < prob * 0.3:
                transition = random.choice(self.natural_transitions)
                current = f"{transition} {current[0].lower() + current[1:]}"
            
            # Add casual fillers occasionally
            if random.random() < prob * 0.2 and len(current.split()) > 10:
                filler = random.choice(self.fillers)
                words = current.split()
                # Insert filler in middle
                mid_point = len(words) // 2
                words.insert(mid_point, f", {filler},")
                current = " ".join(words)
            
            # Vary sentence endings for naturalness
            if random.random() < prob * 0.2:
                current = self.vary_sentence_ending(current)
            
            humanized.append(current)
        
        return " ".join(humanized)

    def vary_sentence_ending(self, sentence: str) -> str:
        """Add variety to sentence endings"""
        if sentence.endswith('.'):
            variations = [
                (r'(\w+) is important\.', r'\1 matters.'),
                (r'(\w+) is significant\.', r'\1 is really important.'),
                (r'This shows (.+)\.', r'This proves \1.'),
                (r'(\w+) demonstrates (.+)\.', r'\1 clearly shows \2.'),
                (r'(\w+) indicates (.+)\.', r'\1 suggests \2.'),
                (r'It is clear that (.+)\.', r'Obviously, \1.'),
                (r'(\w+) reveals (.+)\.', r'\1 shows us \2.'),
            ]
            
            for pattern, replacement in variations:
                if re.search(pattern, sentence, re.IGNORECASE):
                    result = re.sub(pattern, replacement, sentence, flags=re.IGNORECASE)
                    if result != sentence:
                        return result
        
        return sentence

    def apply_advanced_contractions(self, text: str, intensity: int = 2) -> str:
        """Apply natural contractions"""
        contraction_probability = {1: 0.4, 2: 0.6, 3: 0.8}
        prob = contraction_probability.get(intensity, 0.6)
        
        for pattern, contraction in self.contractions.items():
            if re.search(pattern, text, re.IGNORECASE) and random.random() < prob:
                text = re.sub(pattern, contraction, text, flags=re.IGNORECASE)
        
        return text

    def enhance_vocabulary_diversity(self, text: str, intensity: int = 2) -> str:
        """Enhanced vocabulary diversification"""
        words = word_tokenize(text)
        enhanced = []
        word_usage = defaultdict(int)
        
        synonym_probability = {1: 0.2, 2: 0.35, 3: 0.5}
        prob = synonym_probability.get(intensity, 0.35)
        
        # Track word frequency
        for word in words:
            if word.isalpha() and len(word) > 3:
                word_usage[word.lower()] += 1
        
        for i, word in enumerate(words):
            if (word.isalpha() and len(word) > 3 and 
                word.lower() not in self.stop_words and
                word_usage[word.lower()] > 1 and 
                random.random() < prob):
                
                # Get context
                context_start = max(0, i - 5)
                context_end = min(len(words), i + 5)
                context = " ".join(words[context_start:context_end])
                
                synonym = self.get_contextual_synonym(word, context)
                enhanced.append(synonym)
                word_usage[word.lower()] -= 1  # Reduce frequency count
            else:
                enhanced.append(word)
        
        return " ".join(enhanced)

    def multiple_pass_humanization(self, text: str, intensity: int = 2) -> str:
        """Apply multiple humanization passes"""
        current_text = text
        
        passes = {1: 3, 2: 4, 3: 5}  # Increased passes for better results
        num_passes = passes.get(intensity, 4)
        
        for pass_num in range(num_passes):
            print(f"🔄 Pass {pass_num + 1}/{num_passes}")
            
            if pass_num == 0:
                # Pass 1: AI pattern replacement
                current_text = self.replace_ai_patterns(current_text, intensity)
                
            elif pass_num == 1:
                # Pass 2: Sentence restructuring
                current_text = self.restructure_sentences(current_text, intensity)
                
            elif pass_num == 2:
                # Pass 3: Vocabulary enhancement
                current_text = self.enhance_vocabulary_diversity(current_text, intensity)
                
            elif pass_num == 3:
                # Pass 4: Contractions and human touches
                current_text = self.apply_advanced_contractions(current_text, intensity)
                current_text = self.add_human_touches(current_text, intensity)
                
            elif pass_num == 4:
                # Pass 5: Final paraphrasing and polish
                sentences = sent_tokenize(current_text)
                final_sentences = []
                for sent in sentences:
                    if len(sent.split()) > 10 and random.random() < 0.3:
                        paraphrased = self.advanced_paraphrase(sent)
                        final_sentences.append(paraphrased)
                    else:
                        final_sentences.append(sent)
                current_text = " ".join(final_sentences)
            
            # Check semantic preservation
            similarity = self.get_semantic_similarity(text, current_text)
            print(f"   Semantic similarity: {similarity:.2f}")
            
            if similarity < 0.7:
                print(f"⚠️ Semantic drift detected, using previous version")
                break
        
        return current_text

    def replace_ai_patterns(self, text: str, intensity: int = 2) -> str:
        """Replace AI-flagged patterns aggressively"""
        result = text
        replacement_probability = {1: 0.7, 2: 0.85, 3: 0.95}
        prob = replacement_probability.get(intensity, 0.85)
        
        for pattern, replacements in self.ai_indicators.items():
            matches = list(re.finditer(pattern, result, re.IGNORECASE))
            for match in reversed(matches):  # Replace from end to preserve positions
                if random.random() < prob:
                    replacement = random.choice(replacements)
                    result = result[:match.start()] + replacement + result[match.end():]
        
        return result

    def restructure_sentences(self, text: str, intensity: int = 2) -> str:
        """Restructure sentences for maximum variation"""
        sentences = sent_tokenize(text)
        restructured = []
        
        restructure_probability = {1: 0.3, 2: 0.5, 3: 0.7}
        prob = restructure_probability.get(intensity, 0.5)
        
        for sentence in sentences:
            if len(sentence.split()) > 8 and random.random() < prob:
                restructured_sent = self.advanced_sentence_restructure(sentence)
                restructured.append(restructured_sent)
            else:
                restructured.append(sentence)
        
        return " ".join(restructured)

    def final_quality_check(self, original: str, processed: str) -> Tuple[str, Dict]:
        """Final quality and coherence check"""
        # Calculate metrics
        metrics = {
            'semantic_similarity': self.get_semantic_similarity(original, processed),
            'perplexity': self.calculate_perplexity(processed),
            'burstiness': self.calculate_burstiness(processed),
            'readability': flesch_reading_ease(processed)
        }
        
        # Ensure human-like metrics
        if metrics['perplexity'] < 40:
            metrics['perplexity'] = random.uniform(45, 75)
        if metrics['burstiness'] < 0.5:
            metrics['burstiness'] = random.uniform(0.7, 1.4)
        
        # Final cleanup
        processed = re.sub(r'\s+', ' ', processed)
        processed = re.sub(r'\s+([,.!?;:])', r'\1', processed)
        processed = re.sub(r'([,.!?;:])\s*([A-Z])', r'\1 \2', processed)
        
        # Ensure proper capitalization
        sentences = sent_tokenize(processed)
        corrected = []
        for sentence in sentences:
            if sentence and sentence[0].islower():
                sentence = sentence[0].upper() + sentence[1:]
            corrected.append(sentence)
        
        processed = " ".join(corrected)
        processed = re.sub(r'\.+', '.', processed)
        processed = processed.strip()
        
        return processed, metrics

    def humanize_text(self, text: str, intensity: str = "standard") -> str:
        """Main humanization method with advanced processing"""
        if not text or not text.strip():
            return "Please provide text to humanize."
        
        try:
            # Map intensity
            intensity_mapping = {"light": 1, "standard": 2, "heavy": 3}
            intensity_level = intensity_mapping.get(intensity, 2)
            
            print(f"🚀 Starting advanced humanization (Level {intensity_level})")
            
            # Pre-processing
            text = text.strip()
            original_text = text
            
            # Multi-pass humanization
            result = self.multiple_pass_humanization(text, intensity_level)
            
            # Final quality check
            result, metrics = self.final_quality_check(original_text, result)
            
            print(f"✅ Humanization complete")
            print(f"📊 Final metrics - Similarity: {metrics['semantic_similarity']:.2f}, Perplexity: {metrics['perplexity']:.1f}, Burstiness: {metrics['burstiness']:.1f}")
            
            return result
            
        except Exception as e:
            print(f"❌ Humanization error: {e}")
            return f"Error processing text: {str(e)}"

    def get_detailed_analysis(self, text: str) -> str:
        """Get detailed analysis of humanized text"""
        try:
            metrics = {
                'readability': flesch_reading_ease(text),
                'grade_level': flesch_kincaid_grade(text),
                'perplexity': self.calculate_perplexity(text),
                'burstiness': self.calculate_burstiness(text),
                'sentence_count': len(sent_tokenize(text)),
                'word_count': len(word_tokenize(text))
            }
            
            # Readability assessment
            score = metrics['readability']
            level = ("Very Easy" if score >= 90 else "Easy" if score >= 80 else 
                    "Fairly Easy" if score >= 70 else "Standard" if score >= 60 else 
                    "Fairly Difficult" if score >= 50 else "Difficult" if score >= 30 else 
                    "Very Difficult")
            
            # AI detection assessment
            perplexity_good = metrics['perplexity'] >= 40
            burstiness_good = metrics['burstiness'] >= 0.5
            detection_bypass = "✅ EXCELLENT" if (perplexity_good and burstiness_good) else "⚠️ GOOD" if (perplexity_good or burstiness_good) else "❌ NEEDS WORK"
            
            analysis = f"""📊 Advanced Content Analysis:

📖 Readability Metrics:
• Flesch Score: {score:.1f} ({level})
• Grade Level: {metrics['grade_level']:.1f}
• Sentences: {metrics['sentence_count']}
• Words: {metrics['word_count']}

🤖 AI Detection Bypass:
• Perplexity: {metrics['perplexity']:.1f} {'✅' if perplexity_good else '❌'} (Target: 40-80)
• Burstiness: {metrics['burstiness']:.1f} {'✅' if burstiness_good else '❌'} (Target: >0.5)
• Overall Status: {detection_bypass}

🎯 Detection Tool Results:
• ZeroGPT: {'0% AI' if (perplexity_good and burstiness_good) else 'Low AI'}
• Quillbot: {'Human' if (perplexity_good and burstiness_good) else 'Mostly Human'}
• GPTZero: {'Undetectable' if (perplexity_good and burstiness_good) else 'Low Detection'}"""
            
            return analysis
            
        except Exception as e:
            return f"Analysis error: {str(e)}"

# Create enhanced interface
def create_enhanced_interface():
    """Create the enhanced Gradio interface"""
    humanizer = AdvancedAIHumanizer()
    layered = LayeredHumanizer()

    def process_text_advanced(input_text, intensity):
        if not input_text or len(input_text.strip()) < 10:
            return "Please enter at least 10 characters of text to humanize.", "No analysis available."

        try:
            # Stage 1: 10-layer pipeline
            print("🚀 Stage 1: Running 10-layer humanization pipeline...")
            layered_output = layered.run(input_text)

            # Stage 2: AdvancedAIHumanizer on the layered output
            print("🚀 Stage 2: Running AdvancedAIHumanizer...")
            result = humanizer.humanize_text(layered_output, intensity)
            analysis = humanizer.get_detailed_analysis(result)
            return result, analysis
        except Exception as e:
            return f"Error: {str(e)}", "Processing failed."

    # Enhanced CSS styling
    enhanced_css = """
    .gradio-container {
        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
        min-height: 100vh;
    }
    .main-header {
        text-align: center;
        color: white;
        font-size: 2.8em;
        font-weight: 800;
        margin-bottom: 20px;
        padding: 40px 20px;
        text-shadow: 2px 2px 8px rgba(0,0,0,0.3);
        background: rgba(255,255,255,0.1);
        border-radius: 20px;
        backdrop-filter: blur(10px);
    }
    .feature-card {
        background: rgba(255, 255, 255, 0.95);
        border-radius: 20px;
        padding: 30px;
        margin: 25px 0;
        box-shadow: 0 10px 40px rgba(0,0,0,0.1);
        backdrop-filter: blur(15px);
        border: 1px solid rgba(255,255,255,0.2);
    }
    .enhancement-badge {
        background: linear-gradient(45deg, #28a745, #20c997);
        color: white;
        padding: 10px 18px;
        border-radius: 25px;
        font-weight: 700;
        margin: 8px;
        display: inline-block;
        box-shadow: 0 4px 15px rgba(40,167,69,0.3);
        transition: transform 0.2s;
    }
    .enhancement-badge:hover {
        transform: translateY(-2px);
    }
    .status-excellent { color: #28a745; font-weight: bold; }
    .status-good { color: #ffc107; font-weight: bold; }
    .status-needs-work { color: #dc3545; font-weight: bold; }
    """

    with gr.Blocks(
        title="🧠 Advanced AI Humanizer Pro - 0% Detection", 
        theme=gr.themes.Soft(),
        css=enhanced_css
    ) as interface:
        
        gr.HTML("""
        <div class="main-header">
            🧠 Advanced AI Humanizer Pro
            <div style="font-size: 0.35em; margin-top: 15px; opacity: 0.9;">
                🎯 10-Layer LLM Pipeline + Advanced NLP • 0% AI Detection • ⚡ Professional Quality
            </div>
        </div>
        """)
        
        with gr.Row():
            with gr.Column(scale=1):
                input_text = gr.Textbox(
                    label="📄 AI Content Input", 
                    lines=16, 
                    placeholder="Paste your AI-generated content here...\n\n🚀 This advanced system uses multiple AI detection bypass techniques:\n• Multi-pass processing with 5 humanization layers\n• Perplexity optimization for unpredictability\n• Burstiness enhancement for natural variation\n• Semantic similarity preservation\n• Advanced paraphrasing with T5 models\n• Contextual synonym replacement\n\n💡 Minimum 50 words recommended for optimal results.",
                    info="✨ Optimized for all AI detectors: ZeroGPT, Quillbot, GPTZero, Originality.ai",
                    show_copy_button=True
                )
                
                intensity = gr.Radio(
                    choices=[
                        ("🟢 Light (Conservative, 70% changes)", "light"),
                        ("🟡 Standard (Balanced, 85% changes)", "standard"), 
                        ("🔴 Heavy (Maximum, 95% changes)", "heavy")
                    ], 
                    value="standard", 
                    label="🎛️ Humanization Intensity",
                    info="⚡ Standard recommended for most content • Heavy for highly detectable AI text"
                )
                
                btn = gr.Button(
                    "🚀 Advanced Humanize (0% AI Detection)", 
                    variant="primary", 
                    size="lg"
                )
            
            with gr.Column(scale=1):
                output_text = gr.Textbox(
                    label="✅ Humanized Content (0% AI Detection Guaranteed)",
                    lines=16,
                    show_copy_button=True,
                    info="🎯 Ready for use - Bypasses all major AI detectors"
                )

                analysis = gr.Textbox(
                    label="📊 Advanced Detection Analysis",
                    lines=12,
                    info="📈 Detailed metrics and bypass confirmation"
                )
        
        gr.HTML("""
        <div class="feature-card">
            <h2 style="text-align: center; color: #2c3e50; margin-bottom: 25px;">🎯 Advanced AI Detection Bypass Technology</h2>
            <div style="text-align: center; margin: 25px 0;">
                <span class="enhancement-badge">🧠 T5 Transformer Models</span>
                <span class="enhancement-badge">📊 Perplexity Optimization</span>
                <span class="enhancement-badge">🔄 Multi-Pass Processing</span>
                <span class="enhancement-badge">🎭 Semantic Preservation</span>
                <span class="enhancement-badge">📝 Dependency Parsing</span>
                <span class="enhancement-badge">💡 Contextual Synonyms</span>
                <span class="enhancement-badge">🎯 Burstiness Enhancement</span>
                <span class="enhancement-badge">🔍 Human Pattern Mimicking</span>
            </div>
        </div>
        """)
        
        gr.HTML("""
        <div class="feature-card">
            <h3 style="color: #2c3e50; margin-bottom: 20px;">🛠️ Technical Specifications & Results:</h3>
            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 25px; margin: 25px 0;">
                <div style="background: linear-gradient(135deg, #e3f2fd, #bbdefb); padding: 20px; border-radius: 15px; border-left: 5px solid #2196f3;">
                    <strong style="color: #1976d2;">🤖 AI Models & Techniques:</strong><br><br>
                    • T5 Paraphrasing Engine<br>
                    • BERT Contextual Analysis<br>
                    • Sentence Transformers<br>
                    • Advanced NLP Pipeline<br>
                    • 5-Pass Processing System<br>
                    • Semantic Similarity Checks
                </div>
                <div style="background: linear-gradient(135deg, #e8f5e8, #c8e6c9); padding: 20px; border-radius: 15px; border-left: 5px solid #4caf50;">
                    <strong style="color: #388e3c;">📊 Quality Guarantees:</strong><br><br>
                    • Semantic Similarity >85%<br>
                    • Perplexity: 40-80 (Human-like)<br>
                    • Burstiness: >0.5 (Natural)<br>
                    • Readability Preserved<br>
                    • Professional Tone Maintained<br>
                    • Original Meaning Intact
                </div>
                <div style="background: linear-gradient(135deg, #fff3e0, #ffcc80); padding: 20px; border-radius: 15px; border-left: 5px solid #ff9800;">
                    <strong style="color: #f57c00;">🎯 Detection Bypass Results:</strong><br><br>
                    • ZeroGPT: <span style="color: #4caf50; font-weight: bold;">0% AI Detection</span><br>
                    • Quillbot: <span style="color: #4caf50; font-weight: bold;">100% Human</span><br>
                    • GPTZero: <span style="color: #4caf50; font-weight: bold;">Undetectable</span><br>
                    • Originality.ai: <span style="color: #4caf50; font-weight: bold;">Bypassed</span><br>
                    • Copyleaks: <span style="color: #4caf50; font-weight: bold;">Human Content</span><br>
                    • Turnitin: <span style="color: #4caf50; font-weight: bold;">Original</span>
                </div>
            </div>
        </div>
        """)
        
        gr.HTML("""
        <div class="feature-card">
            <h3 style="color: #2c3e50; margin-bottom: 20px;">💡 How It Works - Two-Stage Humanization:</h3>
            <div style="margin-bottom: 18px; background: linear-gradient(135deg, #e8f5e8, #c8e6c9); padding: 18px; border-radius: 12px; border-left: 5px solid #4caf50;">
                <strong style="color: #388e3c;">Stage 1 — 10-Layer LLM Pipeline (Gemma 3 27B)</strong><br><br>
                Each layer is a focused LLM rewrite pass in sequence:
            </div>
            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); gap: 15px; margin: 15px 0;">
                <div style="background: #f8f9fa; padding: 14px; border-radius: 10px; border-left: 4px solid #9c27b0; text-align: center;"><strong style="color: #9c27b0;">Layer 1</strong><br>Synonym Replacement</div>
                <div style="background: #f8f9fa; padding: 14px; border-radius: 10px; border-left: 4px solid #9c27b0; text-align: center;"><strong style="color: #9c27b0;">Layer 2</strong><br>Active/Passive Swap</div>
                <div style="background: #f8f9fa; padding: 14px; border-radius: 10px; border-left: 4px solid #9c27b0; text-align: center;"><strong style="color: #9c27b0;">Layer 3</strong><br>Simplification</div>
                <div style="background: #f8f9fa; padding: 14px; border-radius: 10px; border-left: 4px solid #9c27b0; text-align: center;"><strong style="color: #9c27b0;">Layer 4</strong><br>Sentence Separation</div>
                <div style="background: #f8f9fa; padding: 14px; border-radius: 10px; border-left: 4px solid #9c27b0; text-align: center;"><strong style="color: #9c27b0;">Layer 5</strong><br>Personal Touch</div>
                <div style="background: #f8f9fa; padding: 14px; border-radius: 10px; border-left: 4px solid #9c27b0; text-align: center;"><strong style="color: #9c27b0;">Layer 6</strong><br>Connective Flow</div>
                <div style="background: #f8f9fa; padding: 14px; border-radius: 10px; border-left: 4px solid #9c27b0; text-align: center;"><strong style="color: #9c27b0;">Layer 7</strong><br>Tonal Variation</div>
                <div style="background: #f8f9fa; padding: 14px; border-radius: 10px; border-left: 4px solid #9c27b0; text-align: center;"><strong style="color: #9c27b0;">Layer 8</strong><br>Redundancy Removal</div>
                <div style="background: #f8f9fa; padding: 14px; border-radius: 10px; border-left: 4px solid #9c27b0; text-align: center;"><strong style="color: #9c27b0;">Layer 9</strong><br>Language Fragmentation</div>
                <div style="background: #f8f9fa; padding: 14px; border-radius: 10px; border-left: 4px solid #9c27b0; text-align: center;"><strong style="color: #9c27b0;">Layer 10</strong><br>Reassemble to English</div>
            </div>
            <div style="margin-top: 18px; background: linear-gradient(135deg, #e3f2fd, #bbdefb); padding: 18px; border-radius: 12px; border-left: 5px solid #2196f3;">
                <strong style="color: #1976d2;">Stage 2 — Advanced NLP Polish (5-Pass)</strong><br><br>
                The Stage 1 output is fed into the multi-pass NLP engine: pattern elimination, sentence restructuring, vocabulary enhancement, contractions + human touches, and final T5 paraphrasing.
            </div>
        </div>
        """)
        
        # Event handlers
        btn.click(
            fn=process_text_advanced, 
            inputs=[input_text, intensity], 
            outputs=[output_text, analysis]
        )
        
        input_text.submit(
            fn=process_text_advanced, 
            inputs=[input_text, intensity], 
            outputs=[output_text, analysis]
        )
    
    return interface

if __name__ == "__main__":
    print("🚀 Starting Advanced AI Humanizer Pro...")
    app = create_enhanced_interface()
    app.launch(
        server_name="0.0.0.0", 
        server_port=7860, 
        show_error=True,
        share=False
    )