epub_cleaner.py

#!/usr/bin/env python3
"""
EPUB LLM Cleaner - Selective paragraph rewriting using LLM analysis

Sends full chapter for context, but only rewrites problematic paragraphs.
Best of both worlds: context preserved + speed optimized.

Usage:
    python epub_cleaner.py --input book.epub --output book_cleaned.epub
    python epub_cleaner.py --input book.epub --dry-run
    python epub_cleaner.py --config my_config.yaml --prompts my_prompts.yaml --input book.epub
    python epub_cleaner.py --input book.epub --profile author_profile.json --max-drift 30
"""

import argparse
import hashlib
import json
import os
import re
import shutil
import sys
import time
import zipfile
import tempfile
from datetime import datetime, timedelta
from pathlib import Path
from typing import Optional, Dict, Any, List

try:
    import yaml
except ImportError:
    print("Error: PyYAML not installed. Run: pip install pyyaml")
    sys.exit(1)

try:
    from bs4 import BeautifulSoup
except ImportError:
    print("Error: beautifulsoup4 not installed. Run: pip install beautifulsoup4")
    sys.exit(1)

try:
    import anthropic
except ImportError:
    print("Error: anthropic package not installed. Run: pip install anthropic")
    anthropic = None


# ---------- DEFAULT CONFIGURATION ----------
DEFAULT_CONFIG = {
    'model': 'claude-sonnet-4-5-20250929',
    'provider': 'anthropic',
    'rate_limit_delay': 0.1,
    'max_tokens_analysis': 10,
    'max_tokens_cleaning': 8000,
    'paragraph_selectors': [
        'p.body-text',
        'p.content',
        'p'
    ],
    'chapter_selectors': [
        'h1', 'h2', 'h3',
        '.chapter-title', '.chapter-number',
        '[class*="chapter"]', '[class*="title"]'
    ]
}

# Default cache TTL in hours
DEFAULT_CACHE_TTL = 24


# ---------- CACHE SYSTEM ----------

def get_cache_dir() -> Path:
    """Get the cache directory, creating it if necessary."""
    # Try ~/.booksmith/cache/ first, fall back to temp directory
    home = Path.home()
    cache_dir = home / '.booksmith' / 'cache'

    try:
        cache_dir.mkdir(parents=True, exist_ok=True)
        # Test write access
        test_file = cache_dir / '.write_test'
        test_file.touch()
        test_file.unlink()
        return cache_dir
    except (PermissionError, OSError):
        # Fall back to temp directory
        temp_cache = Path(tempfile.gettempdir()) / 'booksmith_cache'
        temp_cache.mkdir(parents=True, exist_ok=True)
        return temp_cache


def compute_cache_key(input_file: str, prompts: dict, model: str) -> str:
    """
    Compute a unique cache key based on input file, prompts, and model.

    Uses hash of:
    - Absolute path of input file
    - File modification time
    - File size
    - Serialized prompts content
    - Model name
    """
    input_path = Path(input_file).resolve()

    # Get file metadata for change detection
    file_stat = input_path.stat()
    file_mtime = file_stat.st_mtime
    file_size = file_stat.st_size

    # Create hash components
    components = [
        str(input_path),
        str(file_mtime),
        str(file_size),
        json.dumps(prompts, sort_keys=True),
        model
    ]

    # Compute hash
    combined = '|'.join(components)
    hash_digest = hashlib.sha256(combined.encode('utf-8')).hexdigest()[:16]

    return hash_digest


def get_cache_file_path(cache_key: str) -> Path:
    """Get the path to a cache file."""
    cache_dir = get_cache_dir()
    return cache_dir / f"dryrun_{cache_key}.json"


def load_cache(cache_key: str, ttl_hours: int = DEFAULT_CACHE_TTL) -> Optional[Dict[str, Any]]:
    """
    Load cached results if available and not expired.

    Args:
        cache_key: The cache key to look up
        ttl_hours: Time-to-live in hours (default: 24)

    Returns:
        Cached data dict or None if cache is missing/expired/invalid
    """
    cache_file = get_cache_file_path(cache_key)

    if not cache_file.exists():
        return None

    try:
        with open(cache_file, 'r', encoding='utf-8') as f:
            cache_data = json.load(f)

        # Check cache version
        if cache_data.get('version') != 1:
            return None

        # Check expiration
        created_str = cache_data.get('created')
        if created_str:
            created = datetime.fromisoformat(created_str)
            if datetime.now() - created > timedelta(hours=ttl_hours):
                # Cache expired
                return None

        return cache_data

    except (json.JSONDecodeError, KeyError, ValueError):
        return None


def save_cache(cache_key: str, input_file: str, prompts: dict, model: str,
               chapters: Dict[str, Dict[str, Any]]) -> Path:
    """
    Save analysis results to cache.

    Args:
        cache_key: The cache key
        input_file: Path to input EPUB
        prompts: Prompts used for analysis
        model: Model name used
        chapters: Dict of chapter filename -> chapter results

    Returns:
        Path to the saved cache file
    """
    input_path = Path(input_file).resolve()

    # Compute hashes for validation
    prompts_hash = hashlib.sha256(
        json.dumps(prompts, sort_keys=True).encode('utf-8')
    ).hexdigest()[:16]

    input_hash = hashlib.sha256(str(input_path).encode('utf-8')).hexdigest()[:16]

    cache_data = {
        'version': 1,
        'created': datetime.now().isoformat(),
        'input_file': str(input_path.name),
        'input_path': str(input_path),
        'input_hash': input_hash,
        'prompts_hash': prompts_hash,
        'model': model,
        'chapters': chapters
    }

    cache_file = get_cache_file_path(cache_key)

    with open(cache_file, 'w', encoding='utf-8') as f:
        json.dump(cache_data, f, indent=2, ensure_ascii=False)

    return cache_file


def validate_cache(cache_data: Dict[str, Any], prompts: dict, model: str) -> bool:
    """
    Validate that cached results match current prompts and model.

    Args:
        cache_data: Loaded cache data
        prompts: Current prompts
        model: Current model name

    Returns:
        True if cache is valid, False otherwise
    """
    # Check model matches
    if cache_data.get('model') != model:
        return False

    # Check prompts hash matches
    current_prompts_hash = hashlib.sha256(
        json.dumps(prompts, sort_keys=True).encode('utf-8')
    ).hexdigest()[:16]

    if cache_data.get('prompts_hash') != current_prompts_hash:
        return False

    return True


def clear_cache_for_book(input_file: str, prompts: dict, model: str) -> bool:
    """
    Clear cached results for a specific book.

    Returns True if cache was found and cleared, False otherwise.
    """
    cache_key = compute_cache_key(input_file, prompts, model)
    cache_file = get_cache_file_path(cache_key)

    if cache_file.exists():
        cache_file.unlink()
        return True
    return False


def clear_all_cache() -> int:
    """
    Clear all cached results.

    Returns the number of cache files deleted.
    """
    cache_dir = get_cache_dir()
    count = 0

    for cache_file in cache_dir.glob('dryrun_*.json'):
        try:
            cache_file.unlink()
            count += 1
        except OSError:
            pass

    return count


def count_cached_api_calls(cache_data: Dict[str, Any]) -> int:
    """
    Count how many API calls are saved by using cache.

    Each chapter that needed filtering has at least 1 analysis call.
    Each chapter with changes has 1 cleaning call.
    """
    chapters = cache_data.get('chapters', {})
    api_calls = 0

    for chapter_data in chapters.values():
        # Analysis call
        api_calls += 1

        # Cleaning call if chapter needed filtering
        if chapter_data.get('needs_filtering'):
            api_calls += 1

    return api_calls


def parse_chapter_selection(selection_str: str, max_chapters: int) -> set:
    """
    Parse chapter selection string into set of indices.

    Supports formats:
    - "1,3,5" - specific chapters
    - "1-5" - range of chapters
    - "1-3,7,9-11" - mixed
    """
    selected = set()

    parts = selection_str.split(',')
    for part in parts:
        part = part.strip()
        if '-' in part:
            # Range
            try:
                start, end = part.split('-', 1)
                start = int(start.strip())
                end = int(end.strip())
                for i in range(start, end + 1):
                    if 1 <= i <= max_chapters:
                        selected.add(i)
            except ValueError:
                print(f"Warning: Invalid range '{part}', skipping")
        else:
            # Single number
            try:
                num = int(part)
                if 1 <= num <= max_chapters:
                    selected.add(num)
            except ValueError:
                print(f"Warning: Invalid chapter number '{part}', skipping")

    return selected


def load_config(config_path: str = None) -> dict:
    """Load configuration from YAML file with fallback to defaults."""
    config = DEFAULT_CONFIG.copy()

    if config_path:
        path = Path(config_path)
        if not path.exists():
            print(f"Error: Config file not found: {config_path}")
            sys.exit(1)

        try:
            with open(path, 'r', encoding='utf-8') as f:
                user_config = yaml.safe_load(f) or {}
                config.update(user_config)
                print(f"Loaded config from: {config_path}")
        except yaml.YAMLError as e:
            print(f"Error parsing config file: {e}")
            sys.exit(1)
    else:
        # Try to find config.yaml in script directory
        script_dir = Path(__file__).parent
        default_path = script_dir / 'config.yaml'
        if default_path.exists():
            try:
                with open(default_path, 'r', encoding='utf-8') as f:
                    user_config = yaml.safe_load(f) or {}
                    config.update(user_config)
                    print(f"Loaded config from: {default_path}")
            except yaml.YAMLError as e:
                print(f"Warning: Error parsing default config: {e}")

    return config


def load_prompts(prompts_path: str = None) -> dict:
    """Load prompts from YAML file."""
    prompts = {}

    # Determine path to load
    if prompts_path:
        path = Path(prompts_path)
    else:
        # Try to find prompts.yaml in script directory
        script_dir = Path(__file__).parent
        path = script_dir / 'prompts.yaml'

    if not path.exists():
        print(f"Error: Prompts file not found: {path}")
        print("Please create a prompts.yaml file with 'analysis' and 'cleaning' sections.")
        print("See prompts.example.yaml for the expected format.")
        sys.exit(1)

    try:
        with open(path, 'r', encoding='utf-8') as f:
            prompts = yaml.safe_load(f) or {}
            print(f"Loaded prompts from: {path}")
    except yaml.YAMLError as e:
        print(f"Error parsing prompts file: {e}")
        sys.exit(1)

    # Validate required prompts
    if 'analysis' not in prompts or 'user' not in prompts.get('analysis', {}):
        print("Error: Prompts file must contain 'analysis.user' prompt")
        sys.exit(1)

    if 'cleaning' not in prompts or 'user' not in prompts.get('cleaning', {}):
        print("Error: Prompts file must contain 'cleaning.user' prompt")
        sys.exit(1)

    return prompts


def load_author_profile(profile_path: str) -> Optional[Dict[str, Any]]:
    """Load and validate an author profile JSON file."""
    if not profile_path:
        return None

    file_path = Path(profile_path)
    if not file_path.exists():
        print(f"Error: Profile file not found: {profile_path}")
        sys.exit(1)

    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            profile = json.load(f)
    except json.JSONDecodeError as e:
        print(f"Error parsing profile JSON: {e}")
        sys.exit(1)
    except Exception as e:
        print(f"Error reading profile file: {e}")
        sys.exit(1)

    # Basic validation - check for required fields per schema
    if 'overall_style' not in profile:
        # Check if profile is from style_profiler.py format (has style_analysis)
        if 'style_analysis' in profile and profile['style_analysis']:
            # Convert style_profiler output to expected format
            print("  Converting style_profiler format to author_profile format...")
            profile = convert_profiler_to_profile(profile)
        else:
            print("Warning: Profile missing 'overall_style' field")

    print(f"Loaded author profile from: {profile_path}")
    return profile


def convert_profiler_to_profile(profiler_output: Dict[str, Any]) -> Dict[str, Any]:
    """Convert style_profiler.py output to author_profile.schema.json format."""
    profile = {}

    # Build overall_style from style_analysis
    style_analysis = profiler_output.get('style_analysis', {})
    if style_analysis:
        parts = []
        if 'overall_summary' in style_analysis:
            parts.append(style_analysis['overall_summary'])
        prose = style_analysis.get('prose_style', {})
        if prose:
            if 'narrative_voice' in prose:
                parts.append(f"Narrative voice: {prose['narrative_voice']}")
            if 'tone' in prose:
                parts.append(f"Tone: {prose['tone']}")
            if 'sentence_structure' in prose:
                parts.append(f"Sentence structure: {prose['sentence_structure']}")
        profile['overall_style'] = ' '.join(parts) if parts else 'No style description available.'

    # Build do_list from guidelines
    guidelines = profiler_output.get('guidelines', {})
    if guidelines:
        do_items = guidelines.get('do_list', [])
        profile['do_list'] = []
        for item in do_items:
            if isinstance(item, dict):
                guideline = item.get('guideline', '')
                example = item.get('example', '')
                profile['do_list'].append(f"{guideline} (e.g., {example})" if example else guideline)
            else:
                profile['do_list'].append(str(item))

        avoid_items = guidelines.get('avoid_list', [])
        profile['avoid_list'] = []
        for item in avoid_items:
            if isinstance(item, dict):
                guideline = item.get('guideline', '')
                why = item.get('why', '')
                profile['avoid_list'].append(f"{guideline} ({why})" if why else guideline)
            else:
                profile['avoid_list'].append(str(item))

        # Add style_anchors to do_list
        for anchor in guidelines.get('style_anchors', []):
            profile['do_list'].append(f"[ESSENTIAL] {anchor}")

    # Extract sample passages
    profile['example_passages'] = []
    for passage in profiler_output.get('sample_passages', []):
        if isinstance(passage, str):
            profile['example_passages'].append({'text': passage})
        elif isinstance(passage, dict):
            profile['example_passages'].append(passage)

    # Copy metadata
    if 'metadata' in profiler_output:
        profile['metadata'] = profiler_output['metadata']

    return profile


def build_style_guidance(profile: Dict[str, Any]) -> str:
    """Build a STYLE GUIDANCE section to inject into cleaning prompts."""
    if not profile:
        return ""

    sections = []
    sections.append("\n\n=== STYLE GUIDANCE ===")
    sections.append("Preserve the author's voice and style. Follow these guidelines:\n")

    # Overall style description
    if 'overall_style' in profile:
        sections.append("OVERALL STYLE:")
        sections.append(profile['overall_style'])
        sections.append("")

    # Do list
    do_list = profile.get('do_list', [])
    if do_list:
        sections.append("DO (emulate these patterns):")
        for item in do_list[:15]:  # Limit to avoid token bloat
            if isinstance(item, str):
                sections.append(f"  - {item}")
            elif isinstance(item, dict):
                sections.append(f"  - {item.get('guideline', item)}")
        sections.append("")

    # Avoid list
    avoid_list = profile.get('avoid_list', [])
    if avoid_list:
        sections.append("AVOID (do not use these patterns):")
        for item in avoid_list[:15]:
            if isinstance(item, str):
                sections.append(f"  - {item}")
            elif isinstance(item, dict):
                sections.append(f"  - {item.get('guideline', item)}")
        sections.append("")

    # Sample passages for reference
    example_passages = profile.get('example_passages', [])
    if example_passages:
        sections.append("REFERENCE PASSAGES (match this style):")
        for i, passage in enumerate(example_passages[:3], 1):  # Limit to 3
            if isinstance(passage, str):
                text = passage[:500]  # Truncate long passages
            else:
                text = passage.get('text', '')[:500]
            sections.append(f"  Example {i}: \"{text}...\"")
        sections.append("")

    # Vocabulary notes
    vocab = profile.get('vocabulary', {})
    if vocab:
        sig_phrases = vocab.get('signature_phrases', [])
        if sig_phrases:
            phrases = []
            for p in sig_phrases[:5]:
                if isinstance(p, str):
                    phrases.append(p)
                elif isinstance(p, dict):
                    phrases.append(p.get('phrase', ''))
            if phrases:
                sections.append(f"SIGNATURE PHRASES: {', '.join(phrases)}")

        avoided_words = vocab.get('avoided_words', [])
        if avoided_words:
            sections.append(f"WORDS TO AVOID: {', '.join(avoided_words[:10])}")
        sections.append("")

    sections.append("=== END STYLE GUIDANCE ===\n")

    return '\n'.join(sections)


def create_client(config: dict):
    """Create LLM client based on configuration."""
    provider = config.get('provider', 'anthropic')

    if provider == 'anthropic':
        if not anthropic:
            print("Error: anthropic package not installed")
            sys.exit(1)

        api_key = os.environ.get('ANTHROPIC_API_KEY')
        if not api_key:
            print("Error: ANTHROPIC_API_KEY environment variable not set")
            print("Set it with: export ANTHROPIC_API_KEY='your-api-key'")
            sys.exit(1)

        return anthropic.Anthropic(api_key=api_key)
    else:
        print(f"Error: Unsupported provider: {provider}")
        print("Currently supported: anthropic")
        sys.exit(1)


def extract_chapter_info(soup, chapter_selectors: list) -> str:
    """Extract chapter title/number from HTML content."""
    for selector in chapter_selectors:
        elements = soup.select(selector)
        for element in elements:
            text = element.get_text().strip()
            if text and (
                'chapter' in text.lower() or
                text.lower() in ['prologue', 'epilogue'] or
                re.match(r'^\d+$', text) or
                re.match(r'^[ivxlcdm]+$', text.lower()) or
                len(text) < 100
            ):
                return text[:50]

    return None


def analyze_chapter_with_claude(client, config: dict, prompts: dict, chapter_text: str) -> bool:
    """Analyze entire chapter to determine if it needs filtering."""
    if not client or len(chapter_text.strip()) < 100:
        return False

    try:
        analysis_prompt = prompts['analysis']['user'].replace('{chapter_text}', chapter_text)
        system_prompt = prompts['analysis'].get('system', '')

        messages = [{"role": "user", "content": analysis_prompt}]

        kwargs = {
            'model': config['model'],
            'max_tokens': config['max_tokens_analysis'],
            'messages': messages
        }

        if system_prompt:
            kwargs['system'] = system_prompt

        response = client.messages.create(**kwargs)

        result = response.content[0].text.strip().upper()

        if config['rate_limit_delay'] > 0:
            time.sleep(config['rate_limit_delay'])

        return result == "FILTER"

    except Exception as e:
        print(f"    Error during analysis: {e}")
        return False


def clean_chapter_selectively(client, config: dict, prompts: dict, paragraphs: list,
                              style_guidance: str = "") -> dict:
    """
    Send full chapter for context, but only get back problematic paragraphs.
    Returns dict of {paragraph_index: cleaned_text}
    """
    if not client or not paragraphs:
        return {}

    try:
        # Create numbered chapter for context
        numbered_lines = []
        for i, p in enumerate(paragraphs, 1):
            numbered_lines.append(f"[PARAGRAPH {i}]")
            numbered_lines.append(p)
            numbered_lines.append("")

        numbered_chapter = "\n".join(numbered_lines)

        # Replace placeholder in cleaning prompt
        cleaning_prompt = prompts['cleaning']['user'].replace('{numbered_chapter}', numbered_chapter)

        # Inject style guidance if provided
        if style_guidance:
            cleaning_prompt = style_guidance + "\n" + cleaning_prompt

        system_prompt = prompts['cleaning'].get('system', '')

        print(f"    Sending full chapter for context...")
        if style_guidance:
            print(f"    Style guidance injected from author profile...")
        print(f"    Claude will only rewrite problematic paragraphs...")

        messages = [{"role": "user", "content": cleaning_prompt}]

        kwargs = {
            'model': config['model'],
            'max_tokens': config['max_tokens_cleaning'],
            'messages': messages
        }

        if system_prompt:
            kwargs['system'] = system_prompt

        response = client.messages.create(**kwargs)

        # Extract response
        output = ""
        for block in response.content:
            if hasattr(block, 'text'):
                output += block.text

        output = output.strip()

        if config['rate_limit_delay'] > 0:
            time.sleep(config['rate_limit_delay'])

        # Parse output
        if output.upper() == "NONE":
            print(f"    Claude found no paragraphs needing changes")
            return {}

        # Parse PARAGRAPH N: text format
        result = {}
        current_num = None
        current_text = []

        for line in output.split('\n'):
            # Check for PARAGRAPH N: format
            match = re.match(r'^PARAGRAPH\s+(\d+):\s*(.*)$', line)
            if match:
                # Save previous paragraph if any
                if current_num is not None and current_text:
                    result[current_num - 1] = ' '.join(current_text).strip()

                # Start new paragraph
                current_num = int(match.group(1))
                text_start = match.group(2).strip()
                current_text = [text_start] if text_start else []
            elif current_num is not None:
                # Continuation of current paragraph
                current_text.append(line.strip())

        # Save last paragraph
        if current_num is not None and current_text:
            result[current_num - 1] = ' '.join(current_text).strip()

        if result:
            print(f"    Rewrote {len(result)} paragraphs: {sorted([i+1 for i in result.keys()])}")
        else:
            print(f"    Warning: Could not parse Claude's response")
            print(f"    Response preview: {output[:200]}...")

        return result

    except Exception as e:
        print(f"    Error during cleaning: {e}")
        import traceback
        traceback.print_exc()
        return {}


def validate_style_drift(client, config: dict, original_text: str, modified_text: str,
                         profile: Optional[Dict[str, Any]] = None,
                         verbose: bool = False) -> Optional[Dict[str, Any]]:
    """
    Validate style drift between original and modified text.
    Uses style_validator module if available, otherwise uses inline LLM call.

    Returns dict with:
        - overall_score: 0-100 (100 = no drift)
        - dimensions: list of {name, score, description}
        - recommendations: list of suggestions
    """
    try:
        # Try to import style_validator module
        from style_validator import validate_style, result_to_dict
        result = validate_style(
            original_text=original_text,
            modified_text=modified_text,
            profile=profile,
            model=config['model'],
            verbose=verbose
        )
        return result_to_dict(result)
    except ImportError:
        # Fallback: inline LLM-based validation
        if verbose:
            print("    style_validator module not found, using inline validation...")
        return _inline_validate_drift(client, config, original_text, modified_text, profile)


def _inline_validate_drift(client, config: dict, original_text: str, modified_text: str,
                           profile: Optional[Dict[str, Any]] = None) -> Optional[Dict[str, Any]]:
    """Inline style drift validation when style_validator module is not available."""
    if not client:
        return None

    try:
        prompt = f"""Compare the original and modified text below. Rate how well the modified version preserves the style of the original on a scale of 0-100 (100 = identical style, 0 = completely different).

ORIGINAL:
{original_text[:5000]}

MODIFIED:
{modified_text[:5000]}

Respond with ONLY a JSON object in this format:
{{
    "overall_score": <0-100>,
    "assessment": "<brief explanation of style preservation>",
    "dimensions": [
        {{"name": "tone", "score": <0-100>}},
        {{"name": "vocabulary", "score": <0-100>}},
        {{"name": "sentence_structure", "score": <0-100>}}
    ]
}}"""

        response = client.messages.create(
            model=config['model'],
            max_tokens=500,
            messages=[{"role": "user", "content": prompt}]
        )

        result_text = response.content[0].text.strip()

        # Parse JSON from response
        if '```json' in result_text:
            start = result_text.find('```json') + 7
            end = result_text.find('```', start)
            result_text = result_text[start:end].strip()
        elif '```' in result_text:
            start = result_text.find('```') + 3
            end = result_text.find('```', start)
            result_text = result_text[start:end].strip()

        return json.loads(result_text)

    except Exception as e:
        print(f"    Warning: Style drift validation failed: {e}")
        return None


def extract_paragraphs(soup, selectors: list) -> tuple:
    """Extract paragraphs matching any of the configured selectors."""
    paragraphs = []
    paragraph_elements = []
    seen_elements = set()

    for selector in selectors:
        try:
            for p in soup.select(selector):
                # Avoid duplicates
                if id(p) in seen_elements:
                    continue
                seen_elements.add(id(p))

                text = p.get_text().strip()
                if text:
                    paragraphs.append(text)
                    paragraph_elements.append(p)
        except Exception as e:
            print(f"    Warning: Invalid selector '{selector}': {e}")

    return paragraphs, paragraph_elements


def process_epub(input_path: str, output_path: str, config: dict, prompts: dict,
                 client, dry_run: bool = False, profile: Optional[Dict[str, Any]] = None,
                 max_drift: Optional[int] = None, validate_drift: bool = False,
                 chapter_filter: Optional[set] = None,
                 use_cache: bool = True, no_cache: bool = False,
                 cache_ttl: int = DEFAULT_CACHE_TTL):
    """Process EPUB using optimal selective filtering.

    Args:
        chapter_filter: Set of chapter indices (1-based) to process, or None for all
        use_cache: Use cached results if available (default: True)
        no_cache: Force fresh analysis, ignore cache (default: False)
        cache_ttl: Cache time-to-live in hours (default: 24)
    """

    start_time = time.time()

    stats = {
        'chapters_analyzed': 0,
        'chapters_filtered': 0,
        'files_modified': 0,
        'paragraphs_changed': 0,
        'drift_warnings': 0,
        'total_drift_score': 0,
        'drift_validations': 0,
        'cache_hits': 0,
        'api_calls_saved': 0
    }

    modified_chapters = []
    change_log = []
    drift_log = []

    # Cache tracking for dry-run mode
    cache_results = {}  # Will store chapter results for caching

    # Build style guidance from profile
    style_guidance = build_style_guidance(profile) if profile else ""

    # Check for cached results (if not in dry-run mode and not forcing fresh)
    cache_key = compute_cache_key(input_path, prompts, config['model'])
    cache_data = None
    using_cache = False

    if not dry_run and use_cache and not no_cache:
        cache_data = load_cache(cache_key, cache_ttl)
        if cache_data and validate_cache(cache_data, prompts, config['model']):
            using_cache = True
            api_calls_saved = count_cached_api_calls(cache_data)
            stats['api_calls_saved'] = api_calls_saved

    print("\n" + "="*60)
    print("EPUB LLM Cleaner")
    print("Full context + Selective rewriting")
    print("="*60)
    print(f"Model: {config['model']}")
    print(f"Input: {input_path}")
    print(f"Output: {output_path}")
    if chapter_filter:
        print(f"Chapters: {sorted(chapter_filter)}")
    if profile:
        author = profile.get('metadata', {}).get('author_name', 'Unknown')
        print(f"Style Profile: {author}")
    if max_drift is not None:
        print(f"Max Drift Threshold: {max_drift}%")
    if dry_run:
        print("MODE: DRY RUN (no changes will be saved)")
        print("Results will be cached for subsequent runs")
    if using_cache:
        cache_created = cache_data.get('created', 'unknown')
        print(f"\nUsing cached analysis from dry run (saved {stats['api_calls_saved']} API calls)")
        print(f"Cache created: {cache_created}")
    print()

    with tempfile.TemporaryDirectory() as temp_dir:
        temp_path = Path(temp_dir)
        extract_path = temp_path / "epub_extracted"

        print("Extracting EPUB...")
        with zipfile.ZipFile(input_path, 'r') as zip_ref:
            zip_ref.extractall(extract_path)

        print("Processing chapters...")

        html_files = list(extract_path.rglob('*.html')) + list(extract_path.rglob('*.xhtml'))
        print(f"Found {len(html_files)} HTML files")
        if chapter_filter:
            print(f"Processing {len(chapter_filter)} selected chapters\n")
        else:
            print()

        for i, html_file in enumerate(html_files, 1):
            # Skip if chapter filter is set and this chapter is not selected
            if chapter_filter and i not in chapter_filter:
                continue

            chapter_start = time.time()
            chapter_filename = html_file.name
            print(f"Processing {chapter_filename} ({i}/{len(html_files)})")

            with open(html_file, 'r', encoding='utf-8') as f:
                content = f.read()

            soup = BeautifulSoup(content, 'html.parser')

            chapter_info = extract_chapter_info(soup, config['chapter_selectors'])
            chapter_display = chapter_info if chapter_info else html_file.stem
            print(f"  Chapter: {chapter_display}")

            # Extract paragraphs using configured selectors
            paragraphs, paragraph_elements = extract_paragraphs(
                soup, config['paragraph_selectors']
            )

            if not paragraphs:
                print("  No paragraphs found, skipping\n")
                continue

            print(f"  Found {len(paragraphs)} paragraphs")

            # Quick analysis
            stats['chapters_analyzed'] += 1
            chapter_text = "\n\n".join(paragraphs)
            original_chapter_text = chapter_text  # Save for drift comparison

            # Check if we have cached results for this chapter
            cached_chapter = None
            if using_cache and cache_data:
                cached_chapter = cache_data.get('chapters', {}).get(chapter_filename)

            if cached_chapter:
                # Use cached analysis result
                print(f"  Using cached analysis...")
                needs_filtering = cached_chapter.get('needs_filtering', False)
                stats['cache_hits'] += 1
            else:
                # Run fresh analysis
                print(f"  Analyzing...")
                needs_filtering = analyze_chapter_with_claude(client, config, prompts, chapter_text)

            if needs_filtering:
                print(f"  Chapter needs filtering")
                stats['chapters_filtered'] += 1

                # Check for cached cleaning results
                cached_changes = None
                if cached_chapter and cached_chapter.get('changes'):
                    cached_changes = cached_chapter.get('changes')
                    print(f"  Using cached cleaning results...")

                if cached_changes:
                    # Use cached cleaning results
                    # Convert cached changes (string keys) to cleaned_dict format (int keys)
                    cleaned_dict = {}
                    for para_str, cleaned_text in cached_changes.items():
                        try:
                            para_idx = int(para_str) - 1  # Convert 1-based to 0-based
                            cleaned_dict[para_idx] = cleaned_text
                        except ValueError:
                            continue
                else:
                    # Get selective rewrites with style guidance
                    cleaned_dict = clean_chapter_selectively(
                        client, config, prompts, paragraphs, style_guidance
                    )

                if cleaned_dict:
                    # Apply changes
                    file_modified = False
                    chapter_changes = []

                    # Prepare cache entry for this chapter
                    chapter_cache_changes = {}

                    for idx, cleaned_text in cleaned_dict.items():
                        if idx >= len(paragraphs):
                            print(f"    Warning: Invalid paragraph index {idx+1}")
                            continue

                        original_text = paragraphs[idx]
                        if original_text != cleaned_text and cleaned_text:
                            stats['paragraphs_changed'] += 1
                            file_modified = True

                            # Check if this is a removal instruction
                            is_removal = cleaned_text.strip().startswith('[PARAGRAPH REMOVED')

                            # Store for cache (use 1-based string keys for JSON)
                            chapter_cache_changes[str(idx + 1)] = cleaned_text

                            chapter_changes.append({
                                'paragraph_num': idx + 1,
                                'original': original_text,
                                'cleaned': '[REMOVED]' if is_removal else cleaned_text
                            })

                            change_log.append({
                                'chapter': chapter_display,
                                'file': html_file.name,
                                'paragraph_num': idx + 1,
                                'original': original_text,
                                'cleaned': '[REMOVED]' if is_removal else cleaned_text,
                                'original_length': len(original_text),
                                'cleaned_length': 0 if is_removal else len(cleaned_text)
                            })

                            if not dry_run:
                                # Update HTML
                                p_element = paragraph_elements[idx]
                                if is_removal:
                                    # Remove the paragraph entirely from the DOM
                                    p_element.decompose()
                                else:
                                    # Replace paragraph content
                                    original_attrs = dict(p_element.attrs)
                                    p_element.clear()
                                    p_element.string = cleaned_text
                                    p_element.attrs.update(original_attrs)

                    # Store chapter results for cache
                    cache_results[chapter_filename] = {
                        'needs_filtering': True,
                        'changes': chapter_cache_changes,
                        'chapter_display': chapter_display
                    }

                    # Validate style drift if profile is provided and changes were made
                    if file_modified and (profile or validate_drift) and chapter_changes:
                        # Build modified chapter text
                        modified_paragraphs = paragraphs.copy()
                        for change in chapter_changes:
                            idx = change['paragraph_num'] - 1
                            if change['cleaned'] != '[REMOVED]':
                                modified_paragraphs[idx] = change['cleaned']
                            else:
                                modified_paragraphs[idx] = ''  # Mark as removed

                        modified_chapter_text = "\n\n".join(p for p in modified_paragraphs if p)

                        print(f"    Validating style drift...")
                        drift_result = validate_style_drift(
                            client, config,
                            original_chapter_text,
                            modified_chapter_text,
                            profile
                        )

                        if drift_result:
                            drift_score = drift_result.get('overall_score', 100)
                            drift_pct = 100 - drift_score  # Convert to drift percentage

                            stats['drift_validations'] += 1
                            stats['total_drift_score'] += drift_score

                            drift_log.append({
                                'chapter': chapter_display,
                                'file': html_file.name,
                                'drift_score': drift_score,
                                'drift_percentage': drift_pct,
                                'dimensions': drift_result.get('dimensions', []),
                                'assessment': drift_result.get('assessment',
                                             drift_result.get('overall_assessment', ''))
                            })

                            # Update change log entries with drift info
                            for change in change_log:
                                if change['chapter'] == chapter_display:
                                    change['drift_score'] = drift_score
                                    change['drift_percentage'] = drift_pct

                            print(f"    Style preservation: {drift_score}/100 (drift: {drift_pct}%)")

                            # Check against max_drift threshold
                            if max_drift is not None and drift_pct > max_drift:
                                stats['drift_warnings'] += 1
                                print(f"    WARNING: Drift {drift_pct}% exceeds threshold {max_drift}%!")
                                print(f"    Consider reviewing changes for this chapter.")
                                # Future: could implement retry logic here

                    if file_modified:
                        if not dry_run:
                            with open(html_file, 'w', encoding='utf-8') as f:
                                f.write(str(soup))
                        stats['files_modified'] += 1
                        modified_chapters.append(chapter_display)

                chapter_time = time.time() - chapter_start
                print(f"  Processed in {chapter_time:.1f}s\n")
            else:
                # Chapter doesn't need filtering - store in cache too
                if chapter_filename not in cache_results:
                    cache_results[chapter_filename] = {
                        'needs_filtering': False,
                        'changes': {},
                        'chapter_display': chapter_display
                    }
                chapter_time = time.time() - chapter_start
                print(f"  Chapter clean ({chapter_time:.1f}s)\n")

        # Save cache after dry run
        if dry_run and cache_results:
            cache_file = save_cache(cache_key, input_path, prompts, config['model'], cache_results)
            print(f"\nCache saved: {cache_file}")
            print(f"Run without --dry-run to apply changes using cached analysis")

        if not dry_run:
            print("Rebuilding EPUB...")
            with zipfile.ZipFile(output_path, 'w', zipfile.ZIP_DEFLATED) as zip_out:
                for file_path in extract_path.rglob('*'):
                    if file_path.is_file():
                        arcname = file_path.relative_to(extract_path)
                        zip_out.write(file_path, arcname)

        total_time = time.time() - start_time

        # Report results
        print("\n" + "="*60)
        print("PROCESSING COMPLETE" + (" (DRY RUN)" if dry_run else ""))
        print("="*60)
        print(f"Total time: {total_time:.1f} seconds ({total_time/60:.1f} minutes)")
        print(f"Chapters analyzed: {stats['chapters_analyzed']}")
        print(f"Chapters filtered: {stats['chapters_filtered']}")
        print(f"Paragraphs changed: {stats['paragraphs_changed']}")
        print(f"Files modified: {stats['files_modified']}")

        # Cache statistics
        if using_cache:
            print(f"\nCache Usage:")
            print(f"  Chapters from cache: {stats['cache_hits']}")
            print(f"  API calls saved: {stats['api_calls_saved']}")

        # Drift statistics
        if stats['drift_validations'] > 0:
            avg_preservation = stats['total_drift_score'] / stats['drift_validations']
            print(f"\nStyle Preservation:")
            print(f"  Average score: {avg_preservation:.1f}/100")
            print(f"  Chapters validated: {stats['drift_validations']}")
            if stats['drift_warnings'] > 0:
                print(f"  Drift warnings: {stats['drift_warnings']}")

        if modified_chapters:
            print(f"\nChapters modified:")
            for chapter in modified_chapters:
                print(f"  - {chapter}")

        # Generate report
        if change_log:
            report_path = output_path.replace('.epub', '_changes_report.txt')

            report_content = []
            report_content.append("EPUB LLM CLEANER - CHANGE REPORT")
            report_content.append("(Full context preserved, only problematic paragraphs rewritten)")
            report_content.append("=" * 60)
            report_content.append("")
            report_content.append(f"Input: {input_path}")
            report_content.append(f"Output: {output_path}")
            report_content.append(f"Model: {config['model']}")
            if profile:
                author = profile.get('metadata', {}).get('author_name', 'Unknown')
                report_content.append(f"Style Profile: {author}")
            if max_drift is not None:
                report_content.append(f"Max Drift Threshold: {max_drift}%")
            report_content.append(f"Processing time: {total_time:.1f} seconds")
            report_content.append(f"Paragraphs changed: {stats['paragraphs_changed']}")
            if stats['drift_validations'] > 0:
                avg_preservation = stats['total_drift_score'] / stats['drift_validations']
                report_content.append(f"Average style preservation: {avg_preservation:.1f}/100")
            if dry_run:
                report_content.append("MODE: DRY RUN (no changes saved)")
            report_content.append("")

            # Drift summary by chapter
            if drift_log:
                report_content.append("\n" + "=" * 60)
                report_content.append("STYLE DRIFT SUMMARY BY CHAPTER")
                report_content.append("=" * 60)
                for drift_entry in drift_log:
                    score = drift_entry['drift_score']
                    pct = drift_entry['drift_percentage']
                    indicator = ""
                    if score >= 90:
                        indicator = "[EXCELLENT]"
                    elif score >= 75:
                        indicator = "[GOOD]"
                    elif score >= 50:
                        indicator = "[MODERATE]"
                    else:
                        indicator = "[SIGNIFICANT DRIFT]"

                    report_content.append(f"\n{drift_entry['chapter']}: {score}/100 {indicator}")
                    if drift_entry.get('assessment'):
                        report_content.append(f"  {drift_entry['assessment']}")
                report_content.append("")

            # Individual changes
            report_content.append("\n" + "=" * 60)
            report_content.append("DETAILED CHANGES")
            report_content.append("=" * 60)

            for i, change in enumerate(change_log, 1):
                report_content.append(f"\nChange #{i}: {change['chapter']} - Paragraph {change['paragraph_num']}")
                if 'drift_score' in change:
                    report_content.append(f"Style preservation: {change['drift_score']}/100")
                report_content.append("-" * 60)
                report_content.append(f"ORIGINAL ({change['original_length']} chars):\n{change['original']}\n")
                report_content.append(f"CLEANED ({change['cleaned_length']} chars):\n{change['cleaned']}")
                report_content.append("=" * 60)

            if not dry_run:
                with open(report_path, 'w', encoding='utf-8') as f:
                    f.write('\n'.join(report_content))
                print(f"\nReport saved: {report_path}")
            else:
                print("\n--- DRY RUN CHANGE PREVIEW ---")
                for change in change_log[:3]:  # Show first 3 changes
                    print(f"\n{change['chapter']} - Paragraph {change['paragraph_num']}:")
                    if 'drift_score' in change:
                        print(f"  Style preservation: {change['drift_score']}/100")
                    print(f"  Original: {change['original'][:100]}...")
                    print(f"  Cleaned: {change['cleaned'][:100]}...")
                if len(change_log) > 3:
                    print(f"\n... and {len(change_log) - 3} more changes")

        print("="*60)


def main():
    """Main entry point with CLI argument parsing."""
    parser = argparse.ArgumentParser(
        description='EPUB LLM Cleaner - Selectively rewrite paragraphs using LLM analysis',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  %(prog)s --input book.epub --output book_cleaned.epub
  %(prog)s --input book.epub --dry-run
  %(prog)s --config my_config.yaml --prompts my_prompts.yaml --input book.epub
  %(prog)s --input book.epub --profile author_profile.json --max-drift 30

Dry Run Caching:
  When you run with --dry-run, analysis results are cached automatically.
  Running again without --dry-run will reuse the cached results to save API credits.

  Example workflow:
    1. %(prog)s --input book.epub --dry-run     # Preview changes (results cached)
    2. %(prog)s --input book.epub               # Apply changes using cache

  Cache options:
    --no-cache       Force fresh analysis, ignore any cached results
    --clear-cache    Clear cached results for this book and exit
    --cache-ttl N    Cache expires after N hours (default: 24)

Style Preservation:
  Use --profile to load an author style profile (from style_profiler.py).
  Use --max-drift to set a threshold (0-100) for acceptable style drift.
  When drift exceeds the threshold, a warning is shown.

Environment variables:
  ANTHROPIC_API_KEY    Your Anthropic API key (required for Claude)
        """
    )

    parser.add_argument(
        '--input', '-i',
        required=True,
        help='Input EPUB file path'
    )

    parser.add_argument(
        '--output', '-o',
        help='Output EPUB file path (default: input_cleaned.epub)'
    )

    parser.add_argument(
        '--config', '-c',
        help='Path to config.yaml file (default: ./config.yaml)'
    )

    parser.add_argument(
        '--prompts', '-p',
        help='Path to prompts.yaml file (default: ./prompts.yaml)'
    )

    parser.add_argument(
        '--profile',
        help='Path to author style profile JSON file (from style_profiler.py)'
    )

    parser.add_argument(
        '--max-drift',
        type=int,
        choices=range(0, 101),
        metavar='0-100',
        help='Maximum acceptable style drift percentage (0-100). Warn if exceeded.'
    )

    parser.add_argument(
        '--validate-drift',
        action='store_true',
        help='Validate style drift even without a profile'
    )

    parser.add_argument(
        '--dry-run', '-n',
        action='store_true',
        help='Analyze and report changes without modifying files'
    )

    parser.add_argument(
        '--verbose', '-v',
        action='store_true',
        help='Enable verbose output'
    )

    parser.add_argument(
        '--chapters',
        help='Chapter indices to process (e.g., "1,3,5" or "1-10" or "5-10,15,20-25")'
    )

    parser.add_argument(
        '--model', '-m',
        help='Override the model from config (e.g., claude-sonnet-4-5-20250929)'
    )

    # Quality assurance options
    parser.add_argument(
        '--borderline-review',
        action='store_true',
        help='Analyze content categories and let user choose which borderline content to filter'
    )

    parser.add_argument(
        '--passes',
        type=int,
        default=1,
        choices=range(1, 4),
        metavar='1-3',
        help='Maximum filter passes (default: 1). More passes = more thorough but higher cost.'
    )

    parser.add_argument(
        '--verify',
        action='store_true',
        help='Run verification pass to confirm no content was missed'
    )

    parser.add_argument(
        '--filter-profile',
        choices=['strict', 'moderate', 'minimal'],
        help='Apply a preset filter profile (strict=filter all, moderate=ask borderline, minimal=explicit only)'
    )

    parser.add_argument(
        '--non-interactive',
        action='store_true',
        help='Run without user prompts (use saved preferences for borderline decisions)'
    )

    # Cache options
    parser.add_argument(
        '--use-cache',
        action='store_true',
        default=True,
        help='Use cached results if available (default: True)'
    )

    parser.add_argument(
        '--no-cache',
        action='store_true',
        help='Force fresh analysis, ignore any cached results'
    )

    parser.add_argument(
        '--clear-cache',
        action='store_true',
        help='Clear cached results for this book and exit'
    )

    parser.add_argument(
        '--cache-ttl',
        type=int,
        default=DEFAULT_CACHE_TTL,
        metavar='HOURS',
        help=f'Cache time-to-live in hours (default: {DEFAULT_CACHE_TTL})'
    )

    args = parser.parse_args()

    # Validate input file
    input_path = Path(args.input)
    if not input_path.exists():
        print(f"Error: Input file not found: {args.input}")
        sys.exit(1)

    if not input_path.suffix.lower() == '.epub':
        print(f"Warning: Input file does not have .epub extension: {args.input}")

    # Determine output path
    if args.output:
        output_path = args.output
    else:
        output_path = str(input_path.with_stem(input_path.stem + '_cleaned'))

    # Load configuration and prompts
    config = load_config(args.config)
    prompts = load_prompts(args.prompts)

    # Override model if specified
    if args.model:
        config['model'] = args.model
        print(f"Model override: {args.model}")

    # Handle --clear-cache option
    if args.clear_cache:
        cache_key = compute_cache_key(str(input_path), prompts, config['model'])
        if clear_cache_for_book(str(input_path), prompts, config['model']):
            print(f"Cache cleared for: {input_path.name}")
        else:
            print(f"No cache found for: {input_path.name}")
        print(f"Cache directory: {get_cache_dir()}")
        sys.exit(0)

    # Load author profile if provided
    profile = load_author_profile(args.profile)

    # Create LLM client
    client = create_client(config)

    # Parse chapter selection if provided
    chapter_filter = None
    if args.chapters:
        # Count HTML files to determine max chapters
        with tempfile.TemporaryDirectory() as temp_dir:
            temp_path = Path(temp_dir)
            extract_path = temp_path / "epub_extracted"
            with zipfile.ZipFile(str(input_path), 'r') as zip_ref:
                zip_ref.extractall(extract_path)
            html_files = list(extract_path.rglob('*.html')) + list(extract_path.rglob('*.xhtml'))
            max_chapters = len(html_files)
        chapter_filter = parse_chapter_selection(args.chapters, max_chapters)
        if not chapter_filter:
            print("Error: No valid chapters selected")
            sys.exit(1)

    # Handle borderline review workflow
    borderline_categories = []
    if args.borderline_review:
        try:
            from borderline_reviewer import BorderlineReviewer, FilterPreferences

            print("\n" + "=" * 60)
            print("BORDERLINE CONTENT REVIEW")
            print("Analyzing content categories before filtering...")
            print("=" * 60 + "\n")

            # Load preferences
            preferences = FilterPreferences()

            # Apply filter profile if specified
            if args.filter_profile:
                preferences.apply_profile(args.filter_profile)
                preferences.save()

            # Create reviewer
            reviewer = BorderlineReviewer(client, config['model'], preferences)

            # Analyze chapters to find borderline content
            all_borderline = []
            with tempfile.TemporaryDirectory() as temp_dir:
                temp_path = Path(temp_dir)
                extract_path = temp_path / "epub_extracted"
                with zipfile.ZipFile(str(input_path), 'r') as zip_ref:
                    zip_ref.extractall(extract_path)

                html_files = list(extract_path.rglob('*.html')) + list(extract_path.rglob('*.xhtml'))

                for i, html_file in enumerate(html_files, 1):
                    # Skip if chapter filter is set and this chapter is not selected
                    if chapter_filter and i not in chapter_filter:
                        continue

                    print(f"Analyzing {html_file.name} ({i}/{len(html_files)})...")

                    with open(html_file, 'r', encoding='utf-8') as f:
                        content = f.read()

                    soup = BeautifulSoup(content, 'html.parser')
                    paragraphs = [p.get_text().strip() for p in soup.find_all('p') if p.get_text().strip()]

                    if paragraphs:
                        chapter_text = "\n\n".join(paragraphs)
                        result = reviewer.analyze_chapter(chapter_text)
                        if result.get("borderline"):
                            all_borderline.extend(result["borderline"])

            # Aggregate and present borderline items
            if all_borderline:
                from borderline_reviewer import aggregate_borderline_results
                aggregated = aggregate_borderline_results([{"borderline": all_borderline}])
                borderline_list = list(aggregated.values())

                # Present choices to user
                borderline_categories = reviewer.present_borderline_choices(
                    borderline_list,
                    interactive=not args.non_interactive
                )

                if borderline_categories:
                    print(f"\nWill filter these additional categories: {borderline_categories}")
                    # Add selected categories to the prompts
                    additional_criteria = reviewer.get_categories_for_prompt(borderline_categories)
                    if additional_criteria and 'cleaning' in prompts:
                        prompts['cleaning']['user'] = prompts['cleaning']['user'].replace(
                            "Here is the chapter with numbered paragraphs:",
                            additional_criteria + "\n\nHere is the chapter with numbered paragraphs:"
                        )
            else:
                print("No borderline content detected.")

        except ImportError as e:
            print(f"Warning: Could not load borderline reviewer: {e}")
            print("Continuing with standard filtering...")

    # Process the EPUB (potentially multiple passes)
    current_pass = 1
    max_passes = args.passes if args.passes else 1

    while current_pass <= max_passes:
        if max_passes > 1:
            print(f"\n{'=' * 60}")
            print(f"FILTER PASS {current_pass} of {max_passes}")
            print("=" * 60)

        # Use output from previous pass as input for next pass
        current_input = str(input_path) if current_pass == 1 else output_path

        process_epub(
            input_path=current_input,
            output_path=output_path,
            config=config,
            prompts=prompts,
            client=client,
            dry_run=args.dry_run,
            profile=profile,
            max_drift=args.max_drift,
            validate_drift=args.validate_drift,
            chapter_filter=chapter_filter,
            use_cache=args.use_cache,
            no_cache=args.no_cache,
            cache_ttl=args.cache_ttl
        )

        # If verify is enabled and not dry run, check if more passes needed
        if args.verify and not args.dry_run and current_pass < max_passes:
            print("\nRunning verification pass...")
            # TODO: Implement verification logic
            # For now, just continue to next pass
            pass

        current_pass += 1

    # Final verification if requested
    if args.verify and not args.dry_run:
        print("\n" + "=" * 60)
        print("FINAL VERIFICATION")
        print("=" * 60)
        print("Verification pass checking for missed content...")
        # TODO: Implement full verification logic
        print("Verification complete. (Full verification logic coming soon)")


if __name__ == "__main__":
    main()