#!/usr/bin/env python3
"""Return a compact agent starting context for a 1C metadata object."""

from __future__ import annotations

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

sys.path.insert(0, str(Path(__file__).resolve().parent))
from get_1c_form_context import collect_forms, merge_effective as merge_effective_forms  # noqa: E402
from get_1c_object_code_context import (  # noqa: E402
    collect_modules,
    extension_name_from_path,
    merge_effective as merge_effective_modules,
)
from get_1c_object_metadata import build_object_metadata  # noqa: E402
from resolve_1c_object import load_json, resolve_object  # noqa: E402


def decode_arg(value: str | None, encoded: str | None) -> str | None:
    if encoded:
        return base64.b64decode(encoded).decode("utf-8")
    return value


def module_summary(module: dict[str, Any]) -> dict[str, Any]:
    overlays = module.get("extension_overlays") or []
    return {
        "name": module.get("name"),
        "kind": module.get("kind"),
        "origin": module.get("origin"),
        "effective_action": module.get("effective_action"),
        "size": module.get("size"),
        "relative_path": module.get("relative_path"),
        "overlay_count": len(overlays),
        "overlays": [
            {
                "extension": (overlay.get("origin") or {}).get("extension"),
                "effective_action": overlay.get("effective_action"),
                "size": overlay.get("size"),
                "relative_path": overlay.get("relative_path"),
            }
            for overlay in overlays
        ],
    }


def form_summary(form: dict[str, Any]) -> dict[str, Any]:
    overlays = form.get("extension_overlays") or []
    return {
        "name": form.get("name"),
        "synonym": form.get("synonym"),
        "uuid": form.get("uuid"),
        "origin": form.get("origin"),
        "effective_action": form.get("effective_action"),
        "meta_xml_path": form.get("meta_xml_path"),
        "form_xml_path": form.get("form_xml_path"),
        "module_path": form.get("module_path"),
        "overlay_count": len(overlays),
        "overlays": [
            {
                "extension": (overlay.get("origin") or {}).get("extension"),
                "effective_action": overlay.get("effective_action"),
                "uuid": overlay.get("uuid"),
                "form_xml_path": overlay.get("form_xml_path"),
                "module_path": overlay.get("module_path"),
            }
            for overlay in overlays
        ],
    }


def attribute_summary(attribute: dict[str, Any]) -> dict[str, Any]:
    result = {
        "name": attribute.get("name"),
        "synonym": attribute.get("synonym"),
        "type": attribute.get("type"),
        "types": attribute.get("types") or [],
        "origin": attribute.get("origin"),
        "effective_action": attribute.get("effective_action"),
    }
    if attribute.get("is_composite"):
        result["is_composite"] = True
    return {key: value for key, value in result.items() if value not in (None, [], "")}


def extension_names_from_resolution(resolution: dict[str, Any]) -> list[str]:
    names = []
    for overlay in resolution.get("extension_overlays") or []:
        name = extension_name_from_path(overlay.get("path")) or overlay.get("extension_name")
        if name and name not in names:
            names.append(name)
    return names


def view_modules(canonical: dict[str, Any], resolution: dict[str, Any], *, view: str, extension: str | None) -> tuple[list[dict[str, Any]], dict[str, int]]:
    base_modules = collect_modules(canonical.get("path"), source="base")
    extension_modules = []
    for overlay in resolution.get("extension_overlays") or []:
        overlay_extension = extension_name_from_path(overlay.get("path")) or overlay.get("extension_name")
        extension_modules.extend(collect_modules(overlay.get("path"), source="extension", extension_name=overlay_extension))
    if view == "base":
        modules = [{**item, "effective_action": "base"} for item in base_modules]
    elif view == "extension":
        if not extension:
            raise SystemExit("Use --extension with --view extension.")
        modules = [
            {**item, "effective_action": "extended_or_added"}
            for item in extension_modules
            if (item.get("origin") or {}).get("extension") == extension
        ]
    else:
        modules = merge_effective_modules(base_modules, extension_modules)
    return modules, {"modules": len(modules), "base_modules": len(base_modules), "extension_modules": len(extension_modules)}


def view_forms(canonical: dict[str, Any], resolution: dict[str, Any], *, view: str, extension: str | None) -> tuple[list[dict[str, Any]], dict[str, int]]:
    base_forms = collect_forms(canonical.get("path"), source="base")
    extension_forms = []
    for overlay in resolution.get("extension_overlays") or []:
        overlay_extension = extension_name_from_path(overlay.get("path")) or overlay.get("extension_name")
        extension_forms.extend(collect_forms(overlay.get("path"), source="extension", extension_name=overlay_extension))
    if view == "base":
        forms = [{**item, "effective_action": "base"} for item in base_forms]
    elif view == "extension":
        if not extension:
            raise SystemExit("Use --extension with --view extension.")
        forms = [
            {**item, "effective_action": "extended_or_added"}
            for item in extension_forms
            if (item.get("origin") or {}).get("extension") == extension
        ]
    else:
        forms = merge_effective_forms(base_forms, extension_forms)
    return forms, {"forms": len(forms), "base_forms": len(base_forms), "extension_forms": len(extension_forms)}


def build_brief_context(
    index: dict[str, Any],
    *,
    kind: str,
    name: str,
    view: str,
    extension: str | None,
    max_attributes: int,
    max_modules: int,
    max_forms: int,
) -> dict[str, Any]:
    resolution = resolve_object(index, kind=kind, name=name, limit=100)
    canonical = resolution.get("canonical")
    if not canonical:
        raise SystemExit(f"Object not found: {kind}.{name}")

    metadata = build_object_metadata(index, kind=kind, name=name, view=view, extension=extension, include_storage=False)
    modules, module_counts = view_modules(canonical, resolution, view=view, extension=extension)
    forms, form_counts = view_forms(canonical, resolution, view=view, extension=extension)

    attributes = metadata.get("attributes") or []
    tabular_sections = metadata.get("tabular_sections") or []
    extension_names = extension_names_from_resolution(resolution)
    return {
        "schema": "onec_object_brief_context.v1",
        "view": view,
        "extension": extension if view == "extension" else None,
        "object": metadata.get("object"),
        "active_extensions": extension_names,
        "attributes": {
            "items": [attribute_summary(item) for item in attributes[:max_attributes]],
            "total": len(attributes),
            "truncated": len(attributes) > max_attributes,
        },
        "tabular_sections": {
            "items": [
                {
                    "name": item.get("name"),
                    "synonym": item.get("synonym"),
                    "origin": item.get("origin"),
                }
                for item in tabular_sections
            ],
            "total": len(tabular_sections),
        },
        "forms": {
            "items": [form_summary(item) for item in forms[:max_forms]],
            "counts": form_counts,
            "truncated": len(forms) > max_forms,
        },
        "modules": {
            "items": [module_summary(item) for item in modules[:max_modules]],
            "counts": module_counts,
            "truncated": len(modules) > max_modules,
        },
        "next_tools": {
            "metadata": "python scripts/get_1c_object_metadata.py --kind <Kind> --name <Name> --view effective",
            "read_data": "python scripts/read_1c_object_view.py --kind <Kind> --name <Name> --view effective",
            "form": "python scripts/get_1c_form_context.py --kind <Kind> --name <Name> --form <FormName> --view effective",
            "code_context": "python scripts/get_1c_object_code_context.py --kind <Kind> --name <Name> --view effective",
            "module": "python scripts/get_1c_module.py --kind <Kind> --name <Name> --module <ModuleName> --view effective",
        },
        "counts": {
            "attributes": len(attributes),
            "tabular_sections": len(tabular_sections),
            **form_counts,
            **module_counts,
        },
        "resolution": {
            "schema": resolution.get("schema"),
            "canonical": canonical,
            "summary": resolution.get("summary"),
        },
    }


def main() -> int:
    parser = argparse.ArgumentParser(description="Get compact 1C object context for agents.")
    parser.add_argument("--index", type=Path, required=True)
    parser.add_argument("--kind")
    parser.add_argument("--name")
    parser.add_argument("--kind-b64")
    parser.add_argument("--name-b64")
    parser.add_argument("--view", choices=["effective", "base", "extension"], default="effective")
    parser.add_argument("--extension")
    parser.add_argument("--max-attributes", type=int, default=40)
    parser.add_argument("--max-modules", type=int, default=30)
    parser.add_argument("--max-forms", type=int, default=20)
    parser.add_argument("--output", type=Path)
    args = parser.parse_args()

    kind = decode_arg(args.kind, args.kind_b64)
    name = decode_arg(args.name, args.name_b64)
    if not kind or not name:
        raise SystemExit("Use --kind/--name or --kind-b64/--name-b64.")
    result = build_brief_context(
        load_json(args.index),
        kind=kind,
        name=name,
        view=args.view,
        extension=args.extension,
        max_attributes=args.max_attributes,
        max_modules=args.max_modules,
        max_forms=args.max_forms,
    )
    text = json.dumps(result, ensure_ascii=False, indent=2) + "\n"
    if args.output:
        args.output.parent.mkdir(parents=True, exist_ok=True)
        args.output.write_text(text, encoding="utf-8")
        print(json.dumps({"output": str(args.output), "counts": result["counts"], "view": result["view"]}, ensure_ascii=False))
    else:
        print(text)
    return 0


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