from __future__ import annotations

import argparse
from pathlib import Path

from docx_ops_lib import (
    apply_patch_document,
    create_docx_document,
    export_outline_artifacts,
    index_document,
    query_nodes,
    read_json,
    render_docx,
    write_json,
)
from outline_check import check_outline


def main() -> None:
    parser = argparse.ArgumentParser()
    subparsers = parser.add_subparsers(dest="command", required=True)

    index_parser = subparsers.add_parser("index")
    index_parser.add_argument("--docx", required=True)
    index_parser.add_argument("--out", required=True)

    query_parser = subparsers.add_parser("query")
    query_parser.add_argument("--docx", required=True)
    query_parser.add_argument("--query-file", required=True)
    query_parser.add_argument("--out", required=True)

    create_parser = subparsers.add_parser("create")
    create_parser.add_argument("--spec-file", required=True)
    create_parser.add_argument("--report", required=True)

    check_parser = subparsers.add_parser("outline-check")
    check_parser.add_argument("--outline-file", required=True)
    check_parser.add_argument("--report", required=True)

    export_parser = subparsers.add_parser("outline-export")
    export_parser.add_argument("--spec-file", required=True)
    export_parser.add_argument("--report", required=True)

    patch_parser = subparsers.add_parser("patch")
    patch_parser.add_argument("--patch-file", required=True)
    patch_parser.add_argument("--report", required=True)
    patch_parser.add_argument("--render-check", action="store_true")
    patch_parser.add_argument("--render-dir")

    render_parser = subparsers.add_parser("render")
    render_parser.add_argument("--docx", required=True)
    render_parser.add_argument("--out-dir", required=True)
    render_parser.add_argument("--report")

    args = parser.parse_args()

    if args.command == "index":
        write_json(Path(args.out).resolve(), index_document(Path(args.docx).resolve()))
        return

    if args.command == "query":
        index_data = index_document(Path(args.docx).resolve())
        query_data = read_json(Path(args.query_file).resolve())
        write_json(Path(args.out).resolve(), query_nodes(index_data, query_data))
        return

    if args.command == "create":
        spec_data = read_json(Path(args.spec_file).resolve())
        write_json(Path(args.report).resolve(), create_docx_document(spec_data))
        return

    if args.command == "outline-check":
        outline_data = read_json(Path(args.outline_file).resolve())
        write_json(Path(args.report).resolve(), check_outline(outline_data))
        return

    if args.command == "outline-export":
        export_data = read_json(Path(args.spec_file).resolve())
        write_json(Path(args.report).resolve(), export_outline_artifacts(export_data))
        return

    if args.command == "patch":
        patch_data = read_json(Path(args.patch_file).resolve())
        report = apply_patch_document(patch_data)
        if args.render_check:
            output_docx = Path(report["output_docx"]).resolve()
            render_dir = Path(args.render_dir).resolve() if args.render_dir else output_docx.parent / f"{output_docx.stem}_render"
            report["render"] = render_docx(
                output_docx,
                render_dir,
                docx_style_profile=report.get("docx_style_profile", "default_bid"),
                numbering_mode=report.get("numbering_mode", "explicit_text"),
                document_kind=patch_data.get("document_kind", "assembled"),
            )
        write_json(Path(args.report).resolve(), report)
        return

    report = render_docx(Path(args.docx).resolve(), Path(args.out_dir).resolve())
    if args.report:
        write_json(Path(args.report).resolve(), report)


if __name__ == "__main__":
    main()