import sqlite3
from typing import List, Tuple
from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
import torch

# Set device for model
DEVICE = "cuda:0" if torch.cuda.is_available() else "cpu"
print(f"Using device: {DEVICE}")

# Load tokenizer and model
tokenizer = AutoTokenizer.from_pretrained("roberta-base-openai-detector")
model = AutoModelForSequenceClassification.from_pretrained("roberta-base-openai-detector")
pipe = pipeline("text-classification", model=model, tokenizer=tokenizer, device=0 if DEVICE == "cuda:0" else -1)

# Initialize SQLite database
DB_NAME = "classification_results.db"

def initialize_database():
    """
    Initializes the SQLite database and creates the classifications table if it doesn't exist.
    """
    conn = sqlite3.connect(DB_NAME)
    cursor = conn.cursor()
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS classifications (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            filename TEXT,
            line_text TEXT,
            label TEXT,
            confidence REAL
        )
    """)
    conn.commit()
    conn.close()

def classify_text(sentences: List[str]) -> List[Tuple[str, float]]:
    """
    Classifies a list of sentences as 'Human' or 'AI' with confidence scores.

    :param sentences: List of text inputs to classify.
    :return: List of tuples containing the predicted label ('Human' or 'AI') and confidence score.
    """
    results = pipe(sentences)
    return [("Human" if res["label"] == "Real" else "AI", res["score"]) for res in results]

def classify_file(filename: str) -> List[Tuple[str, float]]:
    """
    Reads a file line by line, classifies each line as 'Human' or 'AI', prints the results,
    and stores them in an SQLite database.

    :param filename: Name of the text file to classify.
    :return: List of tuples containing classification results.
    """
    results = []
    
    with open(filename, "r", encoding="utf-8") as file:
        lines = [line.strip() for line in file if line.strip()]  # Remove empty lines

    if not lines:
        print(f"Warning: {filename} is empty or contains only whitespace.")
        return results
    
    classifications = classify_text(lines)

    # Store results in SQLite
    save_to_database(filename, lines, classifications)
    
    # Print results
    for line, classification in zip(lines, classifications):
        print(f"{classification} : {line}")
        results.append(classification)
    
    return results

def save_to_database(filename: str, lines: List[str], classifications: List[Tuple[str, float]]):
    """
    Saves classification results to an SQLite database.

    :param filename: Name of the source file.
    :param lines: List of text lines from the file.
    :param classifications: List of classification results (label, confidence).
    """
    conn = sqlite3.connect(DB_NAME)
    cursor = conn.cursor()

    data = [(filename, line, label, confidence) for line, (label, confidence) in zip(lines, classifications)]
    cursor.executemany("INSERT INTO classifications (filename, line_text, label, confidence) VALUES (?, ?, ?, ?)", data)

    conn.commit()
    conn.close()
    print(f"Results from {filename} saved to database.")

# Initialize database
initialize_database()

# Run classification and store results
classify_file("ai.txt")
classify_file("human.txt")

import random
import torch
import logging
from nltk.corpus import wordnet
from transformers import AutoModelForSeq2SeqLM, AutoModelForCausalLM, AutoTokenizer, T5Tokenizer

# Configure Logging
logger = logging.getLogger(__name__)

class PerturbationConfig:
    """Configuration class for Perturbation settings."""

    def __init__(self):
        # Default model settings
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.t5_model_name = "t5-small"
        self.gpt_model_name = "EleutherAI/gpt-neo-1.3B"

        # Default perturbation method
        self.default_method = "gpt_completion"  # Change to "random" for randomized perturbations

        # Randomization settings
        self.use_random_perturbation = False  # Set to True to randomize perturbation selection

        # Perturbation parameters
        self.top_p = 0.92  # Top-p sampling for GPT perturbations
        self.paraphrase_top_p = 0.95  # Top-p sampling for T5 paraphrasing
        self.max_length = 512  # Max length for generated text perturbations

class Perturbation:
    """Class for perturbing text using different techniques to assess AI-generated text."""

    def __init__(self, config: PerturbationConfig = PerturbationConfig()):
        self.config = config
        self.device = self.config.device

        # Load T5 model for paraphrasing
        self.t5_model = AutoModelForSeq2SeqLM.from_pretrained(self.config.t5_model_name).to(self.device)
        self.t5_tokenizer = T5Tokenizer.from_pretrained(self.config.t5_model_name, model_max_length=512)

        # Load GPT model for AI-based text perturbation
        self.gptj_tokenizer = AutoTokenizer.from_pretrained(self.config.gpt_model_name)
        self.gptj_model = AutoModelForCausalLM.from_pretrained(self.config.gpt_model_name).to(self.device)

        logger.info(f"Perturbation class initialized with default method: {self.config.default_method}")

    def shuffle_text(self, text):
        """Randomly shuffles words in the text."""
        words = text.split()
        random.shuffle(words)
        perturbed_text = " ".join(words)
        logger.debug(f"Shuffle Perturbation: {text} → {perturbed_text}")
        return perturbed_text

    def remove_word(self, text):
        """Randomly removes a word from the text."""
        words = text.split()
        if len(words) > 1:
            index = random.randint(0, len(words) - 1)
            removed_word = words.pop(index)
            perturbed_text = " ".join(words)
            logger.debug(f"Remove Word Perturbation: Removed '{removed_word}' → {perturbed_text}")
        else:
            perturbed_text = text
        return perturbed_text

    def replace_with_mask(self, text):
        """Randomly replaces a word with a mask token."""
        words = text.split()
        if len(words) > 1:
            index = random.randint(0, len(words) - 1)
            replaced_word = words[index]
            words[index] = "<mask>"
            perturbed_text = " ".join(words)
            logger.debug(f"Replace Word with Mask: Replaced '{replaced_word}' with '<mask>' → {perturbed_text}")
        else:
            perturbed_text = text
        return perturbed_text

    def synonym_substitution(self, text):
        """Replaces words with their synonyms using WordNet."""
        words = text.split()
        new_words = []
        for word in words:
            synonyms = wordnet.synsets(word)
            if synonyms:
                new_word = synonyms[0].lemmas()[0].name()
                new_words.append(new_word)
                logger.debug(f"Synonym Substitution: Replaced '{word}' with '{new_word}'")
            else:
                new_words.append(word)
        return " ".join(new_words)

    def paraphrase_text(self, text):
        """Uses T5 to generate a paraphrased version of the text."""
        input_text = f"paraphrase: {text} </s>"
        encoding = self.t5_tokenizer.encode_plus(input_text, return_tensors="pt").to(self.device)

        with torch.no_grad():
            outputs = self.t5_model.generate(**encoding, max_length=self.config.max_length, do_sample=True, top_p=self.config.paraphrase_top_p)

        perturbed_text = self.t5_tokenizer.decode(outputs[0], skip_special_tokens=True)
        logger.debug(f"Paraphrase Perturbation: {text} → {perturbed_text}")
        return perturbed_text

    def insert_random_sentence(self, text):
        """Inserts a random unrelated sentence into the text."""
        random_sentences = [
            "The moon orbits the Earth approximately every 27.3 days.",
            "Neural networks have been widely used in deep learning applications.",
            "Shakespeare wrote some of the most famous plays in history."
        ]
        random_sentence = random.choice(random_sentences)
        words = text.split()
        insert_position = random.randint(0, len(words))
        words.insert(insert_position, random_sentence)
        perturbed_text = " ".join(words)
        logger.debug(f"Insert Random Sentence: Inserted '{random_sentence}' → {perturbed_text}")
        return perturbed_text

    def gpt_completion_perturbation(self, text):
        """Uses a GPT model to generate AI-based perturbations."""
        input_ids = self.gptj_tokenizer.encode(text, return_tensors="pt").to(self.device)
        with torch.no_grad():
            output = self.gptj_model.generate(input_ids, max_length=len(input_ids[0]) + 5, do_sample=True, top_p=self.config.top_p)

        perturbed_text = self.gptj_tokenizer.decode(output[0], skip_special_tokens=True)
        logger.debug(f"GPT Completion Perturbation: {text} → {perturbed_text}")
        return perturbed_text

    def perturb_text(self, text, method=None):
        """
        Applies the selected perturbation method.

        :param text: Input text to be perturbed.
        :param method: Name of the perturbation method to apply.
                       Defaults to the config setting. Use "random" to choose a random method.
        :return: Perturbed text.
        """
        perturbation_methods = {
            "shuffle": self.shuffle_text,
            "remove_word": self.remove_word,
            "replace_mask": self.replace_with_mask,
            "synonym_substitution": self.synonym_substitution,
            "paraphrase": self.paraphrase_text,
            "insert_sentence": self.insert_random_sentence,
            "gpt_completion": self.gpt_completion_perturbation
        }

        # If no method is provided, use the configured default
        if method is None:
            method = self.config.default_method

        # If configured to use random perturbation, pick one randomly
        if method == "random" or self.config.use_random_perturbation:
            method = random.choice(list(perturbation_methods.keys()))

        if method in perturbation_methods:
            logger.info(f"Applying Perturbation: {method} on text: {text}")
            return perturbation_methods[method](text)
        else:
            logger.warning(f"Invalid perturbation method: {method}. Defaulting to GPT Completion.")
            return self.gpt_completion_perturbation(text)

from dataclasses import dataclass
import torch
import numpy as np
import re
import math
import logging
from transformers import GPT2LMHeadModel, GPT2TokenizerFast, T5Tokenizer
from transformers import AutoModelForSeq2SeqLM
from sklearn.preprocessing import StandardScaler
from scipy.special import erf


#  Configure Logging
logging.basicConfig(
    filename="gpt_perplexity.log",
    filemode="w",
    format="%(asctime)s - %(levelname)s - %(message)s",
    level=logging.DEBUG
)

logger = logging.getLogger(__name__)


@dataclass
class ClassificationResult:
    """Dataclass to store classification results."""
    score: float
    diff: float
    std_dev: float
    confidence: float
    label: str

    def __str__(self):
        """Custom string representation."""
        return f"{self.confidence:.2f}% confidence that the text is {self.label}."


class GPTConfig:
    """Configuration class for GPTPerplexity model settings."""
    
    def __init__(self):
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.gpt_model_id = "gpt2" 
        self.t5_model_id = "t5-small"

        # Perplexity settings
        self.max_length = 1024
        self.stride = 51
        self.threshold = 0.7

        # Masking settings
        self.mask_span = 2
        self.mask_ratio = 0.3
        self.mask_samples = 100

        # T5 Generation settings
        self.t5_top_p = 0.96
        self.t5_num_return_sequences = 1


class GPTPerplexity:
    """GPT-based Perplexity and AI-Text Detection Model."""

    def __init__(self, config: GPTConfig):
        self.config = config
        self.device = config.device

        # Load models
        self.gpt_model = GPT2LMHeadModel.from_pretrained(config.gpt_model_id).to(self.device)
        self.tokenizer = GPT2TokenizerFast.from_pretrained(config.gpt_model_id)

        self.t5_model = AutoModelForSeq2SeqLM.from_pretrained(config.t5_model_id).to(self.device).half()
        self.t5_tokenizer = T5Tokenizer.from_pretrained(config.t5_model_id, model_max_length=512)


        # Initialize Perturbation class
        self.perturbation = Perturbation(device=self.device)

        logger.info("GPTPerplexity Model Initialized.")

    def get_log_likelihood(self, sentence):
        """Calculates the log-likelihood of a sentence using GPT2."""
        encodings = self.tokenizer(sentence, return_tensors="pt")
        seq_len = encodings.input_ids.size(1)
        nlls = []

        prev_end_loc = 0
        for begin_loc in range(0, seq_len, self.config.stride):
            end_loc = min(begin_loc + self.config.max_length, seq_len)
            trg_len = end_loc - prev_end_loc
            input_ids = encodings.input_ids[:, begin_loc:end_loc].to(self.device)
            target_ids = input_ids.clone()
            target_ids[:, :-trg_len] = -100

            with torch.no_grad():
                outputs = self.gpt_model(input_ids, labels=target_ids)
                nlls.append(outputs.loss * trg_len)

            prev_end_loc = end_loc
            if end_loc == seq_len:
                break

        likelihood = (-1 * torch.stack(nlls).sum() / end_loc).cpu().item()
        logger.debug(f"Computed log-likelihood: {likelihood}")
        return likelihood

    def compute_ai_score(self, sentence):
        """Computes an AI-score using log-likelihood differences between original and perturbed texts."""
        original_sentence = sentence.strip()
        logger.debug(f"Processing sentence: {original_sentence}")

        real_log_likelihood = self.get_log_likelihood(original_sentence)
        logger.debug(f"Real log-likelihood: {real_log_likelihood}")

        # Generate perturbed versions of the sentence
        perturbed_sentences = [self.get_log_likelihood(self.perturbation.perturb_text(original_sentence)) 
                               for _ in range(self.config.mask_samples)]        
        logger.debug(f"Perturbed sentances: {perturbed_sentences}")

        if not perturbed_sentences:
            logger.error("Error perturbing sentences. No valid perturbations.")
            return -1

        # **Use scikit-learn to standardize data**
        scaler = StandardScaler()
        all_scores = np.array([real_log_likelihood] + perturbed_sentences).reshape(-1, 1)
        standardized_scores = scaler.fit_transform(all_scores).flatten()

        logger.debug(f"Standardized Scores: {standardized_scores}")

        standardized_real_score = standardized_scores[0]
        standardized_perturbed_mean = np.mean(standardized_scores[1:])
        standardized_perturbed_std = np.std(standardized_scores[1:])

        if standardized_perturbed_std == 0:
            logger.warning("Standard deviation is zero. Adding small jitter.")
            standardized_perturbed_std = 1e-8 + np.random.uniform(0, 1e-5)  

        ai_score = (standardized_real_score - standardized_perturbed_mean) / standardized_perturbed_std

        logger.info(f"AI Score: {ai_score}, Difference: {standardized_real_score - standardized_perturbed_mean}, Std Dev: {standardized_perturbed_std}")

        return float(ai_score), float(standardized_real_score - standardized_perturbed_mean), float(standardized_perturbed_std)

    def classify_text(self, sentence) -> ClassificationResult:
        """Classifies text as AI-generated or Human-written and returns a structured result."""
        sentence = re.sub(r"\[[0-9]+\]", "", sentence)  
        score, diff, std_dev = self.compute_ai_score(sentence)

        if score == -1 or math.isnan(score):
            logger.error("Error: Computed an invalid AI score.")
            return ClassificationResult(score=-1, diff=0, std_dev=0, confidence=0, label="Error")

        confidence = self.normal_cdf(abs(self.config.threshold - score)) * 100
        label = "AI-generated" if score > self.config.threshold else "Human-written"
        
        logger.info(f"Final Classification: {confidence:.2f}% confidence that the text is {label}.")

        return ClassificationResult(score=score, diff=diff, std_dev=std_dev, confidence=confidence, label=label)

    @staticmethod
    def normal_cdf(x):
        """Approximate the CDF of a normal distribution using erf."""
        return 0.5 * (1 + erf(x / math.sqrt(2)))

import sqlite3

def setup_database():
    """Creates the SQLite database and results table if it doesn't exist."""
    conn = sqlite3.connect("classification_results.db")
    cursor = conn.cursor()
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS results (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            filename TEXT,
            text TEXT,
            score REAL,
            diff REAL,
            std_dev REAL,
            confidence REAL,
            label TEXT
        )
    """)
    conn.commit()
    conn.close()

def classify_file(model, filename):
    """
    Reads a file line by line, classifies each line as 'AI-generated' or 'Human-written',
    and stores the results in an SQLite database.

    :param model: The GPTPerplexity model for classification.
    :param filename: Name of the text file to classify.
    """
    print(f"\nProcessing file: {filename}\n" + "-"*40)

    with open(filename, "r", encoding="utf-8") as file:
        lines = [line.strip() for line in file if line.strip()]  # Remove empty lines

    if not lines:
        print(f"Warning: {filename} is empty or contains only whitespace.")
        return

    conn = sqlite3.connect("classification_results.db")
    cursor = conn.cursor()

    for line in lines:
        classification_result = model.classify_text(line)

        # Insert into the database
        cursor.execute("""
            INSERT INTO results (filename, text, score, diff, std_dev, confidence, label)
            VALUES (?, ?, ?, ?, ?, ?, ?)
        """, (filename, line, classification_result.score, classification_result.diff,
              classification_result.std_dev, classification_result.confidence, classification_result.label))

        print(f" Text: {line}\n {str(classification_result)}\n")

    conn.commit()
    conn.close()

def generate_markdown_report():
    """Generates a markdown report from the classification results stored in the database."""
    conn = sqlite3.connect("classification_results.db")
    cursor = conn.cursor()

    # Fetch results
    cursor.execute("SELECT filename, text, score, confidence, label FROM results")
    rows = cursor.fetchall()
    conn.close()

    # Create Markdown content
    markdown_content = "# AI vs. Human Text Classification Report\n\n"
    markdown_content += "| Filename | Text | Score | Confidence | Label |\n"
    markdown_content += "|----------|------|-------|------------|-------|\n"

    for row in rows:
        filename, text, score, confidence, label = row
        markdown_content += f"| {filename} | {text[:50]}... | {score:.2f} | {confidence:.2f}% | {label} |\n"

    # Write to markdown file
    with open("classification_report.md", "w", encoding="utf-8") as md_file:
        md_file.write(markdown_content)

    print("\n Report generated: classification_report.md")

# Step 1: Setup the database
setup_database()

# Step 2: Process files and store results in SQLite
config = GPTConfig()
model = GPTPerplexity(config)

classify_file(model, "ai.txt")
classify_file(model, "human.txt")

# Step 3: Generate markdown report from the stored results
generate_markdown_report()

from datasets import load_dataset
import pandas as pd

# Load the dataset
dataset = load_dataset("NicolaiSivesind/human-vs-machine")

# Convert to DataFrame
df_train = pd.DataFrame(dataset["train"])
df_test = pd.DataFrame(dataset["test"])

print(f"Training samples: {len(df_train)}, Test samples: {len(df_test)}")

import torch
import ollama

def get_embedding(text):
    """Generates an embedding using Ollama"""
    try:
        embedding_data = ollama.embeddings(model="mxbai-embed-large", prompt=text)
        return torch.tensor(embedding_data["embedding"], dtype=torch.float32)
    except Exception as e:
        print(f"Error generating embedding: {e}")
        return None

# Convert text to embeddings
train_embeddings = [get_embedding(text) for text in df_train["text"]]
test_embeddings = [get_embedding(text) for text in df_test["text"]]

# Stack embeddings into tensors
train_embeddings_tensor = torch.stack([e for e in train_embeddings if e is not None])
test_embeddings_tensor = torch.stack([e for e in test_embeddings if e is not None])

import torch.nn as nn
import torch.optim as optim

class SparseAutoencoder(nn.Module):
    def __init__(self, input_dim, hidden_dim):
        super(SparseAutoencoder, self).__init__()
        self.encoder = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU()
        )
        self.decoder = nn.Sequential(
            nn.Linear(hidden_dim, input_dim),
            nn.Sigmoid()
        )

    def forward(self, x):
        encoded = self.encoder(x)
        decoded = self.decoder(encoded)
        return decoded, encoded

# Initialize model
input_dim = train_embeddings_tensor.shape[1]  # Embedding size
hidden_dim = 128  # Feature compression dimension, you may need to adjust
sae = SparseAutoencoder(input_dim, hidden_dim).to("cuda")

# Train SAE
# Define optimizer and loss function
optimizer = optim.Adam(model.parameters(), lr=1e-3, weight_decay=1e-5)  # Add weight decay for regularization
loss_fn = nn.MSELoss()
epochs = 500

for epoch in range(epochs):
    optimizer.zero_grad()
    reconstructed, encoded = sae(train_embeddings_tensor.to("cuda"))
    loss = loss_fn(reconstructed, train_embeddings_tensor.to("cuda"))
    loss.backward()
    optimizer.step()

    # Compute validation loss
    model.eval()  # Set to evaluation mode
    with torch.no_grad():
        val_reconstructed, _ = model(val_embeddings)
        val_loss = loss_fn(val_reconstructed, val_embeddings)

    # Save best model based on validation loss
    if val_loss < best_val_loss:
        best_val_loss = val_loss
        print(f"Saving best model with validation loss: {best_val_loss.item():.6f} .. {epoch}")
        torch.save(model.state_dict(), "best_sparse_autoencoder.pth")

    print(f"Epoch [{epoch+1}/{epochs}] - Train Loss: {train_loss.item():.6f} | Validation Loss: {val_loss.item():.6f}")

print("✅ Training completed. Best model saved!")

def detect_ai_text(model, test_embeddings, threshold=0.21):
    """
    Uses the Sparse Autoencoder to classify AI-generated text.
    - Computes reconstruction loss.
    - Labels as AI-generated if loss is below threshold.
    """
    with torch.no_grad():
        reconstructed, _ = model(test_embeddings)  # Forward pass through SAE
        reconstruction_loss = torch.mean((test_embeddings - reconstructed) ** 2, dim=1)  # MSE loss per sample

    # Convert to CPU for further processing
    reconstruction_loss = reconstruction_loss.cpu().numpy()

    # Classify based on threshold
    predictions = (reconstruction_loss > threshold).astype(int)  # 1 = AI, 0 = Human

    return reconstruction_loss, predictions

# Run AI detection on test embeddings
test_reconstruction_loss, test_predictions = detect_ai_text(loaded_model, test_embeddings_tensor)

import xgboost as xgb
from sklearn.metrics import accuracy_score

# Train XGBoost classifier
xgb_model = xgb.XGBClassifier(
    objective="binary:logistic",
    eval_metric="logloss",
    max_depth=7,
    learning_rate=0.01,
    n_estimators=500
)

xgb_model.fit(train_features, df_train["label"])

# Predict on test set
test_preds = xgb_model.predict(test_features)

# Evaluate accuracy
accuracy = accuracy_score(df_test["label"], test_preds)
print(f"XGBoost Accuracy: {accuracy:.4f}")

from sklearn.manifold import TSNE
import matplotlib.pyplot as plt

# Reduce SAE features using t-SNE
tsne = TSNE(n_components=2, random_state=42)
test_features_2d = tsne.fit_transform(test_features)

# Plot results
plt.figure(figsize=(8, 6))
plt.scatter(test_features_2d[df_test["label"] == 0, 0], test_features_2d[df_test["label"] == 0, 1], 
            c="blue", label="Human", alpha=0.5)
plt.scatter(test_features_2d[df_test["label"] == 1, 0], test_features_2d[df_test["label"] == 1, 1], 
            c="red", label="AI", alpha=0.5)
plt.xlabel("t-SNE Component 1")
plt.ylabel("t-SNE Component 2")
plt.title(" t-SNE Visualization of SAE Features")
plt.legend()
plt.show()

import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix

# Compute confusion matrix
cm = confusion_matrix(test_labels, test_preds)

# Plot confusion matrix
plt.figure(figsize=(6, 5))
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", xticklabels=["Human", "AI"], yticklabels=["Human", "AI"])
plt.xlabel("Predicted Label")
plt.ylabel("True Label")
plt.title("📊 XGBoost Confusion Matrix")
plt.show()

import re
import numpy as np
import nltk
from nltk.tokenize import word_tokenize
from collections import Counter
from transformers import AutoModelForSequenceClassification, AutoTokenizer

nltk.download("punkt")

class AIWatermarkDetector:
    def __init__(self):
        """Initialize token patterns and AI classifiers."""
        self.common_ai_tokens = {"thus", "moreover", "indeed", "consequently", "notably"}  # Probabilistic watermark
        self.tokenizer = AutoTokenizer.from_pretrained("roberta-base-openai-detector")
        self.model = AutoModelForSequenceClassification.from_pretrained("roberta-base-openai-detector")

    def detect_token_watermark(self, text):
        """Check if AI-preferred words appear more frequently than expected."""
        tokens = word_tokenize(text.lower())
        token_counts = Counter(tokens)

        ai_bias_score = sum(token_counts[token] for token in self.common_ai_tokens if token in token_counts)
        normalized_score = ai_bias_score / len(tokens)

        return normalized_score > 0.02, f"AI Token Watermark Score: {normalized_score:.4f}"

    def detect_zero_width_chars(self, text):
        """Detect invisible Unicode characters that AI models may embed as watermarks."""
        hidden_chars = re.findall(r'[\u200B\u200C\u200D\uFEFF]', text)  # Zero-width characters
        return len(hidden_chars) > 0, f"Zero-Width Characters Found: {len(hidden_chars)}"

    def detect_style_patterns(self, text):
        """Use an AI detector model to classify writing style."""
        inputs = self.tokenizer(text, return_tensors="pt", truncation=True, padding=True)
        outputs = self.model(**inputs)
        ai_confidence = outputs.logits.softmax(dim=-1).tolist()[0][1]  # AI-generated confidence

        return ai_confidence > 0.7, f"Style AI Confidence Score: {ai_confidence:.4f}"

    def analyze_text(self, text):
        """Run all detection methods and return the results."""
        results = {
            "Token Watermark": self.detect_token_watermark(text),
            "Zero-Width Watermark": self.detect_zero_width_chars(text),
            "Style-Based Fingerprinting": self.detect_style_patterns(text),
        }
        
        ai_detected = any(flag for flag, _ in results.values())
        final_verdict = "AI-Generated Text Detected" if ai_detected else "Likely Human-Written"

        return {"Verdict": final_verdict, "Details": results}

# Usage Example
if __name__ == "__main__":
    detector = AIWatermarkDetector()
    sample_text = "Indeed, the rapid growth of AI has notably changed how we communicate. Moreover, its impact is undeniable."
    
    result = detector.analyze_text(sample_text)
    print(result)

python ai_watermark_detector.py

{
    "Verdict": "AI-Generated Text Detected",
    "Details": {
        "Token Watermark": (True, "AI Token Watermark Score: 0.0345"),
        "Zero-Width Watermark": (False, "Zero-Width Characters Found: 0"),
        "Style-Based Fingerprinting": (True, "Style AI Confidence Score: 0.8312")
    }
}