Mineru Converter

# Python
__pycache__/
*.py[cod]
*.egg-info/
dist/
build/

# Testing
.pytest_cache/
.coverage
htmlcov/

# IDE
.idea/
.vscode/
*.swp

# MinerU auto-installed venv
.mineru_venv/

# OS
.DS_Store
Thumbs.db

# Generated output during local testing
raw/

# MinerU Converter configuration
# Copy this file to config.yaml and customize as needed.

# Default output directory for converted files
output_dir: "./raw"

# MinerU CLI settings
mineru:
  command: "mineru"
  args:
    backend: "pipeline"
    model: "auto"
    language: "ch"
    method: "auto"

# Supported file extensions (lowercase)
supported_extensions:
  - ".pdf"
  - ".docx"
  - ".pptx"
  - ".xlsx"
  - ".png"
  - ".jpg"
  - ".jpeg"
  - ".bmp"
  - ".tiff"
  - ".tif"

# Manifest settings
manifest:
  filename: "manifest.json"
  version: "1.0"

# File organization
organizer:
  attachments_dir: "attachments"
  hash_prefix_length: 8

# MinerU Converter configuration
# Customize defaults by editing this file.

# Output directory for converted files (relative to project root)
output_dir: "./raw"

# MinerU CLI settings
mineru:
  command: "mineru"
  args:
    backend: "pipeline"
    model: "auto"
    language: "ch"
    method: "auto"

# Supported file extensions
supported_extensions:
  - ".pdf"
  - ".docx"
  - ".pptx"
  - ".xlsx"
  - ".png"
  - ".jpg"
  - ".jpeg"
  - ".bmp"
  - ".tiff"
  - ".tif"
  - ".epub"

# Manifest settings
manifest:
  filename: "manifest.json"
  version: "1.0"

# File organization
organizer:
  attachments_dir: "attachments"
  hash_prefix_length: 8

pyyaml>=6.0
ebooklib>=1.0
html2text>=2024.0

#!/usr/bin/env python3
"""Entry point for mineru-converter-skill."""

import sys
from pathlib import Path

# Ensure project root is in path
project_root = Path(__file__).resolve().parent
if str(project_root) not in sys.path:
    sys.path.insert(0, str(project_root))

from scripts.cli import main

sys.exit(main())

"""Allow running as: python3 -m scripts.cli"""

import sys
from pathlib import Path

# Ensure the project root is in sys.path
_project_root = Path(__file__).resolve().parent.parent
if str(_project_root) not in sys.path:
    sys.path.insert(0, str(_project_root))

from scripts.cli import main

sys.exit(main())

"""CLI entry point for mineru-converter-skill."""

import sys
import json
import argparse
from pathlib import Path

# Support both module and direct execution
try:
    from .config_loader import get_output_dir
    from .converter import convert_single, convert_batch, build_plan, get_status
    from .mineru_caller import check_mineru_available, MineruNotFoundError
    from .mineru_setup import check_mineru_available as check_mineru_setup, install_mineru_auto, show_manual_instructions
    from .manifest_manager import ManifestLoadError
except ImportError:
    _project_root = Path(__file__).resolve().parent.parent
    if str(_project_root) not in sys.path:
        sys.path.insert(0, str(_project_root))
    from config_loader import get_output_dir
    from converter import convert_single, convert_batch, build_plan, get_status
    from mineru_caller import check_mineru_available, MineruNotFoundError
    from mineru_setup import check_mineru_available as check_mineru_setup, install_mineru_auto, show_manual_instructions
    from manifest_manager import ManifestLoadError


def _format_report(report, as_json=False):
    """Format conversion report for display."""
    if as_json:
        return json.dumps(report, indent=2, ensure_ascii=False)

    lines = []
    if "items" in report:
        lines.append(f"Scanned: {report['scanned']}")
        lines.append(f"Processed: {report['processed']}")
        lines.append(f"Skipped: {report['skipped']}")
        lines.append(f"Failed: {report['failed']}")
        lines.append("")

        for item in report.get("items", []):
            icon = {"success": "[OK]", "skipped": "[SKIP]", "failed": "[ERR]"}.get(item["status"], "[???]")
            lines.append(f"{icon} {item['path']}")
            if item.get("error"):
                lines.append(f"       {item['error']}")
            if item.get("details"):
                d = item["details"]
                if d.get("md_path"):
                    lines.append(f"       -> {d['md_path']}")
                if d.get("images"):
                    lines.append(f"       images: {d['images']}")
    elif "process" in report:
        lines.append(f"Source:    {report['source_dir']}")
        lines.append(f"Output:    {report['output_dir']}")
        lines.append(f"Scanned:   {report['scanned']}")
        lines.append(f"To convert: {len(report['process'])}")
        lines.append(f"Already done: {len(report['skip'])}")
        lines.append("")

        if report["process"]:
            lines.append("To convert:")
            for item in report["process"]:
                lines.append(f"  [NEW] {item['path']}")
        if report["skip"]:
            lines.append("")
            lines.append("Already converted:")
            for item in report["skip"]:
                lines.append(f"  [SKIP] {item['path']}")
                if item.get("reason"):
                    lines.append(f"         {item['reason']}")
        if report.get("unsupported"):
            lines.append("")
            lines.append("Unsupported:")
            for item in report["unsupported"]:
                lines.append(f"  [SKIP] {item['path']} ({item['reason']})")
    elif "total" in report:
        lines.append(f"Output dir: {report['output_dir']}")
        lines.append(f"Total: {report['total']} (success: {report['success']}, failed: {report['failed']})")

    return "\n".join(lines)


def _ensure_mineru_installed():
    """Check if MinerU is installed, prompt user to install if not."""
    available, version = check_mineru_available()
    if available:
        return True

    print("MinerU is not installed or not in PATH.")
    print("The converter needs MinerU to function.")
    print()

    try:
        choice = input("Would you like to install MinerU? (A)uto / (M)anual / (C)ancel [A]: ").strip().lower()
    except (EOFError, KeyboardInterrupt):
        choice = "c"

    if choice in ("b", "m", "manual"):
        print()
        print(show_manual_instructions())
        return False
    elif choice in ("c", "cancel", "n", "no"):
        print("Aborted. Please install MinerU and try again.")
        return False
    else:
        # Default: auto install
        try:
            use_all_choice = input("Install full version (all backends) or core only? (F)ull / (C)ore [F]: ").strip().lower()
            use_all = use_all_choice not in ("c", "core", "core only")
        except (EOFError, KeyboardInterrupt):
            use_all = True

        print()
        if install_mineru_auto(use_all=use_all):
            # Re-check
            available, version = check_mineru_available()
            if available:
                print(f"MinerU installed successfully (version {version}).")
                return True
            else:
                print("Installation completed but MinerU still not detected. Check the output above for errors.")
                return False
        else:
            print("Installation failed. Please install manually.")
            return False


def main():
    parser = argparse.ArgumentParser(
        prog="mineru-converter",
        description="Convert documents (PDF, DOCX, PPTX, XLSX, images) to Markdown using MinerU.",
    )
    sub = parser.add_subparsers(dest="command", help="Available commands")

    # convert command
    conv_parser = sub.add_parser("convert", help="Convert one or more files")
    conv_parser.add_argument("--file", type=str, help="Single file to convert")
    conv_parser.add_argument("--dir", type=str, help="Directory of files to convert")
    conv_parser.add_argument("--output-dir", type=str, default=None, help="Output directory (default: from config)")
    conv_parser.add_argument("--force", action="store_true", help="Force re-conversion even if already done")
    conv_parser.add_argument("--workers", type=int, default=1, help="Parallel workers for batch (default: 1)")
    conv_parser.add_argument("--json", action="store_true", dest="as_json", help="Output as JSON")
    conv_parser.add_argument("--verbose", action="store_true", help="Verbose output")
    conv_parser.add_argument("--pages", type=str, default=None, help="Page range to convert (e.g. '3-5'), only for single file")
    conv_parser.add_argument("--method", type=str, default=None, choices=["auto", "txt", "ocr"],
                             help="PDF parsing method (default: from config)")
    conv_parser.add_argument("--lang", type=str, default=None, help="Document language (default: from config)")

    # plan command
    plan_parser = sub.add_parser("plan", help="Show conversion plan without executing")
    plan_parser.add_argument("--dir", type=str, required=True, help="Directory to scan")
    plan_parser.add_argument("--output-dir", type=str, default=None, help="Output directory (default: from config)")
    plan_parser.add_argument("--json", action="store_true", dest="as_json", help="Output as JSON")

    # status command
    status_parser = sub.add_parser("status", help="Show conversion statistics")
    status_parser.add_argument("--output-dir", type=str, default=None, help="Output directory (default: from config)")
    status_parser.add_argument("--list-converted", action="store_true", help="List converted files")
    status_parser.add_argument("--list-failed", action="store_true", help="List failed files")
    status_parser.add_argument("--json", action="store_true", dest="as_json", help="Output as JSON")

    args = parser.parse_args()

    if not args.command:
        parser.print_help()
        return 1

    output_dir = Path(args.output_dir).expanduser().resolve() if args.output_dir else None

    try:
        if args.command == "convert":
            # Validate: --pages only works with --file
            if args.dir and args.pages:
                parser.error("--pages can only be used with --file, not with --dir")

            # Ensure MinerU is installed before any conversion
            if not _ensure_mineru_installed():
                return 1

            if args.file:
                result = convert_single(
                    args.file, output_dir=output_dir, force=args.force,
                    verbose=args.verbose, pages=args.pages,
                    method=args.method, lang=args.lang,
                )
                # For single file, wrap in report format
                report = {"items": [result], "scanned": 1, "processed": 1 if result["status"] == "success" else 0,
                          "skipped": 1 if result["status"] == "skipped" else 0, "failed": 1 if result["status"] == "failed" else 0}
            elif args.dir:
                result = convert_batch(
                    args.dir, output_dir=output_dir, force=args.force,
                    workers=args.workers, verbose=args.verbose,
                    method=args.method, lang=args.lang,
                )
                report = result
            else:
                parser.error("--file or --dir required for convert")
                return 1

        elif args.command == "plan":
            report = build_plan(args.dir, output_dir=output_dir)

        elif args.command == "status":
            report = get_status(output_dir=output_dir,
                                list_converted=args.list_converted,
                                list_failed=args.list_failed)

        else:
            parser.print_help()
            return 1

        print(_format_report(report, as_json=args.as_json))

    except ManifestLoadError as e:
        print(f"Error: {e}", file=sys.stderr)
        return 1
    except Exception as e:
        print(f"Error: {e}", file=sys.stderr)
        return 1

    return 0


if __name__ == "__main__":
    sys.exit(main())

"""Configuration loader for mineru-converter-skill."""

import yaml
from pathlib import Path
from typing import Dict, Any, Optional

# Project root is the parent of the scripts/ directory
_PROJECT_ROOT = Path(__file__).resolve().parent.parent
_CONFIG_PATH = _PROJECT_ROOT / "config.yaml"
_DEFAULT_CONFIG: Dict[str, Any] = {
    "output_dir": "./raw",
    "mineru": {
        "command": "mineru",
        "args": {
            "backend": "pipeline",
            "model": "auto",
            "language": "ch",
            "method": "auto",
        },
    },
    "supported_extensions": [
        ".pdf", ".docx", ".pptx", ".xlsx",
        ".png", ".jpg", ".jpeg", ".bmp", ".tiff", ".tif",
        ".epub",
    ],
    "manifest": {
        "filename": "manifest.json",
        "version": "1.0",
    },
    "organizer": {
        "attachments_dir": "attachments",
        "hash_prefix_length": 8,
    },
}


def load_config(config_path: Optional[Path] = None) -> Dict[str, Any]:
    """Load configuration from YAML file, falling back to defaults."""
    path = config_path or _CONFIG_PATH
    if not path.exists():
        return _DEFAULT_CONFIG

    with open(path, "r", encoding="utf-8") as f:
        user_config = yaml.safe_load(f) or {}

    return _merge_defaults(_DEFAULT_CONFIG, user_config)


def _merge_defaults(defaults: Dict[str, Any], overrides: Dict[str, Any]) -> Dict[str, Any]:
    """Deep-merge overrides into defaults."""
    merged = {}
    for key, default_val in defaults.items():
        override_val = overrides.get(key)
        if isinstance(default_val, dict) and isinstance(override_val, dict):
            merged[key] = _merge_defaults(default_val, override_val)
        else:
            merged[key] = override_val if override_val is not None else default_val
    return merged


def get_output_dir(config: Optional[Dict[str, Any]] = None) -> Path:
    """Get expanded output directory path from config.
    
    Relative paths (e.g., "./raw") are resolved against the current working directory.
    Absolute paths or tilde paths are resolved normally.
    """
    cfg = config or load_config()
    raw_path = Path(cfg["output_dir"])
    if raw_path.is_absolute() or str(raw_path).startswith("~"):
        return raw_path.expanduser().resolve()
    # Relative path — resolve against CWD
    return (Path.cwd() / raw_path).resolve()


def get_supported_extensions(config: Optional[Dict[str, Any]] = None) -> set:
    """Get set of supported file extensions from config."""
    cfg = config or load_config()
    return set(cfg["supported_extensions"])


def get_manifest_path(output_dir: Path) -> Path:
    """Get manifest.json path within output_dir."""
    return output_dir / "manifest.json"

"""Core converter — orchestrates single file, batch, and plan operations."""

import json
import shutil
import uuid
from pathlib import Path
from typing import Dict, Any, List, Optional, Tuple
from concurrent.futures import ThreadPoolExecutor, as_completed

from .config_loader import load_config, get_output_dir, get_supported_extensions, get_manifest_path
from .manifest_manager import (
    load_manifest,
    check_converted,
    upsert_file_record,
    compute_sha256,
    ManifestLoadError,
    ManifestSaveError,
)
from .mineru_caller import run_mineru, MineruError
from .file_organizer import move_mineru_output, OrganizerError


class ConvertError(Exception):
    """Base exception for conversion operations."""


def _get_format(file_path: Path) -> str:
    """Return lowercase file extension."""
    return file_path.suffix.lower()


def _is_supported(file_path: Path, config: Optional[Dict] = None) -> bool:
    """Check if a file extension is supported."""
    return file_path.suffix.lower() in get_supported_extensions(config)


def _collect_files(input_path: Path) -> List[Path]:
    """Recursively collect supported files from a directory, or return the single file."""
    input_path = Path(input_path).expanduser().resolve()
    config = load_config()

    if input_path.is_file():
        return [input_path]

    files = []
    for ext in config.get("supported_extensions", []):
        files.extend(input_path.rglob(f"*{ext}"))

    return sorted(files)


def _parse_page_range(pages_str: str) -> Tuple[Optional[int], Optional[int]]:
    """
    Parse page range string like '3-5' into (start, end) 0-indexed.
    Single page '3' returns (2, 2).

    Returns:
        (start_page, end_page) as 0-indexed ints, or (None, None).
    """
    if not pages_str:
        return None, None
    pages_str = pages_str.strip()
    if "-" in pages_str:
        parts = pages_str.split("-", 1)
        start = int(parts[0]) - 1
        end = int(parts[1]) - 1
        return start, end
    else:
        page = int(pages_str) - 1
        return page, page


def convert_single(
    file_path: Path,
    output_dir: Optional[Path] = None,
    force: bool = False,
    verbose: bool = False,
    pages: Optional[str] = None,
    method: Optional[str] = None,
    lang: Optional[str] = None,
) -> Dict[str, Any]:
    """
    Convert a single file.

    Args:
        pages: Page range string, e.g. '3-5' (1-indexed). Only for PDF.
        method: PDF parsing method — 'auto', 'txt', 'ocr'.
        lang: Document language code.

    Returns:
        Dict with keys: path, status (success/skipped/failed), error, details
    """
    file_path = Path(file_path).expanduser().resolve()
    output_dir = Path(output_dir or get_output_dir()).expanduser().resolve()
    output_dir.mkdir(parents=True, exist_ok=True)

    # Parse page range
    start_page, end_page = _parse_page_range(pages) if pages else (None, None)

    result = {
        "path": str(file_path),
        "status": "pending",
        "error": None,
        "details": None,
    }

    # Check if supported
    if not _is_supported(file_path):
        result["status"] = "skipped"
        result["error"] = f"Unsupported format: {file_path.suffix}"
        return result

    # Check if already converted
    manifest = load_manifest(get_manifest_path(output_dir))
    is_converted, new_hash = check_converted(file_path, manifest)

    if is_converted and not force:
        result["status"] = "skipped"
        return result

    file_format = _get_format(file_path)
    file_hash = new_hash or _get_file_hash(file_path)

    # EPUB conversion — does not use MinerU
    if file_format == ".epub":
        return _convert_epub_workflow(
            file_path, output_dir, file_format, result,
        )

    try:
        # Step 1: Run MinerU
        tmp_dir = output_dir / f".tmp_mineru_{uuid.uuid4().hex[:8]}"
        mineru_results = run_mineru(
            file_path, tmp_dir, verbose=verbose,
            start_page=start_page, end_page=end_page,
            method=method, lang=lang,
        )

        if not mineru_results:
            raise MineruError("MinerU produced no output")

        # Use the first (and usually only) output subdirectory from MinerU
        mineru_subdir = Path(mineru_results[0]["subdir"])

        # Step 2: Move outputs and rewrite paths
        final_result = move_mineru_output(mineru_subdir, output_dir)

        # Step 3: Cleanup temp MinerU directory
        try:
            shutil.rmtree(tmp_dir)
        except OSError:
            pass

        # Step 4: Update manifest (atomic load-modify-save)
        attachments_rel = f"attachments/{final_result['hash_prefix']}"
        md_rel = Path(final_result["md_path"]).relative_to(output_dir)
        upsert_file_record(
            file_path,
            output_md=str(md_rel),
            output_attachments=attachments_rel,
            file_format=file_format,
            status="success",
        )

        result["status"] = "success"
        result["details"] = {
            "md_path": str(final_result["md_path"]),
            "attachments_path": final_result["attachments_path"],
            "images": final_result["image_count"],
        }

    except MineruError as e:
        result["status"] = "failed"
        result["error"] = f"MinerU error: {e}"
        try:
            shutil.rmtree(tmp_dir)
        except OSError:
            pass
        try:
            upsert_file_record(
                file_path,
                output_md="", output_attachments="",
                file_format=file_format,
                status="failed", error=str(e),
            )
        except ManifestSaveError:
            pass

    except OrganizerError as e:
        result["status"] = "failed"
        result["error"] = f"Organization error: {e}"
        try:
            shutil.rmtree(tmp_dir)
        except OSError:
            pass

    except Exception as e:
        result["status"] = "failed"
        result["error"] = f"Unexpected error: {e}"
        try:
            shutil.rmtree(tmp_dir)
        except OSError:
            pass

    return result


def convert_batch(
    dir_path: Path,
    output_dir: Optional[Path] = None,
    force: bool = False,
    workers: int = 1,
    verbose: bool = False,
    method: Optional[str] = None,
    lang: Optional[str] = None,
) -> Dict[str, Any]:
    """
    Convert all supported files in a directory.

    Args:
        method: PDF parsing method applied to all files.
        lang: Document language applied to all files.

    Returns:
        Dict with scanned, processed, skipped, failed counts and per-file results.
    """
    dir_path = Path(dir_path).expanduser().resolve()
    output_dir = Path(output_dir or get_output_dir()).expanduser().resolve()
    output_dir.mkdir(parents=True, exist_ok=True)

    files = _collect_files(dir_path)
    if not files:
        return {
            "scanned": 0, "processed": 0, "skipped": 0, "failed": 0,
            "items": [], "message": f"No supported files found in {dir_path}",
        }

    results = []
    stats = {"scanned": len(files), "processed": 0, "skipped": 0, "failed": 0}

    def _convert_one(fp: Path) -> Dict[str, Any]:
        return convert_single(fp, output_dir, force=force, verbose=verbose, method=method, lang=lang)

    # Single-threaded by default for manifest safety; parallel if workers > 1
    if workers > 1:
        with ThreadPoolExecutor(max_workers=workers) as executor:
            futures = {executor.submit(_convert_one, fp): fp for fp in files}
            for future in as_completed(futures):
                try:
                    r = future.result()
                except Exception as e:
                    r = {"path": str(futures[future]), "status": "failed", "error": str(e), "details": None}
                results.append(r)
    else:
        for fp in files:
            results.append(_convert_one(fp))

    # Aggregate stats
    for r in results:
        if r["status"] == "skipped":
            stats["skipped"] += 1
        elif r["status"] == "success":
            stats["processed"] += 1
        elif r["status"] == "failed":
            stats["failed"] += 1

    stats["items"] = results
    return stats


def build_plan(
    dir_path: Path,
    output_dir: Optional[Path] = None,
) -> Dict[str, Any]:
    """
    Build a conversion plan: which files are skip vs process.

    Returns:
        Dict with scanned count, skip list, process list, and failed list.
    """
    dir_path = Path(dir_path).expanduser().resolve()
    output_dir = Path(output_dir or get_output_dir()).expanduser().resolve()
    output_dir.mkdir(parents=True, exist_ok=True)

    files = _collect_files(dir_path)
    manifest = load_manifest(get_manifest_path(output_dir))

    plan = {
        "source_dir": str(dir_path),
        "output_dir": str(output_dir),
        "scanned": len(files),
        "skip": [],
        "process": [],
        "unsupported": [],
    }

    for fp in files:
        if not _is_supported(fp):
            plan["unsupported"].append({"path": str(fp), "reason": f"Unsupported format: {fp.suffix}"})
            continue

        is_converted, _ = check_converted(fp, manifest)
        entry = {"path": str(fp)}

        if is_converted:
            # Check if content has changed
            file_hash = _get_file_hash(fp)
            # Find existing record by filename
            found = False
            for hk, record in manifest.get("files", {}).items():
                if record.get("source_filename") == fp.name:
                    if hk == file_hash:
                        entry["reason"] = "Already converted"
                    else:
                        entry["reason"] = "Modified (re-conversion needed)"
                    break
            if not found:
                entry["reason"] = "Already converted"
            plan["skip"].append(entry)
        else:
            plan["process"].append(entry)

    return plan


def get_status(
    output_dir: Optional[Path] = None,
    list_converted: bool = False,
    list_failed: bool = False,
) -> Dict[str, Any]:
    """Get conversion status statistics."""
    output_dir = Path(output_dir or get_output_dir()).expanduser().resolve()
    manifest = load_manifest(get_manifest_path(output_dir))

    files = manifest.get("files", {})
    status = {
        "output_dir": str(output_dir),
        "total": len(files),
        "success": 0,
        "failed": 0,
        "converted": [],
        "failed_list": [],
    }

    for hash_key, record in files.items():
        if record.get("status") == "success":
            status["success"] += 1
            if list_converted:
                status["converted"].append({
                    "file": record.get("source_filename"),
                    "format": record.get("format"),
                    "converted_at": record.get("converted_at"),
                })
        else:
            status["failed"] += 1
            if list_failed:
                status["failed_list"].append({
                    "file": record.get("source_filename"),
                    "error": record.get("error"),
                })

    return status


def _get_file_hash(file_path: Path) -> str:
    """Helper to compute file hash (wrapper for manifest_manager.compute_sha256)."""
    return compute_sha256(file_path)


def _convert_epub_workflow(
    file_path: Path,
    output_dir: Path,
    file_format: str,
    result: Dict[str, Any],
) -> Dict[str, Any]:
    """Convert an EPUB file and record the result in the manifest."""
    from .epub_converter import convert_epub, EpubConvertError

    manifest_path = get_manifest_path(output_dir)

    try:
        final_result = convert_epub(file_path, output_dir)

        attachments_rel = f"attachments/{final_result['hash_prefix']}"
        md_rel = Path(final_result["md_path"]).relative_to(output_dir)
        upsert_file_record(
            file_path,
            output_md=str(md_rel),
            output_attachments=attachments_rel,
            file_format=file_format,
            status="success",
            manifest_path=manifest_path,
        )

        result["status"] = "success"
        result["details"] = {
            "md_path": str(final_result["md_path"]),
            "attachments_path": final_result["attachments_path"],
            "images": final_result["image_count"],
        }

    except EpubConvertError as e:
        result["status"] = "failed"
        result["error"] = f"EPUB conversion error: {e}"
        try:
            upsert_file_record(
                file_path,
                output_md="", output_attachments="",
                file_format=file_format,
                status="failed", error=str(e),
                manifest_path=manifest_path,
            )
        except ManifestSaveError:
            pass

    except Exception as e:
        result["status"] = "failed"
        result["error"] = f"Unexpected EPUB error: {e}"
        try:
            upsert_file_record(
                file_path,
                output_md="", output_attachments="",
                file_format=file_format,
                status="failed", error=str(e),
                manifest_path=manifest_path,
            )
        except ManifestSaveError:
            pass

    return result

"""EPUB to Markdown converter — standalone, does not depend on MinerU.

Extracts images, converts HTML content to Markdown, and rewrites
image paths to the `attachments/<hash>/` convention used by
the mineru-converter skill.
"""

import hashlib
import re
from pathlib import Path
from typing import Dict, Any, Optional

from ebooklib import epub
from html2text import HTML2Text

from .config_loader import load_config

ITEM_IMAGE = 1
ITEM_DOCUMENT = 9


class EpubConvertError(Exception):
    """Base exception for EPUB conversion."""


def convert_epub(
    epub_path: Path,
    output_dir: Path,
) -> Dict[str, Any]:
    """Convert an EPUB file to Markdown and extract its images.

    Args:
        epub_path: Path to the .epub file.
        output_dir: Root output directory (e.g. ``./raw``).

    Returns:
        Dict with keys:
          - md_path: absolute path to the written .md file
          - attachments_path: absolute path to the images subdirectory
          - image_count: number of extracted images
          - hash_prefix: 8-char hex prefix used for the attachments folder
    """
    epub_path = Path(epub_path).expanduser().resolve()
    output_dir = Path(output_dir).expanduser().resolve()
    output_dir.mkdir(parents=True, exist_ok=True)

    file_hash = _compute_file_hash(epub_path)
    config = load_config()
    org = config.get("organizer", {})
    hash_prefix_len = org.get("hash_prefix_length", 8)
    hash_prefix = file_hash[:hash_prefix_len]
    attachments_dir_name = org.get("attachments_dir", "attachments")
    attachments_path = output_dir / attachments_dir_name / hash_prefix
    attachments_path.mkdir(parents=True, exist_ok=True)

    book = epub.read_epub(str(epub_path))

    name_map = _extract_images(book, attachments_path)
    md_content = _convert_content(book)
    md_content = _rewrite_image_paths(
        md_content,
        f"{attachments_dir_name}/{hash_prefix}",
        name_map,
    )

    md_path = output_dir / _derive_filename(book, epub_path)
    md_path.parent.mkdir(parents=True, exist_ok=True)
    md_path.write_text(md_content, encoding="utf-8")

    return {
        "md_path": str(md_path.resolve()),
        "attachments_path": str(attachments_path.resolve()),
        "image_count": len(name_map) // 2,
        "hash_prefix": hash_prefix,
    }


def _compute_file_hash(file_path: Path) -> str:
    """SHA-256 of the entire EPUB file (used for attachment folder naming)."""
    h = hashlib.sha256()
    with open(file_path, "rb") as f:
        for chunk in iter(lambda: f.read(65536), b""):
            h.update(chunk)
    return h.hexdigest()


def _extract_images(
    book: epub.EpubBook,
    attachments_dir: Path,
) -> Dict[str, str]:
    """Save every image embedded in the EPUB to *attachments_dir*.

    Returns a mapping of *both* the original EPUB path (``images/foo.jpg``)
    and bare filename (``foo.jpg``) → the filename used on disk, so that
    path rewriting can succeed regardless of how the HTML references the
    image.
    """
    name_map: Dict[str, str] = {}
    for item in book.get_items():
        if item.get_type() != ITEM_IMAGE:
            continue
        orig = item.get_name()
        base = Path(orig).name
        if not base:
            continue

        dest = attachments_dir / base
        if dest.exists():
            stem = Path(base).stem
            counter = 1
            while dest.exists():
                dest = attachments_dir / f"{stem}_{counter}{Path(base).suffix}"
                counter += 1

        attachments_dir.mkdir(parents=True, exist_ok=True)
        with open(dest, "wb") as f:
            f.write(item.get_content())

        name_map[orig] = dest.name
        name_map[base] = dest.name

    return name_map


def _convert_content(book: epub.EpubBook) -> str:
    """Walk every ``ITEM_DOCUMENT`` in spine order and convert to Markdown."""
    h = HTML2Text()
    h.body_width = 0
    h.ignore_links = False
    h.ignore_images = False
    h.ignore_emphasis = False
    h.unicode_snob = True
    h.single_line_break = True

    parts: list[str] = []
    for item in book.get_items():
        if item.get_type() != ITEM_DOCUMENT:
            continue
        content = item.get_body_content().decode("utf-8", errors="replace")
        md = h.handle(content)
        parts.append(md)

    return "\n\n".join(parts)


def _rewrite_image_paths(
    md_content: str,
    attachments_rel: str,
    name_map: Dict[str, str],
) -> str:
    """Replace every ``![alt](<any-path>)`` with the correct attachments path.

    Uses *name_map* (built by :func:`_extract_images`) to look up the
    actual saved filename regardless of the original reference style
    (``images/x.jpg``, ``../images/x.jpg``, ``OEBPS/x.jpg``, …).
    """

    def _replacer(m):
        alt = m.group(1)
        ref = m.group(2)
        basename = Path(ref).name
        saved = name_map.get(ref) or name_map.get(basename) or basename
        return f"![{alt}]({attachments_rel}/{saved})"

    return re.sub(r'!\[([^\]]*)\]\(([^)]+)\)', _replacer, md_content)


def _derive_filename(book: epub.EpubBook, epub_path: Path) -> str:
    """Produce a human-friendly ``.md`` filename from metadata or the file path."""

    title: Optional[str] = None
    try:
        title = book.get_metadata("DC", "title")
        if title:
            title = title[0][0]
    except Exception:
        pass

    stem = (title or epub_path.stem).strip()
    stem = re.sub(r'[\\/:*?"<>|]', "_", stem)
    if len(stem) > 128:
        stem = stem[:128]
    return f"{stem}.md"

"""File organizer — moves outputs, rewrites image paths, cleans up temp files."""

import hashlib
import re
import shutil
from pathlib import Path
from typing import Dict, Any, Optional, List

from .config_loader import load_config
from .manifest_manager import compute_sha256


class OrganizerError(Exception):
    """Base exception for file organization operations."""


def _hash_dir(dir_path: Path) -> str:
    """Compute a hash based on all files within a directory (for grouping attachments)."""
    h = hashlib.sha256()
    for f in sorted(dir_path.rglob("*")):
        if f.is_file():
            h.update(f.name.encode())
            h.update(str(f.stat().st_size).encode())
    return h.hexdigest()


class ImagePathRewriteError(OrganizerError):
    """Failed to rewrite image paths in markdown."""


def move_mineru_output(
    mineru_output_dir: Path,
    target_output_dir: Path,
) -> Dict[str, Any]:
    """
    Extract markdown and images from MinerU output, move to target directory,
    and clean up temporary MinerU subdirectories.

    Args:
        mineru_output_dir: The top-level directory where MinerU wrote results.
        target_output_dir: The target output directory (raw/).

    Returns:
        Dict with keys:
          - md_path: Path to the final markdown file
          - attachments_path: Path to the attachments subdirectory
          - md_content: Content of the markdown file (for path rewriting)
    """
    mineru_output_dir = Path(mineru_output_dir).resolve()
    target_output_dir = Path(target_output_dir).expanduser().resolve()
    target_output_dir.mkdir(parents=True, exist_ok=True)

    config = load_config()
    organizer_config = config.get("organizer", {})
    attachments_dir_name = organizer_config.get("attachments_dir", "attachments")
    hash_prefix_len = organizer_config.get("hash_prefix_length", 8)

    # Compute hash for attachments folder (from md files' content)
    md_files = list(mineru_output_dir.rglob("*.md"))
    if md_files:
        file_hash = compute_sha256(md_files[0])
    else:
        file_hash = _hash_dir(mineru_output_dir)
    hash_prefix = file_hash[:hash_prefix_len]
    attachments_path = target_output_dir / attachments_dir_name / hash_prefix
    attachments_path.mkdir(parents=True, exist_ok=True)

    # Find all .md files in the mineru output
    md_files = []
    for md_file in mineru_output_dir.rglob("*.md"):
        if md_file.is_file() and md_file.stat().st_size > 0:
            md_files.append(md_file)

    if not md_files:
        raise OrganizerError(f"No valid markdown files found in {mineru_output_dir}")

    # Use the .md file whose name most closely matches the input directory name
    input_dir_name = mineru_output_dir.name.lower()
    md_file = _select_best_md(md_files, input_dir_name)

    # Copy images to attachments — search recursively (MinerU v3.x puts images in subdirs)
    images_src = None
    for img_dir in mineru_output_dir.rglob("images"):
        if img_dir.is_dir() and any(img_dir.iterdir()):
            images_src = img_dir
            break

    image_count = 0
    if images_src is not None:
        image_count = _copy_images(images_src, attachments_path)

    # Determine the target MD filename
    md_filename = _get_md_filename(md_file)
    md_dest = target_output_dir / md_filename

    # Read content, rewrite image paths, then write
    md_content = md_file.read_text(encoding="utf-8")
    md_content = rewrite_image_paths(md_content, attachments_dir_name, hash_prefix)
    md_dest.write_text(md_content, encoding="utf-8")

    return {
        "md_path": str(md_dest),
        "attachments_path": str(attachments_path),
        "md_content": md_content,
        "image_count": image_count,
        "hash_prefix": hash_prefix,
    }


def _select_best_md(md_files: List[Path], input_dir_name: str) -> Path:
    """
    Select the most appropriate .md file from the MinerU output.
    Prefers files whose stem matches the input directory name.
    """
    for md_file in md_files:
        stem = md_file.stem.lower()
        if input_dir_name in stem or stem in input_dir_name:
            return md_file

    # Fallback: pick the file with the most content
    return max(md_files, key=lambda f: f.stat().st_size)


def _get_md_filename(md_file: Path) -> str:
    """
    Derive a clean filename for the output markdown.
    Uses the md file's stem, replacing characters that are invalid in filenames.
    """
    stem = md_file.stem
    # Replace characters that could be problematic
    stem = re.sub(r'[\\/:*?"<>|]', '_', stem)
    # Limit length
    if len(stem) > 128:
        stem = stem[:128]
    return f"{stem}.md"


def _copy_images(images_src: Path, attachments_dest: Path) -> int:
    """
    Copy all images from source to destination, handling name conflicts
    by appending a numeric suffix.

    Returns the number of images copied.
    """
    count = 0
    for img_file in sorted(images_src.iterdir()):
        if not img_file.is_file():
            continue
        ext = img_file.suffix.lower()
        if ext not in (".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp", ".tiff", ".tif"):
            continue

        dest = attachments_dest / img_file.name
        if dest.exists():
            # Handle conflicts
            counter = 1
            base = img_file.stem
            while dest.exists():
                dest = attachments_dest / f"{base}_{counter}{ext}"
                counter += 1
        shutil.copy2(str(img_file), str(dest))
        count += 1

    return count


def rewrite_image_paths(
    md_content: str,
    attachments_base: str = "attachments",
    hash_prefix: str = "",
) -> str:
    """
    Rewrite image paths in markdown content.

    Converts paths like:
      - ![alt](images/img.png)
      - ![alt](./images/img.png)
    To:
      - ![alt](attachments/<hash>/img.png)

    Args:
        md_content: The markdown content to rewrite.
        attachments_base: Base name for the attachments directory (default: "attachments").
        hash_prefix: The hash prefix for the attachments subdirectory.

    Returns:
        The rewritten markdown content.
    """
    # Pattern matches ![...](path) where path starts with images/ or ./images/
    pattern = re.compile(
        r'(!\[[^\]]*\])\((?:\./)?images/([^)]+)\)'
    )

    def replacer(match):
        prefix = match.group(1)
        img_name = match.group(2)
        return f"{prefix}({attachments_base}/{hash_prefix}/{img_name})"

    return pattern.sub(replacer, md_content)


def cleanup_mineru_subdirs(output_dir: Path, keep_subdirs: Optional[List[str]] = None) -> int:
    """
    Remove temporary subdirectories created by MinerU that are no longer needed.

    Args:
        output_dir: The top-level output directory.
        keep_subdirs: List of subdirectory names to keep (relative to output_dir).

    Returns:
        Number of directories removed.
    """
    output_dir = Path(output_dir).resolve()
    keep_subdirs = keep_subdirs or []
    removed = 0

    for item in output_dir.iterdir():
        if not item.is_dir():
            continue
        if item.name in keep_subdirs:
            continue
        try:
            shutil.rmtree(item)
            removed += 1
        except OSError:
            pass

    return removed

"""Manifest manager for tracking converted files with SHA256 hashing and file locking."""

import hashlib
import json
import fcntl
from datetime import datetime, timezone
from pathlib import Path
from typing import Dict, Any, Optional, Tuple
from contextlib import contextmanager

from .config_loader import load_config, get_output_dir, get_manifest_path


class ManifestError(Exception):
    """Base exception for manifest operations."""


class ManifestLoadError(ManifestError):
    """Failed to load manifest."""


class ManifestSaveError(ManifestError):
    """Failed to save manifest."""


@contextmanager
def _locked_file(file_path: Path, mode: str = "r+"):
    """Context manager that applies file locking for safe concurrent access."""
    if not file_path.exists() and "r" not in mode:
        file_path.parent.mkdir(parents=True, exist_ok=True)
        fd = open(file_path, mode)
    else:
        fd = open(file_path, mode)

    try:
        if "r" in mode:
            fcntl.flock(fd, fcntl.LOCK_SH)
        else:
            fcntl.flock(fd, fcntl.LOCK_EX)
        yield fd
    finally:
        fcntl.flock(fd, fcntl.LOCK_UN)
        fd.close()


def compute_sha256(file_path: Path) -> str:
    """Compute SHA256 hash of a file."""
    file_path = Path(file_path).expanduser().resolve()
    sha256 = hashlib.sha256()
    with open(file_path, "rb") as f:
        for chunk in iter(lambda: f.read(8192), b""):
            sha256.update(chunk)
    return sha256.hexdigest()


def load_manifest(manifest_path: Optional[Path] = None) -> Dict[str, Any]:
    """Load manifest.json from disk."""
    if manifest_path is None:
        output_dir = get_output_dir()
        manifest_path = get_manifest_path(output_dir)

    if not manifest_path.exists():
        return {
            "version": load_config().get("manifest", {}).get("version", "1.0"),
            "files": {},
        }

    try:
        with _locked_file(manifest_path, "r") as f:
            content = f.read()
            return json.loads(content)
    except (json.JSONDecodeError, IOError) as e:
        raise ManifestLoadError(f"Failed to load manifest from {manifest_path}: {e}")


def save_manifest(manifest: Dict[str, Any], manifest_path: Optional[Path] = None) -> None:
    """Save manifest to disk with file locking."""
    if manifest_path is None:
        output_dir = get_output_dir()
        manifest_path = get_manifest_path(output_dir)

    manifest_path.parent.mkdir(parents=True, exist_ok=True)

    try:
        with _locked_file(manifest_path, "w") as f:
            fcntl.flock(f, fcntl.LOCK_EX)
            f.seek(0)
            f.truncate()
            json.dump(manifest, f, indent=2, ensure_ascii=False)
    except IOError as e:
        raise ManifestSaveError(f"Failed to save manifest to {manifest_path}: {e}")


def upsert_file_record(
    file_path: Path,
    output_md: str,
    output_attachments: str,
    file_format: str,
    status: str = "success",
    error: Optional[str] = None,
    manifest_path: Optional[Path] = None,
) -> None:
    """Atomically load manifest, add/update a file record, and save — all under one lock."""
    if manifest_path is None:
        output_dir = get_output_dir()
        manifest_path = get_manifest_path(output_dir)

    file_path = Path(file_path).expanduser().resolve()
    manifest_path = Path(manifest_path).expanduser().resolve()

    file_hash = compute_sha256(file_path)
    record = build_record(
        source_path=file_path,
        output_md=output_md,
        output_attachments=output_attachments,
        file_format=file_format,
        status=status,
        error=error,
    )

    manifest_path.parent.mkdir(parents=True, exist_ok=True)
    # Ensure file exists before opening for read+write
    if not manifest_path.exists():
        json.dump(
            {"version": load_config().get("manifest", {}).get("version", "1.0"), "files": {}},
            open(manifest_path, "w"),
        )
    try:
        with open(manifest_path, "r+") as f:
            fcntl.flock(f, fcntl.LOCK_EX)
            content = f.read()
            if not content:
                content = "{}"
            try:
                manifest = json.loads(content)
            except json.JSONDecodeError:
                manifest = {"version": load_config().get("manifest", {}).get("version", "1.0"), "files": {}}
            manifest.setdefault("files", {})[file_hash] = record
            f.seek(0)
            f.truncate()
            json.dump(manifest, f, indent=2, ensure_ascii=False)
            f.flush()
    except IOError as e:
        raise ManifestSaveError(f"Failed to save manifest to {manifest_path}: {e}")


def upsert_record(manifest: Dict[str, Any], file_hash: str, record: Dict[str, Any]) -> Dict[str, Any]:
    """Add or update a file record in the manifest."""
    manifest.setdefault("files", {})[file_hash] = record
    return manifest


def build_record(
    source_path: Path,
    output_md: str,
    output_attachments: str,
    file_format: str,
    status: str = "success",
    error: Optional[str] = None,
) -> Dict[str, Any]:
    """Build a manifest record for a converted file."""
    return {
        "source_path": str(Path(source_path).expanduser().resolve()),
        "source_filename": source_path.name,
        "output_md": output_md,
        "output_attachments": output_attachments,
        "format": file_format,
        "converted_at": datetime.now(timezone.utc).isoformat(),
        "status": status,
        "error": error,
    }


def check_converted(
    file_path: Path,
    manifest: Dict[str, Any],
) -> Tuple[bool, Optional[str]]:
    """
    Check if a file has already been converted.
    Returns (is_converted, hash_key).
    """
    file_path = Path(file_path).expanduser().resolve()
    file_hash = compute_sha256(file_path)

    files = manifest.get("files", {})
    for hash_key, record in files.items():
        if record.get("source_path") == str(file_path):
            # Source path matches — check if hash changed
            if hash_key == file_hash:
                return True, hash_key
            else:
                # File modified — return not converted but with new hash
                return False, file_hash
        # Also check by source_filename + size as fallback
        if record.get("source_filename") == file_path.name:
            existing_size = record.get("source_size")
            current_size = file_path.stat().st_size
            if existing_size == current_size:
                if hash_key == file_hash:
                    return True, hash_key

    return False, file_hash


def add_conversion_record(
    manifest: Dict[str, Any],
    file_path: Path,
    output_md: str,
    output_attachments: str,
    file_format: str,
    status: str = "success",
    error: Optional[str] = None,
) -> Dict[str, Any]:
    """Add a conversion record to the manifest and return the hash key."""
    file_hash = compute_sha256(file_path)
    record = build_record(
        source_path=file_path,
        output_md=output_md,
        output_attachments=output_attachments,
        file_format=file_format,
        status=status,
        error=error,
    )
    manifest = upsert_record(manifest, file_hash, record)
    return manifest

"""MinerU CLI wrapper — invokes mineru command and returns output metadata."""

import subprocess
from pathlib import Path
from typing import List, Dict, Any, Optional, Tuple

from .config_loader import load_config, get_output_dir, get_manifest_path


class MineruError(Exception):
    """Base exception for MinerU operations."""


class MineruNotFoundError(MineruError):
    """MinerU CLI not found."""


class MineruExecutionError(MineruError):
    """MinerU command failed."""


# Format-specific extra arguments
_FORMAT_EXTRA_ARGS: Dict[str, List[str]] = {
    ".xlsx": ["--table"],
}

# Timeout in seconds
_TIMEOUT = 300


def run_mineru(
    input_path: Path,
    output_dir: Path,
    verbose: bool = False,
    start_page: Optional[int] = None,
    end_page: Optional[int] = None,
    method: Optional[str] = None,
    lang: Optional[str] = None,
) -> List[Dict[str, str]]:
    """
    Invoke MinerU to convert a single file.

    Args:
        input_path: Path to the source file.
        output_dir: Directory where MinerU writes results.
        verbose: If True, print MinerU stderr output.
        start_page: 0-indexed start page (PDF only).
        end_page: 0-indexed end page (PDF only).
        method: PDF parsing method — 'auto', 'txt', or 'ocr'.
        lang: Document language code (e.g. 'ch', 'en', 'ja').

    Returns:
        List of dicts with keys:
          - subdir: relative path of the output subdirectory
          - md_files: list of .md file paths found
          - images_dir: path to the images directory (or None)

    Raises:
        MineruNotFoundError: If mineru command is not available.
        MineruExecutionError: If MinerU fails.
    """
    input_path = Path(input_path).expanduser().resolve()
    output_dir = Path(output_dir).expanduser().resolve()
    output_dir.mkdir(parents=True, exist_ok=True)

    config = load_config()
    mineru_config = config.get("mineru", {})
    mineru_cmd = mineru_config.get("command", "mineru")
    default_args = mineru_config.get("args", {})

    cmd = [
        mineru_cmd,
        "-p", str(input_path),
        "-o", str(output_dir),
        "-b", default_args.get("backend", "pipeline"),
    ]

    # -m method: CLI arg overrides config
    if method is not None:
        cmd.extend(["-m", method])
    elif default_args.get("method", "auto") != "auto":
        cmd.extend(["-m", default_args["method"]])

    # -l language: CLI arg overrides config
    if lang is not None:
        cmd.extend(["-l", lang])
    elif default_args.get("language", "ch") != "ch":
        cmd.extend(["-l", default_args["language"]])

    # -s/-e page range (only for PDF)
    if start_page is not None:
        cmd.extend(["-s", str(start_page)])
    if end_page is not None:
        cmd.extend(["-e", str(end_page)])

    # Add format-specific arguments
    ext = input_path.suffix.lower()
    cmd.extend(_FORMAT_EXTRA_ARGS.get(ext, []))

    try:
        result = subprocess.run(
            cmd,
            capture_output=True,
            text=True,
            check=True,
            timeout=_TIMEOUT,
        )
    except FileNotFoundError:
        raise MineruNotFoundError(
            f"mineru command not found: {mineru_cmd}. "
            "Please ensure MinerU is installed and available in PATH."
        )
    except subprocess.TimeoutExpired:
        raise MineruExecutionError(f"MinerU timed out after {_TIMEOUT}s for {input_path}")
    except subprocess.CalledProcessError as e:
        stderr = e.stderr or ""
        if verbose:
            print(f"[mineru stderr] {stderr}")
        raise MineruExecutionError(
            f"MinerU failed (exit code {e.returncode}) for {input_path}: {stderr}"
        )

    if verbose and result.stdout:
        print(f"[mineru output] {result.stdout.strip()}")

    return _scan_mineru_output(output_dir, input_path)


def check_mineru_available() -> Tuple[bool, Optional[str]]:
    """
    Check if the MinerU command is available and responds to --version.

    Reads the command from config.yaml, falls back to "mineru".

    Returns:
        Tuple of (available: bool, version_string: str or None).
    """
    config = load_config()
    mineru_cmd = config.get("mineru", {}).get("command", "mineru")

    try:
        result = subprocess.run(
            [mineru_cmd, "--version"],
            capture_output=True,
            text=True,
            timeout=30,
        )
        if result.returncode == 0:
            version = result.stdout.strip().split("\n")[-1].strip()
            return True, version
        return False, None
    except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
        return False, None


def _scan_mineru_output(output_dir: Path, input_path: Path) -> List[Dict[str, str]]:
    """
    Scan the output directory for MinerU-generated subdirectories.

    Finds all subdirectories, locates .md files and images, returns metadata.
    """
    output_dir = Path(output_dir).resolve()
    results = []

    for item in sorted(output_dir.iterdir()):
        if not item.is_dir():
            continue

        md_files = []
        for md_file in item.rglob("*.md"):
            if md_file.is_file():
                md_files.append(str(md_file))

        images_dir = None
        images_path = item / "images"
        if images_path.is_dir():
            images_dir = str(images_path)

        results.append({
            "subdir": str(item),
            "md_files": md_files,
            "images_dir": images_dir,
        })

    if not results:
        raise MineruExecutionError(
            f"No output subdirectories found in {output_dir}. "
            "MinerU may have failed or written to an unexpected location."
        )

    return results

"""MinerU installation guidance and automatic setup."""

import subprocess
from pathlib import Path
from typing import Tuple
import yaml

from .config_loader import load_config

_SKILL_DIR = Path(__file__).resolve().parent.parent


def check_mineru_available() -> Tuple[bool, str]:
    """
    Check if MinerU is available by running mineru --version.

    Returns:
        (available: bool, version: str)
    """
    from .mineru_caller import check_mineru_available as _check
    return _check()


def install_mineru_auto(
    use_all: bool = True,
) -> bool:
    """
    Automatically install MinerU in a local venv under the skill directory.

    Creates ~/.config/opencode/skills/mineru-converter/.mineru_venv
    and installs mineru[all] or mineru[core] into it.
    Updates config.yaml to point to the venv's mineru binary.

    Args:
        use_all: If True, install mineru[all]; otherwise mineru[core].

    Returns:
        True if installation succeeded.
    """
    venv_dir = _SKILL_DIR / ".mineru_venv"
    pip_install = "mineru[all]" if use_all else "mineru[core]"

    print(f"\nCreating virtual environment at {venv_dir}...")
    result = subprocess.run(
        ["python3", "-m", "venv", str(venv_dir)],
        capture_output=True, text=True,
    )
    if result.returncode != 0:
        print(f"Failed to create venv: {result.stderr}")
        return False

    pip_cmd = str(venv_dir / "bin" / "pip")
    print(f"Installing {pip_install}...")
    result = subprocess.run(
        [pip_cmd, "install", "-i", "https://mirrors.aliyun.com/pypi/simple", pip_install],
        capture_output=True, text=True,
        timeout=600,
    )
    if result.returncode != 0:
        print(f"Installation failed: {result.stderr}")
        return False

    mineru_bin = str(venv_dir / "bin" / "mineru")
    print(f"\nMinerU installed successfully at {mineru_bin}")

    # Update config.yaml
    _update_config_command(_SKILL_DIR / "config.yaml", mineru_bin)

    return True


def _update_config_command(config_path: Path, mineru_bin: str) -> None:
    """Update config.yaml with the new mineru command path."""
    cfg_path = Path(config_path).expanduser().resolve()
    if not cfg_path.exists():
        return

    with open(cfg_path, "r", encoding="utf-8") as f:
        config = yaml.safe_load(f) or {}

    config.setdefault("mineru", {})["command"] = mineru_bin

    with open(cfg_path, "w", encoding="utf-8") as f:
        yaml.dump(config, f, default_flow_style=False, allow_unicode=True, sort_keys=False)


def show_manual_instructions() -> str:
    """Return installation instructions as text."""
    return (
        "\nMinerU is not installed. Install it manually:\n\n"
        "  1. Create a virtual environment:\n"
        "     python3 -m venv ~/Projects/mineru_env\n"
        "     source ~/Projects/mineru_env/bin/activate\n\n"
        "  2. Install MinerU (with all backends):\n"
        "     pip install -i https://mirrors.aliyun.com/pypi/simple 'mineru[all]'\n\n"
        "     Or core only (lighter):\n"
        "     pip install -i https://mirrors.aliyun.com/pypi/simple 'mineru[core]'\n\n"
        "  3. Verify:\n"
        "     mineru --version\n\n"
        "After installing, call the converter again.\n"
    )

"""Validate converted output — checks MD existence, image paths, and manifest consistency."""

import re
from pathlib import Path
from typing import Dict, Any, List, Optional

from .config_loader import get_output_dir, get_manifest_path
from .manifest_manager import load_manifest


class ValidationResult:
    def __init__(self):
        self.errors: List[str] = []
        self.warnings: List[str] = []
        self.files_checked: int = 0

    @property
    def is_valid(self) -> bool:
        return len(self.errors) == 0

    def summary(self) -> str:
        parts = [f"Checked: {self.files_checked} files"]
        if self.errors:
            parts.append(f"Errors: {len(self.errors)}")
        if self.warnings:
            parts.append(f"Warnings: {len(self.warnings)}")
        return " | ".join(parts)


def validate_conversion(
    output_dir: Optional[Path] = None,
) -> ValidationResult:
    """
    Validate all entries in manifest.json against actual files on disk.

    Checks:
      - Each manifest entry's output_md file exists
      - Each manifest entry's attachments directory exists (if specified)
      - Image paths in MD files reference valid files
    """
    output_dir = Path(output_dir or get_output_dir()).expanduser().resolve()
    result = ValidationResult()

    manifest = load_manifest(get_manifest_path(output_dir))
    files = manifest.get("files", {})

    if not files:
        result.warnings.append("No records in manifest to validate")
        return result

    for file_hash, record in files.items():
        result.files_checked += 1

        # Check MD file exists
        md_rel = record.get("output_md", "")
        if not md_rel:
            result.warnings.append(f"Record {file_hash}: no output_md path")
            continue

        md_path = output_dir / md_rel
        if not md_path.exists():
            result.errors.append(f"MD file missing: {md_path}")
            continue

        # Check attachments exist
        attachments_rel = record.get("output_attachments", "")
        if attachments_rel:
            attachments_path = output_dir / attachments_rel
            if not attachments_path.exists():
                result.warnings.append(f"Attachments missing: {attachments_path}")

        # Check image references in MD
        if md_path.exists():
            _check_image_refs(md_path, output_dir, result)

    return result


def _check_image_refs(md_path: Path, output_dir: Path, result: ValidationResult) -> None:
    """Check that all image references in a markdown file point to existing files."""
    content = md_path.read_text(encoding="utf-8")
    pattern = re.compile(r'!\[[^\]]*\]\(([^)]+)\)')
    refs = pattern.findall(content)

    for ref in refs:
        # Skip external URLs
        if ref.startswith("http://") or ref.startswith("https://"):
            continue

        img_path = output_dir / ref
        if not img_path.exists():
            result.warnings.append(f"Image not found: {img_path} (referenced from {md_path})")


if __name__ == "__main__":
    import sys
    output = Path(sys.argv[1]).expanduser().resolve() if len(sys.argv) > 1 else None
    vr = validate_conversion(output_dir=output)
    print(vr.summary())
    for e in vr.errors:
        print(f"  ERROR: {e}", file=sys.stderr)
    for w in vr.warnings:
        print(f"  WARN:  {w}")
    sys.exit(0 if vr.is_valid else 1)