import argparse
import sys
import os
import asyncio
from pathlib import Path
from dotenv import load_dotenv

# Add project root to sys.path
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))

from src.assembly.backfiller import BackfillEngine
from src.assembly.builder import BilingualBuilder
from src.translation.manifest_manager import ManifestManager
from src.common.data_model import BookStructure
from src.common.exceptions import EpubTranslatorError
from src.common.utils import setup_logger, ensure_directory
from src.common.paths import get_work_dirs
from src.common.config import load_global_config

logger = setup_logger("pipeline_build")

async def run_build(args):
    input_path = Path(args.input_epub)
    if not input_path.exists():
        logger.error(f"Input file not found: {input_path}")
        sys.exit(1)

    work = get_work_dirs(input_path)
    work_root = work["root"]
    structure_path = work["structure"]
    manifest_path = work["manifest"]
    
    if not structure_path.exists() or not manifest_path.exists():
        logger.error("Missing structure or manifest. Run Step 1-3.")
        sys.exit(1)
        
    output_dir = Path(args.output_dir)
    ensure_directory(output_dir)
    
    try:
        # Load Data
        logger.info("Loading structure and manifest...")
        structure = BookStructure.load(structure_path)
        manager = ManifestManager(manifest_path)
        manager.load()
        
        # Backfill (Pure Injection)
        logger.info(f"Injecting content (Mode: {args.mode})...")
        backfiller = BackfillEngine() # No dependencies needed
        updated_structure = await backfiller.backfill(structure, manager.entries, mode=args.mode)
        
        # Build
        logger.info("Building EPUB...")
        builder = BilingualBuilder(work_root, original_epub_path=input_path)
        
        if args.mode == "bilingual":
            output_filename = f"bilingual_{input_path.stem}.epub"
        else:
            output_filename = f"translated_{input_path.stem}.epub"
            
        output_path = output_dir / output_filename
        
        builder.build(updated_structure, output_path)
        logger.info(f"Build complete. Output: {output_path}")
        
    except EpubTranslatorError as e:
        logger.error(f"Build failed: {e}")
        sys.exit(1)
    except Exception as e:
        logger.critical(f"Unexpected error: {e}")
        import traceback
        traceback.print_exc()
        sys.exit(1)

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Step 4: Build EPUB (Injection + Packaging)")
    parser.add_argument("input_epub", help="Path to original EPUB")
    parser.add_argument("--output-dir", default="output", help="Output directory")
    parser.add_argument("--bilingual", action="store_true", help="Output bilingual version (default target only)")
    
    args = parser.parse_args()
    args.mode = "bilingual" if args.bilingual else "target_only"
    
    asyncio.run(run_build(args))