#!/usr/bin/env python3
"""
Auto-fix ESLint unused-imports errors for MD/MDX files.

Usage:
  python autofix.py /tmp/eslint.json   # path to eslint --format json output
If no path is provided, defaults to /tmp/eslint.json.
"""

from __future__ import annotations

import json
import re
import sys
from collections import defaultdict
from pathlib import Path

IMPORT_UNUSED_RULE = "unused-imports/no-unused-imports"
DEFAULT_ESLINT_JSON = Path("/tmp/eslint.json")


def load_unused_map(eslint_json: Path) -> dict[Path, set[str]]:
    """Return mapping of file -> unused import names from ESLint JSON output."""
    data = json.loads(eslint_json.read_text())
    unused_by_file: dict[Path, set[str]] = defaultdict(set)
    for result in data:
        file_path = Path(result["filePath"])
        for msg in result.get("messages", []):
            if msg.get("ruleId") != IMPORT_UNUSED_RULE:
                continue
            match = re.search(r"'([^']+)'", msg.get("message", ""))
            if match:
                unused_by_file[file_path].add(match.group(1))
    return unused_by_file


def clean_imports(text: str, unused: set[str]) -> str:
    """Remove unused names from import lines; drop empty imports."""
    lines = text.splitlines()
    new_lines: list[str] = []
    default_pat = re.compile(
        r"^\s*import\s+([A-Za-z0-9_]+)(\s*,\s*\{[^}]*\})?\s+from\s+[^;]+;?\s*$"
    )
    named_pat = re.compile(r"^\s*import\s*\{([^}]*)\}\s*from\s*[^;]+;?\s*$")

    in_fence = False

    for line in lines:
        stripped = line.lstrip()

        # Respect fenced code blocks (``` or ~~~); leave imports inside untouched.
        if stripped.startswith("```") or stripped.startswith("~~~"):
            in_fence = not in_fence
            new_lines.append(line)
            continue
        if in_fence:
            new_lines.append(line)
            continue

        if not stripped.startswith("import "):
            new_lines.append(line)
            continue

        ori_line = line

        def keep_named(named_block: str) -> list[str]:
            names = [n.strip() for n in named_block.split(",") if n.strip()]
            return [n for n in names if n not in unused]

        m = default_pat.match(line)
        if m:
            default_name = m.group(1)
            named_block = m.group(2)
            default_used = default_name not in unused
            named_kept: list[str] = []
            if named_block:
                inner = named_block[named_block.find("{") + 1 : named_block.rfind("}")]
                named_kept = keep_named(inner)
            if default_used or named_kept:
                parts: list[str] = []
                if default_used:
                    parts.append(default_name)
                if named_kept:
                    parts.append("{ " + ", ".join(named_kept) + " }")
                newline = f"import {', '.join(parts)} from" + line.split(" from", 1)[1]
                new_lines.append(newline)
            # If nothing is kept, drop the import line entirely
            continue

        m = named_pat.match(line)
        if m:
            kept = keep_named(m.group(1))
            if kept:
                newline = f"import {{ {', '.join(kept)} }} from" + line.split(" from", 1)[1]
                new_lines.append(newline)
            continue

        # Non-standard import line: leave it unchanged
        new_lines.append(ori_line)

    return "\n".join(new_lines) + ("\n" if text.endswith("\n") else "")


def apply_fixes(unused_by_file: dict[Path, set[str]]) -> int:
    changed = 0
    for file_path, unused_names in unused_by_file.items():
        if not file_path.exists():
            print(f"skip missing file: {file_path}")
            continue
        original = file_path.read_text()
        updated = clean_imports(original, unused_names)
        if updated != original:
            file_path.write_text(updated)
            changed += 1
            print(f"cleaned {file_path}")
    return changed


def main(argv: list[str]) -> int:
    eslint_json = Path(argv[1]) if len(argv) > 1 else DEFAULT_ESLINT_JSON
    if not eslint_json.exists():
        print(f"ESLint output not found at {eslint_json}", file=sys.stderr)
        return 1

    unused_by_file = load_unused_map(eslint_json)
    if not unused_by_file:
        print("No unused-imports violations found.")
        return 0

    changed = apply_fixes(unused_by_file)
    print(f"Updated {changed} file(s).")
    return 0


if __name__ == "__main__":
    raise SystemExit(main(sys.argv))