interactive.py

#!/usr/bin/env python3
"""
EPUB LLM Cleaner - Interactive Mode

Guided interactive mode for complex changes. Features:
- Wizard-style flow through editing operations
- Preview mode with sample changes before applying
- Iterative chapter-by-chapter refinement
- Profile building helper

Usage:
    python interactive.py
    python interactive.py --input book.epub

No external dependencies required beyond the base project requirements.
"""

import argparse
import json
import os
import sys
import tempfile
import zipfile
from pathlib import Path
from typing import Optional, List, Dict, Any

# Ensure the script directory is in the path for imports
SCRIPT_DIR = Path(__file__).parent
if str(SCRIPT_DIR) not in sys.path:
    sys.path.insert(0, str(SCRIPT_DIR))


# ---------- CONSTANTS ----------

MODES = {
    'edit': {
        'name': 'Edit',
        'description': 'Change existing content (cleanup, filtering, style adaptation)',
        'icon': '[E]',
    },
    'transform': {
        'name': 'Transform',
        'description': 'Major adaptation (genre shift, setting change, plot modification)',
        'icon': '[T]',
    },
    'annotate': {
        'name': 'Annotate',
        'description': 'Add commentary layer without modifying original text',
        'icon': '[A]',
    },
    'profile': {
        'name': 'Build Profile',
        'description': 'Create an author style profile from sample EPUBs',
        'icon': '[P]',
    },
}

EDIT_WORKFLOWS = {
    'cleanup': {
        'name': 'OCR Cleanup',
        'description': 'Fix OCR errors, scanning artifacts, formatting issues (~5% drift)',
        'workflow_file': 'cleanup.yaml',
    },
    'filter': {
        'name': 'Content Filtering',
        'description': 'Remove or modify specific content types (~15% drift)',
        'workflow_file': 'filter.yaml',
    },
    'modernize': {
        'name': 'Language Modernization',
        'description': 'Update archaic language to modern style (~30% drift)',
        'workflow_file': 'modernize.yaml',
    },
}

ANNOTATION_STYLES = {
    'scholarly': 'Literary analysis, sources, references',
    'historical': 'Period context, author biography, events',
    'educational': 'Vocabulary, concepts, explanations',
    'devils_advocate': 'Challenge assumptions, alternative views',
    'thematic': 'Connections to other works, parallels',
    'fun_facts': 'Trivia, behind-the-scenes, inspirations',
    'funny': 'Humorous observations, witty asides',
    'cross_reference': 'Links to other texts, author\'s other works',
}


# ---------- UTILITY FUNCTIONS ----------

def clear_screen():
    """Clear the terminal screen."""
    os.system('cls' if os.name == 'nt' else 'clear')


def print_header(title: str, width: int = 70):
    """Print a formatted header."""
    print()
    print("=" * width)
    print(f"  {title}")
    print("=" * width)
    print()


def print_section(title: str, width: int = 70):
    """Print a section divider."""
    print()
    print("-" * width)
    print(f"  {title}")
    print("-" * width)
    print()


def print_option(key: str, name: str, description: str = ""):
    """Print a menu option."""
    if description:
        print(f"  {key}) {name}")
        print(f"       {description}")
    else:
        print(f"  {key}) {name}")


def get_input(prompt: str, default: str = "") -> str:
    """Get user input with optional default."""
    if default:
        result = input(f"{prompt} [{default}]: ").strip()
        return result if result else default
    else:
        return input(f"{prompt}: ").strip()


def get_yes_no(prompt: str, default: bool = True) -> bool:
    """Get a yes/no response from the user."""
    default_str = "Y/n" if default else "y/N"
    response = input(f"{prompt} [{default_str}]: ").strip().lower()
    if not response:
        return default
    return response in ('y', 'yes', 'true', '1')


def get_choice(prompt: str, options: List[str], allow_multiple: bool = False) -> Any:
    """Get a choice from a list of options."""
    print(prompt)
    for i, opt in enumerate(options, 1):
        print(f"  {i}) {opt}")
    print()

    if allow_multiple:
        print("  Enter numbers separated by commas (e.g., 1,3,5)")
        response = input("  Your choice(s): ").strip()
        try:
            indices = [int(x.strip()) - 1 for x in response.split(',')]
            return [options[i] for i in indices if 0 <= i < len(options)]
        except (ValueError, IndexError):
            print("  Invalid selection. Please try again.")
            return get_choice(prompt, options, allow_multiple)
    else:
        response = input("  Your choice: ").strip()
        try:
            idx = int(response) - 1
            if 0 <= idx < len(options):
                return options[idx]
        except ValueError:
            pass
        print("  Invalid selection. Please try again.")
        return get_choice(prompt, options, allow_multiple)


def validate_epub(path: str) -> bool:
    """Check if a file is a valid EPUB."""
    try:
        with zipfile.ZipFile(path, 'r') as z:
            # Check for mimetype file (required for EPUB)
            if 'mimetype' in z.namelist():
                return True
            # Check for META-INF/container.xml (also required)
            if 'META-INF/container.xml' in z.namelist():
                return True
    except (zipfile.BadZipFile, FileNotFoundError):
        pass
    return False


def get_epub_info(epub_path: str) -> Dict[str, Any]:
    """Extract basic info from an EPUB file."""
    info = {
        'path': epub_path,
        'filename': Path(epub_path).name,
        'chapter_count': 0,
        'title': None,
    }

    try:
        from bs4 import BeautifulSoup

        with tempfile.TemporaryDirectory() as temp_dir:
            with zipfile.ZipFile(epub_path, 'r') as z:
                z.extractall(temp_dir)

            temp_path = Path(temp_dir)

            # Count HTML files (chapters)
            html_files = list(temp_path.rglob('*.html')) + list(temp_path.rglob('*.xhtml'))
            info['chapter_count'] = len(html_files)

            # Try to get title from content.opf
            opf_files = list(temp_path.rglob('*.opf'))
            for opf_file in opf_files:
                try:
                    with open(opf_file, 'r', encoding='utf-8') as f:
                        soup = BeautifulSoup(f.read(), 'html.parser')
                        title_elem = soup.find('dc:title') or soup.find('title')
                        if title_elem:
                            info['title'] = title_elem.get_text().strip()
                            break
                except Exception:
                    pass
    except Exception as e:
        print(f"  Warning: Could not read EPUB details: {e}")

    return info


def extract_sample_passages(epub_path: str, num_passages: int = 3) -> List[Dict[str, str]]:
    """Extract sample passages from an EPUB for preview."""
    passages = []

    try:
        from bs4 import BeautifulSoup

        with tempfile.TemporaryDirectory() as temp_dir:
            with zipfile.ZipFile(epub_path, 'r') as z:
                z.extractall(temp_dir)

            temp_path = Path(temp_dir)
            html_files = sorted(list(temp_path.rglob('*.html')) + list(temp_path.rglob('*.xhtml')))

            for html_file in html_files:
                if len(passages) >= num_passages:
                    break

                try:
                    with open(html_file, 'r', encoding='utf-8') as f:
                        soup = BeautifulSoup(f.read(), 'html.parser')

                    # Find paragraphs
                    for p in soup.find_all('p'):
                        text = p.get_text().strip()
                        if 100 < len(text) < 1000:
                            passages.append({
                                'file': html_file.name,
                                'text': text[:500] + ('...' if len(text) > 500 else ''),
                            })
                            if len(passages) >= num_passages:
                                break
                except Exception:
                    continue
    except Exception as e:
        print(f"  Warning: Could not extract passages: {e}")

    return passages


# ---------- WIZARD FLOWS ----------

class InteractiveWizard:
    """Main interactive wizard for EPUB LLM Cleaner."""

    def __init__(self, input_epub: Optional[str] = None):
        self.input_epub = input_epub
        self.epub_info = None
        self.config = {}

        if input_epub and os.path.exists(input_epub):
            if validate_epub(input_epub):
                self.epub_info = get_epub_info(input_epub)
            else:
                print(f"Warning: {input_epub} does not appear to be a valid EPUB file.")

    def run(self):
        """Main entry point for the wizard."""
        while True:
            clear_screen()
            self.show_main_menu()

            choice = get_input("\nEnter your choice (q to quit)").lower()

            if choice in ('q', 'quit', 'exit'):
                print("\nGoodbye!")
                break
            elif choice in ('1', 'e', 'edit'):
                self.edit_flow()
            elif choice in ('2', 't', 'transform'):
                self.transform_flow()
            elif choice in ('3', 'a', 'annotate'):
                self.annotate_flow()
            elif choice in ('4', 'p', 'profile'):
                self.profile_flow()
            else:
                print("\nInvalid choice. Please try again.")
                input("Press Enter to continue...")

    def show_main_menu(self):
        """Display the main menu."""
        print_header("EPUB LLM Cleaner - Interactive Mode")

        if self.epub_info:
            print(f"  Current book: {self.epub_info['filename']}")
            if self.epub_info.get('title'):
                print(f"  Title: {self.epub_info['title']}")
            print(f"  Chapters: {self.epub_info['chapter_count']}")
            print()

        print("What would you like to do?\n")

        print_option("1", "Edit", "Change existing content (cleanup, filtering, style)")
        print()
        print_option("2", "Transform", "Major adaptation (genre shift, setting change)")
        print()
        print_option("3", "Annotate", "Add commentary without modifying text")
        print()
        print_option("4", "Build Profile", "Create author style profile from samples")
        print()
        print_option("q", "Quit", "Exit the interactive mode")

    # ---------- EDIT FLOW ----------

    def edit_flow(self):
        """Guide user through the edit workflow."""
        clear_screen()
        print_header("Edit Mode - Content Modification")

        # Step 1: Select or confirm input EPUB
        epub_path = self.select_input_epub()
        if not epub_path:
            return

        # Step 2: Choose workflow type
        print_section("Step 2: Choose Edit Type")
        print("What kind of editing do you want to perform?\n")

        for key, wf in EDIT_WORKFLOWS.items():
            print_option(key[0].upper(), wf['name'], wf['description'])
            print()

        print_option("C", "Custom", "Define your own editing rules")
        print()

        choice = get_input("Choose an option").lower()

        workflow = None
        if choice in ('o', 'ocr', 'cleanup', '1'):
            workflow = 'cleanup'
        elif choice in ('f', 'filter', '2'):
            workflow = 'filter'
        elif choice in ('m', 'modernize', '3'):
            workflow = 'modernize'
        elif choice in ('c', 'custom'):
            workflow = 'custom'
        else:
            print("Invalid choice.")
            input("Press Enter to continue...")
            return

        # Step 3: Preview mode
        print_section("Step 3: Preview Changes")

        if get_yes_no("Would you like to preview changes before applying?", True):
            self.show_edit_preview(epub_path, workflow)

            if not get_yes_no("\nProceed with these changes?", True):
                print("\nCancelled. No changes made.")
                input("Press Enter to continue...")
                return

        # Step 4: Configure output
        print_section("Step 4: Configure Output")

        default_output = str(Path(epub_path).with_stem(Path(epub_path).stem + '_edited'))
        output_path = get_input("Output file path", default_output)

        dry_run = get_yes_no("Perform a dry run first (no files modified)?", True)

        # Step 5: Execute
        print_section("Step 5: Processing")

        self.execute_edit(epub_path, output_path, workflow, dry_run)

        input("\nPress Enter to continue...")

    def show_edit_preview(self, epub_path: str, workflow: str):
        """Show a preview of potential changes."""
        print("\nExtracting sample passages for preview...")

        passages = extract_sample_passages(epub_path, 3)

        if not passages:
            print("Could not extract sample passages.")
            return

        print(f"\nFound {len(passages)} sample passages:\n")

        for i, passage in enumerate(passages, 1):
            print(f"--- Sample {i} (from {passage['file']}) ---")
            print(passage['text'])
            print()

        if workflow == 'cleanup':
            print("\nWith 'OCR Cleanup', the system will:")
            print("  - Fix character substitution errors (rn->m, cl->d, etc.)")
            print("  - Repair broken hyphenation from line breaks")
            print("  - Remove page numbers embedded in text")
            print("  - Fix punctuation errors from OCR")
            print("  - Expected drift: ~5% (minimal changes)")
        elif workflow == 'filter':
            print("\nWith 'Content Filtering', the system will:")
            print("  - Identify and modify flagged content")
            print("  - Apply your specified filtering rules")
            print("  - Expected drift: ~15% (moderate changes)")
        elif workflow == 'modernize':
            print("\nWith 'Language Modernization', the system will:")
            print("  - Update archaic vocabulary")
            print("  - Simplify complex sentence structures")
            print("  - Maintain author's core voice")
            print("  - Expected drift: ~30% (notable changes)")
        elif workflow == 'custom':
            print("\nWith 'Custom' editing, you define the rules.")
            print("You will be prompted for specific instructions.")

    def execute_edit(self, epub_path: str, output_path: str, workflow: str, dry_run: bool):
        """Execute the edit operation."""
        try:
            from epub_cleaner import load_config, load_prompts, create_client, process_epub
        except ImportError as e:
            print(f"Error: Could not import epub_cleaner module: {e}")
            return

        # Find workflow file if specified
        workflow_config = None
        if workflow != 'custom':
            workflow_file = SCRIPT_DIR / 'workflows' / f'{workflow}.yaml'
            if workflow_file.exists():
                workflow_config = str(workflow_file)
                print(f"Using workflow: {workflow_file.name}")

        try:
            config = load_config(workflow_config)
            prompts = load_prompts(workflow_config)
            client = create_client(config)

            print(f"\n{'Dry run - ' if dry_run else ''}Processing: {epub_path}")
            print(f"Output will be saved to: {output_path}")
            print()

            process_epub(
                input_path=epub_path,
                output_path=output_path,
                config=config,
                prompts=prompts,
                client=client,
                dry_run=dry_run
            )

            if dry_run:
                print("\nDry run complete. No files were modified.")
                if get_yes_no("Apply changes for real?", False):
                    process_epub(
                        input_path=epub_path,
                        output_path=output_path,
                        config=config,
                        prompts=prompts,
                        client=client,
                        dry_run=False
                    )
                    print(f"\nDone! Output saved to: {output_path}")
            else:
                print(f"\nDone! Output saved to: {output_path}")

        except Exception as e:
            print(f"\nError during processing: {e}")
            import traceback
            traceback.print_exc()

    # ---------- TRANSFORM FLOW ----------

    def transform_flow(self):
        """Guide user through the transformation workflow."""
        clear_screen()
        print_header("Transform Mode - Major Adaptation")

        print("IMPORTANT: Transformation requires preparation!\n")
        print("This mode is for major changes like:")
        print("  - Genre shifts (Fantasy -> Sci-Fi)")
        print("  - Setting changes (Medieval -> Modern)")
        print("  - Plot modifications (alternate endings)")
        print()
        print("Before transformation, you need:")
        print("  1. A book model (character/plot analysis)")
        print("  2. A change plan (what to transform)")
        print()

        # Step 1: Select input EPUB
        epub_path = self.select_input_epub()
        if not epub_path:
            return

        # Step 2: Check for book model
        print_section("Step 2: Book Model")

        default_model = str(Path(epub_path).with_suffix('.book_model.json'))

        if os.path.exists(default_model):
            print(f"Found existing book model: {default_model}")
            if get_yes_no("Use this model?", True):
                model_path = default_model
            else:
                model_path = None
        else:
            print("No book model found. You need to analyze the book first.")
            if get_yes_no("Analyze the book now?", True):
                model_path = self.run_book_analysis(epub_path)
            else:
                model_path = get_input("Enter path to existing book model (or leave blank to skip)")

        if not model_path or not os.path.exists(model_path):
            print("\nBook model is required for transformation.")
            print("Run: python book_analyzer.py --input book.epub")
            input("Press Enter to continue...")
            return

        # Step 3: Define transformation goal
        print_section("Step 3: Define Your Transformation")

        print("Describe what you want to transform. Examples:")
        print("  - 'Convert to a steampunk setting with clockwork technology'")
        print("  - 'Change the ending so the hero survives'")
        print("  - 'Set the story in modern-day Tokyo instead of Victorian London'")
        print()

        goal = get_input("Your transformation goal")

        if not goal:
            print("Transformation goal is required.")
            input("Press Enter to continue...")
            return

        # Step 4: Generate or load change plan
        print_section("Step 4: Change Plan")

        default_plan = str(Path(epub_path).with_suffix('.change_plan.json'))

        if os.path.exists(default_plan):
            print(f"Found existing change plan: {default_plan}")
            if get_yes_no("Use this plan?", True):
                plan_path = default_plan
            else:
                plan_path = None
        else:
            plan_path = None

        if not plan_path:
            print("\nGenerating change plan based on your goal...")
            plan_path = self.run_change_planning(model_path, goal, epub_path)

        if not plan_path or not os.path.exists(plan_path):
            print("\nChange plan is required for transformation.")
            print("Run: python change_planner.py --model book_model.json --goal 'your goal'")
            input("Press Enter to continue...")
            return

        # Step 5: Preview
        print_section("Step 5: Preview Transformation")

        self.show_transform_preview(plan_path)

        if not get_yes_no("\nProceed with transformation?", True):
            print("\nCancelled. No changes made.")
            input("Press Enter to continue...")
            return

        # Step 6: Execute
        print_section("Step 6: Processing")

        default_output = str(Path(epub_path).with_stem(Path(epub_path).stem + '_transformed'))
        output_path = get_input("Output file path", default_output)

        self.execute_transform(epub_path, output_path, model_path, plan_path)

        input("\nPress Enter to continue...")

    def run_book_analysis(self, epub_path: str) -> Optional[str]:
        """Run book analysis to generate model."""
        try:
            from book_analyzer import analyze_book
        except ImportError as e:
            print(f"Error: Could not import book_analyzer: {e}")
            return None

        output_path = str(Path(epub_path).with_suffix('.book_model.json'))

        print(f"\nAnalyzing book structure...")
        print("This may take several minutes for long books.\n")

        try:
            analyze_book(
                input_path=epub_path,
                output_path=output_path,
                model='claude-sonnet-4-5-20250929',
                verbose=True
            )
            print(f"\nBook model saved to: {output_path}")
            return output_path
        except Exception as e:
            print(f"Error during analysis: {e}")
            return None

    def run_change_planning(self, model_path: str, goal: str, epub_path: str) -> Optional[str]:
        """Run change planning to generate plan."""
        try:
            from change_planner import generate_change_plan, load_book_model, create_client
        except ImportError as e:
            print(f"Error: Could not import change_planner: {e}")
            return None

        output_path = str(Path(epub_path).with_suffix('.change_plan.json'))

        print(f"\nGenerating change plan for: {goal}")
        print("This may take a few minutes...\n")

        try:
            client = create_client()
            book_model = load_book_model(model_path)

            plan = generate_change_plan(
                client=client,
                book_model=book_model,
                change_goal=goal,
                verbose=True
            )

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

            print(f"\nChange plan saved to: {output_path}")
            return output_path
        except Exception as e:
            print(f"Error during planning: {e}")
            import traceback
            traceback.print_exc()
            return None

    def show_transform_preview(self, plan_path: str):
        """Show a preview of the transformation plan."""
        try:
            with open(plan_path, 'r', encoding='utf-8') as f:
                plan = json.load(f)
        except Exception as e:
            print(f"Could not read plan: {e}")
            return

        print("\n=== TRANSFORMATION PLAN SUMMARY ===\n")

        if 'change_interpretation' in plan:
            interp = plan['change_interpretation']
            print(f"Summary: {interp.get('summary', 'N/A')}")
            print(f"Scope: {interp.get('scope', 'N/A')}")
            print(f"Type: {interp.get('change_type', 'N/A')}")

        if 'affected_characters' in plan:
            chars = plan['affected_characters']
            print(f"\nAffected characters: {len(chars)}")
            for char in chars[:5]:
                print(f"  - {char.get('name', 'Unknown')}: {char.get('impact_type', '')}")

        if 'chapter_modifications' in plan:
            mods = plan['chapter_modifications']
            print(f"\nChapters to modify: {len(mods)}")
            for mod in mods[:5]:
                print(f"  - Chapter {mod.get('chapter_number', '?')}: {mod.get('modification_summary', '')[:60]}...")

    def execute_transform(self, epub_path: str, output_path: str, model_path: str, plan_path: str):
        """Execute the transformation."""
        print("\nTransformation execution is a complex multi-step process.")
        print("For full transformation, use the CLI with the transform workflow:")
        print()
        print(f"  python cli.py edit --input \"{epub_path}\" \\")
        print(f"      --workflow transform \\")
        print(f"      --output \"{output_path}\"")
        print()
        print("After transformation, run consistency checking:")
        print(f"  python consistency_checker.py --input \"{output_path}\" --model \"{model_path}\"")

    # ---------- ANNOTATE FLOW ----------

    def annotate_flow(self):
        """Guide user through the annotation workflow."""
        clear_screen()
        print_header("Annotate Mode - Add Commentary")

        print("Add scholarly footnotes, historical context, or other commentary")
        print("to your EPUB without modifying the original text.\n")

        # Step 1: Select input
        epub_path = self.select_input_epub()
        if not epub_path:
            return

        # Step 2: Choose annotation styles
        print_section("Step 2: Choose Commentary Styles")

        print("Select one or more commentary styles:\n")

        style_list = list(ANNOTATION_STYLES.keys())
        for i, (key, desc) in enumerate(ANNOTATION_STYLES.items(), 1):
            print(f"  {i}) {key.replace('_', ' ').title()}")
            print(f"       {desc}")
            print()

        print("Enter style numbers separated by commas (e.g., 1,3,6):")
        response = input("  Your choices: ").strip()

        try:
            indices = [int(x.strip()) - 1 for x in response.split(',') if x.strip()]
            selected_styles = [style_list[i] for i in indices if 0 <= i < len(style_list)]
        except (ValueError, IndexError):
            selected_styles = ['scholarly']

        if not selected_styles:
            selected_styles = ['scholarly']

        print(f"\nSelected styles: {', '.join(selected_styles)}")

        # Step 3: Configure frequency
        print_section("Step 3: Annotation Frequency")

        print("How many annotations per chapter?")
        print("  1) Light (1-2 per chapter)")
        print("  2) Moderate (3-5 per chapter)")
        print("  3) Heavy (6-10 per chapter)")
        print()

        freq_choice = get_input("Choose frequency", "2")

        frequency = {
            '1': '1-2 per chapter',
            '2': '3-5 per chapter',
            '3': '6-10 per chapter',
        }.get(freq_choice, '3-5 per chapter')

        # Step 4: Preview
        print_section("Step 4: Preview Sample Passages")

        if get_yes_no("Show sample passages that might be annotated?", True):
            self.show_annotation_preview(epub_path, selected_styles)

        if not get_yes_no("\nProceed with annotation?", True):
            print("\nCancelled. No changes made.")
            input("Press Enter to continue...")
            return

        # Step 5: Configure output
        print_section("Step 5: Configure Output")

        default_output = str(Path(epub_path).with_stem(Path(epub_path).stem + '_annotated'))
        output_path = get_input("Output file path", default_output)

        note_format = 'footnotes'
        if get_yes_no("Use footnotes? (No = endnotes)", True):
            note_format = 'footnotes'
        else:
            note_format = 'endnotes'

        # Step 6: Execute
        print_section("Step 6: Processing")

        self.execute_annotate(epub_path, output_path, selected_styles, frequency, note_format)

        input("\nPress Enter to continue...")

    def show_annotation_preview(self, epub_path: str, styles: List[str]):
        """Show sample passages that could be annotated."""
        passages = extract_sample_passages(epub_path, 3)

        if not passages:
            print("Could not extract sample passages.")
            return

        print(f"\nSample passages that might receive {', '.join(styles)} annotations:\n")

        for i, passage in enumerate(passages, 1):
            print(f"--- Sample {i} ---")
            print(passage['text'][:300] + "...")
            print()

    def execute_annotate(self, epub_path: str, output_path: str, styles: List[str],
                         frequency: str, note_format: str):
        """Execute the annotation operation."""
        try:
            from annotator import load_config, create_client, process_epub, save_annotations, DEFAULT_CONFIG
            from footnote_inserter import process_epub as insert_footnotes
        except ImportError as e:
            print(f"Error: Could not import required modules: {e}")
            return

        config = DEFAULT_CONFIG.copy()
        config['styles'] = styles
        config['frequency'] = frequency

        try:
            client = create_client(config)

            print(f"\nGenerating {', '.join(styles)} annotations...")
            print(f"Frequency: {frequency}")
            print(f"Format: {note_format}")
            print()

            annotations = process_epub(
                input_path=epub_path,
                config=config,
                client=client,
                dry_run=False
            )

            if not annotations:
                print("No annotations were generated.")
                return

            print(f"\nGenerated {len(annotations)} annotations.")

            # Save annotations JSON
            annotations_file = output_path.replace('.epub', '_annotations.json')
            save_annotations(annotations, annotations_file, config, epub_path)
            print(f"Annotations saved to: {annotations_file}")

            # Format annotations for inserter
            formatted = []
            for ann in annotations:
                formatted.append({
                    'chapter': ann['chapter_file'],
                    'paragraph_index': ann['paragraph_index'],
                    'passage_text': ann['passage_text'],
                    'note_text': ann['commentary']['text'],
                    'note_type': ann['commentary']['style']
                })

            # Save temp file and insert
            with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False, encoding='utf-8') as f:
                json.dump(formatted, f, indent=2, ensure_ascii=False)
                temp_path = f.name

            try:
                insert_footnotes(
                    input_path=epub_path,
                    annotations_path=temp_path,
                    output_path=output_path,
                    note_format=note_format,
                    css_filename='footnotes.css'
                )
                print(f"\nAnnotated EPUB saved to: {output_path}")
            finally:
                os.unlink(temp_path)

        except Exception as e:
            print(f"\nError during annotation: {e}")
            import traceback
            traceback.print_exc()

    # ---------- PROFILE FLOW ----------

    def profile_flow(self):
        """Guide user through profile building."""
        clear_screen()
        print_header("Build Author Profile - Style Analysis")

        print("Create an author style profile by analyzing sample EPUBs.")
        print("The profile captures writing patterns, voice, and vocabulary.\n")
        print("This profile can then be used to preserve style during editing.\n")

        # Step 1: Select sample EPUBs
        print_section("Step 1: Select Sample Books")

        print("For best results, provide 1-3 books by the same author.")
        print("More samples = more accurate profile.\n")

        epub_files = []

        if self.input_epub and os.path.exists(self.input_epub):
            if get_yes_no(f"Include current book ({Path(self.input_epub).name})?", True):
                epub_files.append(self.input_epub)

        while True:
            if epub_files:
                print(f"\nCurrent samples: {len(epub_files)}")
                for f in epub_files:
                    print(f"  - {Path(f).name}")

            add_more = get_input("\nAdd another EPUB path (or 'done' to continue)")

            if add_more.lower() in ('done', 'd', ''):
                break

            if os.path.exists(add_more) and validate_epub(add_more):
                epub_files.append(add_more)
                print(f"  Added: {Path(add_more).name}")
            else:
                print("  File not found or not a valid EPUB.")

        if not epub_files:
            print("\nAt least one EPUB is required.")
            input("Press Enter to continue...")
            return

        # Step 2: Guided passage selection
        print_section("Step 2: Select Representative Passages")

        print("The profiler will automatically select passages, but you can")
        print("help by indicating which types of content to prioritize:\n")

        print("  1) Auto-select (let the system choose)")
        print("  2) Prioritize narrative prose")
        print("  3) Prioritize dialogue")
        print("  4) Balanced mix")
        print()

        selection_mode = get_input("Choose selection mode", "1")

        # Step 3: Preview sample passages
        print_section("Step 3: Preview Selected Passages")

        if get_yes_no("Preview passages that will be analyzed?", True):
            self.show_profile_preview(epub_files[0])

        # Step 4: Configure output
        print_section("Step 4: Configure Output")

        # Suggest output name based on input
        first_epub = Path(epub_files[0])
        default_output = str(first_epub.with_stem(first_epub.stem + '_profile').with_suffix('.json'))
        output_path = get_input("Profile output path", default_output)

        # Step 5: Execute
        print_section("Step 5: Analyzing Style")

        self.execute_profile(epub_files, output_path)

        input("\nPress Enter to continue...")

    def show_profile_preview(self, epub_path: str):
        """Show passages that will be used for profiling."""
        passages = extract_sample_passages(epub_path, 5)

        if not passages:
            print("Could not extract sample passages.")
            return

        print(f"\nSample passages that will be analyzed for style:\n")

        for i, passage in enumerate(passages, 1):
            print(f"--- Passage {i} ---")
            print(passage['text'][:300] + "...")
            print()

        print("The profiler will analyze sentence structure, vocabulary,")
        print("dialogue patterns, and narrative voice from these passages.")

    def execute_profile(self, epub_files: List[str], output_path: str):
        """Execute profile generation."""
        try:
            from style_profiler import create_client, generate_style_profile
        except ImportError as e:
            print(f"Error: Could not import style_profiler: {e}")
            return

        try:
            client = create_client()

            print(f"\nAnalyzing {len(epub_files)} EPUB(s) for style patterns...")
            print("This may take several minutes.\n")

            profile = generate_style_profile(
                client=client,
                model='claude-sonnet-4-20250514',
                epub_paths=epub_files,
                verbose=True
            )

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

            print(f"\n\nProfile saved to: {output_path}")

            # Show summary
            if 'style_analysis' in profile:
                style = profile['style_analysis']
                if 'overall_summary' in style:
                    print(f"\nStyle Summary: {style['overall_summary'][:200]}...")

        except Exception as e:
            print(f"\nError during profiling: {e}")
            import traceback
            traceback.print_exc()

    # ---------- HELPER METHODS ----------

    def select_input_epub(self) -> Optional[str]:
        """Get or confirm input EPUB path."""
        print_section("Step 1: Select Input EPUB")

        if self.epub_info:
            print(f"Current book: {self.epub_info['filename']}")
            if self.epub_info.get('title'):
                print(f"Title: {self.epub_info['title']}")
            print()

            if get_yes_no("Use this book?", True):
                return self.input_epub

        while True:
            path = get_input("Enter path to EPUB file")

            if not path:
                print("  Path is required.")
                if get_yes_no("Cancel and return to main menu?", True):
                    return None
                continue

            if not os.path.exists(path):
                print(f"  File not found: {path}")
                continue

            if not validate_epub(path):
                print("  File does not appear to be a valid EPUB.")
                if not get_yes_no("Use anyway?", False):
                    continue

            self.epub_info = get_epub_info(path)
            self.input_epub = path
            return path


# ---------- CHAPTER-BY-CHAPTER MODE ----------

class ChapterIterator:
    """Process book chapter by chapter with user feedback."""

    def __init__(self, epub_path: str, config: dict):
        self.epub_path = epub_path
        self.config = config
        self.chapter_results = []

    def run_iterative(self):
        """Process chapters one by one with feedback."""
        print_header("Chapter-by-Chapter Processing")

        print("This mode lets you review and adjust changes for each chapter.")
        print("You can approve, reject, or modify the changes before moving on.\n")

        # Extract chapters
        chapters = self.extract_chapters()

        if not chapters:
            print("No chapters found in EPUB.")
            return

        print(f"Found {len(chapters)} chapters.\n")

        for i, chapter in enumerate(chapters, 1):
            print(f"\n{'='*60}")
            print(f"Chapter {i}/{len(chapters)}: {chapter.get('title', 'Untitled')}")
            print(f"{'='*60}\n")

            # Show preview
            preview = chapter.get('text', '')[:500]
            print(f"Preview:\n{preview}...\n")

            # Get action
            action = self.get_chapter_action()

            if action == 'skip':
                print("  Skipping this chapter.")
                self.chapter_results.append({'chapter': i, 'action': 'skipped'})
            elif action == 'process':
                print("  Processing...")
                result = self.process_chapter(chapter)
                self.chapter_results.append({'chapter': i, 'action': 'processed', 'result': result})

                # Show changes
                if result.get('changes'):
                    print("\n  Changes made:")
                    for change in result['changes'][:3]:
                        print(f"    - {change}")
            elif action == 'quit':
                print("\n  Stopping iteration.")
                break

        # Summary
        self.show_summary()

    def extract_chapters(self) -> List[Dict[str, Any]]:
        """Extract chapter information from EPUB."""
        chapters = []

        try:
            from bs4 import BeautifulSoup

            with tempfile.TemporaryDirectory() as temp_dir:
                with zipfile.ZipFile(self.epub_path, 'r') as z:
                    z.extractall(temp_dir)

                temp_path = Path(temp_dir)
                html_files = sorted(list(temp_path.rglob('*.html')) + list(temp_path.rglob('*.xhtml')))

                for html_file in html_files:
                    try:
                        with open(html_file, 'r', encoding='utf-8') as f:
                            soup = BeautifulSoup(f.read(), 'html.parser')

                        text = soup.get_text(separator='\n', strip=True)

                        if len(text) > 500:
                            title_elem = soup.find(['h1', 'h2', 'h3'])
                            title = title_elem.get_text().strip() if title_elem else html_file.stem

                            chapters.append({
                                'file': html_file.name,
                                'title': title[:100],
                                'text': text,
                            })
                    except Exception:
                        continue
        except Exception as e:
            print(f"Error extracting chapters: {e}")

        return chapters

    def get_chapter_action(self) -> str:
        """Get user action for current chapter."""
        print("What would you like to do?")
        print("  p) Process this chapter")
        print("  s) Skip this chapter")
        print("  q) Quit iteration")
        print()

        choice = get_input("Action", "p").lower()

        if choice in ('p', 'process', ''):
            return 'process'
        elif choice in ('s', 'skip'):
            return 'skip'
        elif choice in ('q', 'quit'):
            return 'quit'
        else:
            return 'skip'

    def process_chapter(self, chapter: Dict[str, Any]) -> Dict[str, Any]:
        """Process a single chapter."""
        # This would integrate with epub_cleaner for actual processing
        return {
            'changes': [],
            'status': 'processed'
        }

    def show_summary(self):
        """Show processing summary."""
        print_section("Processing Summary")

        processed = sum(1 for r in self.chapter_results if r['action'] == 'processed')
        skipped = sum(1 for r in self.chapter_results if r['action'] == 'skipped')

        print(f"Chapters processed: {processed}")
        print(f"Chapters skipped: {skipped}")
        print(f"Total chapters reviewed: {len(self.chapter_results)}")


# ---------- MAIN ENTRY POINT ----------

def main():
    """Main entry point for interactive mode."""
    parser = argparse.ArgumentParser(
        description='EPUB LLM Cleaner - Interactive Mode',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  python interactive.py
  python interactive.py --input book.epub

The interactive mode provides a guided wizard for:
  - Editing EPUBs (cleanup, filtering, modernization)
  - Transforming books (genre shifts, setting changes)
  - Adding annotations (footnotes, commentary)
  - Building author style profiles
        """
    )

    parser.add_argument(
        '--input', '-i',
        help='Input EPUB file to work with'
    )

    args = parser.parse_args()

    # Validate input if provided
    input_epub = None
    if args.input:
        if os.path.exists(args.input):
            if validate_epub(args.input):
                input_epub = args.input
            else:
                print(f"Warning: {args.input} does not appear to be a valid EPUB.")
                if get_yes_no("Continue anyway?", False):
                    input_epub = args.input
        else:
            print(f"Error: File not found: {args.input}")
            sys.exit(1)

    # Run wizard
    wizard = InteractiveWizard(input_epub)
    wizard.run()


if __name__ == "__main__":
    main()