#!/usr/bin/env python3
"""CLI: HTML-прототип управляемой формы 1С из Form.xml.

Версия: 0.1.0
Автор: Michael BAG <mk@p7net.ru>

Примеры:
  python3 form_xml_to_html.py -b crm3-26 -o Справочник.Номенклатура -f ФормаЭлемента
  python3 form_xml_to_html.py -c configs/form_prototype.crm3-26.json -f ФормаЭлемента
  python3 form_xml_to_html.py -b crm3-26.rhana -o Общие -f РК_ФормаНастроекРана
"""

from __future__ import annotations

import argparse
import json
import sys
from pathlib import Path

from export1c_help.form_prototype import (
    __author__,
    __email__,
    __version__,
    build_output_path,
    default_search_roots,
    export_form_prototype,
    load_settings_file,
    resolve_form_xml,
)
from export1c_help.resolve import ResolveError


def _build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        prog="form_xml_to_html",
        description=(
            "Собрать HTML-прототип формы 1С по -b/-o/-f "
            f"(v{__version__}, {__author__})"
        ),
    )
    parser.add_argument(
        "-b",
        "--base",
        help="Имя/путь каталога конфигурации (или …/src)",
    )
    parser.add_argument(
        "-o",
        "--object",
        help="Объект: Справочник.Номенклатура | Документ.X | Общие",
    )
    parser.add_argument(
        "-f",
        "--form",
        required=True,
        help="Имя формы (для общих форм — имя общей формы)",
    )
    parser.add_argument(
        "-p",
        "--out-path",
        help=(
            "Каталог вывода: <out>/<конфа>/<тип>/<объект>/<форма>.html "
            "(по умолчанию out/form-prototypes)"
        ),
    )
    parser.add_argument(
        "-c",
        "--config",
        help="JSON с параметрами (base, object, out_path, search_roots), без формы",
    )
    parser.add_argument(
        "--version",
        action="version",
        version=f"form_xml_to_html {__version__} — {__author__} ({__email__})",
    )
    return parser


def _resolve_out_path(raw: str | None, *, config_path: Path | None) -> Path:
    tool_root = Path(__file__).resolve().parent
    if not raw:
        return (tool_root / "out" / "form-prototypes").resolve()
    path = Path(raw).expanduser()
    if path.is_absolute():
        return path.resolve()
    # Относительный путь: от cwd; если запускали с -c — также пробуем от каталога config
    cwd_path = (Path.cwd() / path).resolve()
    if path.parts[0] in (".", "..") or cwd_path.parent.exists():
        return cwd_path
    if config_path is not None:
        return (config_path.parent / path).resolve()
    return (tool_root / path).resolve()


def main(argv: list[str] | None = None) -> int:
    parser = _build_parser()
    args = parser.parse_args(argv)

    settings: dict = {}
    config_path: Path | None = None
    if args.config:
        try:
            settings = load_settings_file(Path(args.config))
            config_path = Path(settings["_config_path"])
        except (ResolveError, OSError, json.JSONDecodeError) as exc:
            print(f"error: {exc}", file=sys.stderr)
            return 2

    base = args.base or settings.get("base")
    object_ref = args.object or settings.get("object")
    out_raw = args.out_path or settings.get("out_path") or settings.get("out")

    if not base:
        parser.error("нужен -b/--base или base в -c/--config")
    if not object_ref:
        parser.error("нужен -o/--object или object в -c/--config")

    search_roots = default_search_roots(config_path)
    extra_roots = settings.get("search_roots") or []
    if isinstance(extra_roots, list):
        base_for_rel = config_path.parent if config_path else Path.cwd()
        for item in extra_roots:
            p = Path(str(item)).expanduser()
            if not p.is_absolute():
                p = (base_for_rel / p).resolve()
            search_roots.insert(0, p)

    try:
        form_xml, _config_root, base_name, type_dir, object_name = resolve_form_xml(
            base=str(base),
            object_ref=str(object_ref),
            form_name=args.form,
            search_roots=search_roots,
        )
        out_root = _resolve_out_path(
            str(out_raw) if out_raw else None, config_path=config_path
        )
        output_html = build_output_path(
            out_root,
            base_name=base_name,
            type_dir=type_dir,
            object_name=object_name,
            form_name=args.form.strip(),
        )
        export_form_prototype(
            form_xml=form_xml,
            output_html=output_html,
            display_title=f"{object_name} · {args.form.strip()}",
        )
    except ResolveError as exc:
        print(f"error: {exc}", file=sys.stderr)
        return 1

    print(f"OK: {output_html}")
    print(f"src: {form_xml}")
    print(f"form_xml_to_html {__version__} — {__author__}")
    return 0


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