#!/usr/bin/env python3
"""Render 1C saved-state object report JSON as Markdown."""

from __future__ import annotations

import argparse
import json
from pathlib import Path
from typing import Any


def load_json(path: Path) -> dict[str, Any]:
    return json.loads(path.read_text(encoding="utf-8-sig"))


def line(text: str = "") -> str:
    return text.rstrip() + "\n"


def bullet(text: str) -> str:
    return f"- {text}\n"


def code(value: Any) -> str:
    if value is None:
        return "`null`"
    return f"`{value}`"


def trim(value: str, max_chars: int) -> str:
    if len(value) <= max_chars:
        return value
    return value[: max_chars - 3].rstrip() + "..."


def storage_summary(storage: Any) -> str:
    rows = storage if isinstance(storage, list) else [storage]
    parts: list[str] = []
    for row in rows:
        if not isinstance(row, dict):
            continue
        saved = row.get("saved_table")
        active = row.get("active_table")
        name = row.get("file_name")
        active_exists = row.get("active_exists")
        parts.append(f"{saved}->{active} `{name}` active_exists=`{active_exists}`")
    return "; ".join(parts)


def render_object_change(change: dict[str, Any]) -> str:
    full_name = change.get("full_name") or change.get("name")
    layer = change.get("layer")
    kind_ru = change.get("kind_ru") or change.get("kind")
    synonym = change.get("synonym")
    out = bullet(f"{code(full_name)}: слой={code(layer)}, вид={code(kind_ru)}, состояние={code(change.get('change_state'))}")
    if synonym:
        out += f"  Синоним: {code(synonym)}\n"
    storage = storage_summary(change.get("storage") or [])
    if storage:
        out += f"  Хранилище: {storage}\n"
    return out


def render_system_change(change: dict[str, Any]) -> str:
    name = change.get("name")
    layer = change.get("layer")
    extension = change.get("extension")
    storage = storage_summary(change.get("storage") or {})
    suffix = f", расширение={code(extension)}" if extension else ""
    if storage:
        return bullet(f"{code(name)}: слой={code(layer)}{suffix}; {storage}")
    return bullet(f"{code(name)}: слой={code(layer)}{suffix}")


def render_agent_summary(summary: dict[str, Any]) -> str:
    out = ""
    objects = summary.get("object_changes") or []
    systems = summary.get("system_changes") or []
    if not objects and not systems:
        return out
    out += line()
    out += line("## Agent Summary")
    if summary.get("default_next_action"):
        out += bullet(f"Next action: {summary.get('default_next_action')}")
    for item in objects:
        parts = item.get("parts") or []
        added = item.get("added_terms") or item.get("added_words") or []
        removed = item.get("removed_terms") or item.get("removed_words") or []
        out += bullet(
            f"{code(item.get('full_name'))}: "
            f"parts={code(item.get('parts_count'))}, "
            f"text_diff_parts={code(item.get('text_diff_parts'))}, "
            f"active_missing_parts={code(item.get('active_missing_parts'))}"
        )
        if added:
            out += f"  Added terms: {', '.join(code(word) for word in added)}\n"
        if removed:
            out += f"  Removed terms: {', '.join(code(word) for word in removed)}\n"
        for part in parts:
            out += (
                "  Part: "
                f"{code(part.get('file_name'))}, "
                f"role={code(part.get('payload_role'))}, "
                f"active_exists={code(part.get('active_exists'))}, "
                f"summary={code(part.get('summary'))}, "
                f"delta_chars={code(part.get('delta_chars'))}\n"
            )
    if systems:
        names = ", ".join(code(item.get("name")) for item in systems)
        out += bullet(f"System changes: {names}")
    return out


def render_detail(detail: dict[str, Any], max_diff_lines: int, max_words: int) -> str:
    out = ""
    out += line(f"### {detail.get('full_name')}")
    out += line()
    out += bullet(f"Слой: {code(detail.get('layer'))}")
    if detail.get("extension"):
        out += bullet(f"Расширение: {code(detail.get('extension'))}")
    out += bullet(f"Вид объекта: {code(detail.get('kind_ru') or detail.get('kind'))}")
    out += bullet(f"Имя: {code(detail.get('name'))}")
    out += line()

    for part in detail.get("details") or []:
        payload = part.get("payload") or {}
        diff = payload.get("text_diff") or {}
        out += bullet(
            "Часть "
            f"{code(part.get('file_name'))}: "
            f"role={code(part.get('payload_role'))}, "
            f"{part.get('saved_table')}->{part.get('active_table')}, "
            f"active_exists={code(part.get('active_exists'))}, "
            f"text_comparable={code(payload.get('text_comparable'))}"
        )
        summary = payload.get("summary")
        if summary:
            out += f"  Итог: {summary}\n"
        if part.get("active_cas_key"):
            out += f"  Active CAS key: {code(part.get('active_cas_key'))}\n"
        if diff:
            out += (
                "  Размер текста: "
                f"active={code(diff.get('active_chars'))}, "
                f"saved={code(diff.get('saved_chars'))}, "
                f"delta={code(diff.get('delta_chars'))}\n"
            )
            added = diff.get("added_words") or []
            removed = diff.get("removed_words") or []
            hints = payload.get("semantic_hints") or {}
            added_terms = hints.get("added_terms") or []
            removed_terms = hints.get("removed_terms") or []
            if added_terms:
                out += f"  Добавленные термины: {', '.join(code(w) for w in added_terms[:max_words])}\n"
            if removed_terms:
                out += f"  Удаленные термины: {', '.join(code(w) for w in removed_terms[:max_words])}\n"
            if added:
                out += f"  Добавленные слова: {', '.join(code(w) for w in added[:max_words])}\n"
            if removed:
                out += f"  Удаленные слова: {', '.join(code(w) for w in removed[:max_words])}\n"
            diff_lines = diff.get("unified_diff") or []
            if diff_lines:
                out += "\n"
                out += "```diff\n"
                for diff_line in diff_lines[:max_diff_lines]:
                    out += trim(str(diff_line), 220) + "\n"
                if len(diff_lines) > max_diff_lines:
                    out += f"... truncated {len(diff_lines) - max_diff_lines} lines\n"
                out += "```\n"
                out += "\n"
    return out


def resolve_linked_path(report_path: Path, value: str | None) -> Path | None:
    if not value:
        return None
    path = Path(value)
    if path.is_absolute():
        return path
    return (report_path.parent / path).resolve()


def render(data: dict[str, Any], comparison: dict[str, Any], detail: dict[str, Any], max_diff_lines: int, max_words: int) -> str:
    counts = data.get("counts") or {}
    safety = data.get("safety") or {}
    out = ""
    out += line("# 1C Saved State Object Report")
    out += line()
    out += line(f"Database: `{data.get('database')}`")
    out += line(f"View: `{comparison.get('view')}`")
    out += line(f"Report: `{data.get('report')}`")
    out += line()
    out += line("## Summary")
    out += bullet(f"Object changes: `{counts.get('object_changes')}`")
    out += bullet(f"System changes: `{counts.get('system_changes')}`")
    out += bullet(f"Detail objects: `{counts.get('detail_objects')}`")
    out += bullet(f"Detail parts: `{counts.get('detail_parts')}`")
    out += line()
    out += line("## Safety")
    for key in ("read_only", "sql_write_performed", "public_terms_are_1c_objects", "secrets_in_report"):
        out += bullet(f"{key}: `{safety.get(key)}`")

    out += render_agent_summary(data.get("agent_summary") or {})

    object_changes = comparison.get("object_changes") or []
    if object_changes:
        out += line()
        out += line("## Object Changes")
        for change in object_changes:
            out += render_object_change(change)

    system_changes = comparison.get("system_changes") or []
    if system_changes:
        out += line()
        out += line("## System Changes")
        for change in system_changes:
            out += render_system_change(change)

    object_details = detail.get("object_details") or []
    if object_details:
        out += line()
        out += line("## Details")
        for item in object_details:
            out += render_detail(item, max_diff_lines=max_diff_lines, max_words=max_words)

    active_resolution = detail.get("active_extension_resolution") or {}
    if active_resolution:
        out += line()
        out += line("## Active Extension Resolution")
        out += bullet(f"Mapped parts: `{active_resolution.get('mapped_parts')}`")
        if active_resolution.get("extension_manifest_summary"):
            out += bullet(f"Manifest summary: `{active_resolution.get('extension_manifest_summary')}`")
        if active_resolution.get("config_cas_all_dir"):
            out += bullet(f"ConfigCAS all dir: `{active_resolution.get('config_cas_all_dir')}`")
    return out


def main() -> int:
    parser = argparse.ArgumentParser(description="Render 1C saved-state object report Markdown.")
    parser.add_argument("--report", type=Path, required=True)
    parser.add_argument("--comparison", type=Path)
    parser.add_argument("--detail", type=Path)
    parser.add_argument("--output", type=Path)
    parser.add_argument("--max-diff-lines", type=int, default=80)
    parser.add_argument("--max-words", type=int, default=20)
    args = parser.parse_args()

    report = load_json(args.report)
    comparison_path = args.comparison or resolve_linked_path(args.report, report.get("comparison"))
    detail_path = args.detail or resolve_linked_path(args.report, report.get("detail"))
    if comparison_path is None:
        raise SystemExit("Comparison path is required.")
    if detail_path is None:
        raise SystemExit("Detail path is required.")

    markdown = render(
        report,
        load_json(comparison_path),
        load_json(detail_path),
        max_diff_lines=args.max_diff_lines,
        max_words=args.max_words,
    )
    if args.output:
        args.output.parent.mkdir(parents=True, exist_ok=True)
        args.output.write_text(markdown, encoding="utf-8")
        print(json.dumps({"output": str(args.output)}, ensure_ascii=False))
    else:
        print(markdown)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())