#!/usr/bin/env python3
import argparse
import json
from datetime import date
from pathlib import Path


ROOT = Path(__file__).resolve().parents[1]


def parse_simple_yaml(path: Path):
    data = {}
    current_key = None
    for raw in path.read_text().splitlines():
        if not raw.strip() or raw.lstrip().startswith("#"):
            continue
        if raw.startswith("  - ") and current_key:
            data.setdefault(current_key, []).append(raw.strip()[2:].strip())
            continue
        if ":" in raw and not raw.startswith(" "):
            key, value = raw.split(":", 1)
            key = key.strip()
            value = value.strip()
            current_key = key
            if value == "":
                data[key] = []
            else:
                data[key] = value.strip('"').strip("'")
    return data


def yaml_scalar(value):
    if isinstance(value, bool):
        return "true" if value else "false"
    if value is None:
        return "null"
    if isinstance(value, (int, float)):
        return str(value)
    text = str(value)
    if text == "":
        return '""'
    if any(ch in text for ch in [":", "#", "{", "}", "[", "]", ",", "\"", "'", "\n"]) or text.startswith(" ") or text.endswith(" "):
        return json.dumps(text, ensure_ascii=False)
    return text


def dump_yaml(mapping, indent=0):
    lines = []
    pad = " " * indent
    for key, value in mapping.items():
        if isinstance(value, dict):
            lines.append(f"{pad}{key}:")
            lines.extend(dump_yaml(value, indent + 2))
        elif isinstance(value, list):
            if not value:
                lines.append(f"{pad}{key}: []")
            else:
                lines.append(f"{pad}{key}:")
                for item in value:
                    if isinstance(item, dict):
                        lines.append(f"{pad}  -")
                        lines.extend(dump_yaml(item, indent + 4))
                    else:
                        lines.append(f"{pad}  - {yaml_scalar(item)}")
        else:
            lines.append(f"{pad}{key}: {yaml_scalar(value)}")
    return lines


def main():
    parser = argparse.ArgumentParser(description="Scaffold a derived convex decomposition asset directory.")
    parser.add_argument("raw_asset_dir", help="Path to a raw asset directory under assets/<source>/raw/...")
    parser.add_argument("--variant", default="vhacd_v1", help="Derived asset variant suffix.")
    parser.add_argument("--tool", default="vhacd", help="Convex decomposition tool name.")
    parser.add_argument("--tool-version", default="TBD", help="Convex decomposition tool version.")
    args = parser.parse_args()

    raw_asset_dir = Path(args.raw_asset_dir).resolve()
    raw_rel = raw_asset_dir.relative_to(ROOT / "assets")
    parts = raw_rel.parts
    if len(parts) < 5 or parts[1] != "raw":
        raise SystemExit("raw_asset_dir must be under assets/<source>/raw/<asset_type>/<category>/<asset_id>")

    source = parts[0]
    asset_type = parts[2]
    category = parts[3]
    asset_id = parts[4]

    raw_meta_path = raw_asset_dir / "metadata.yaml"
    raw_meta = parse_simple_yaml(raw_meta_path) if raw_meta_path.exists() else {}
    license_name = raw_meta.get("license", "unknown")
    origin_url = raw_meta.get("origin_url", "")
    source_commit = raw_meta.get("source_commit")

    derived_asset_id = f"{asset_id}_{args.variant}"
    derived_dir = ROOT / "assets" / source / "derived" / "convex_decompositions" / category / derived_asset_id
    if derived_dir.exists():
        raise SystemExit(f"destination already exists: {derived_dir}")

    (derived_dir / "meshes").mkdir(parents=True, exist_ok=False)
    (derived_dir / "mjcf").mkdir(parents=True, exist_ok=False)
    (derived_dir / "logs").mkdir(parents=True, exist_ok=False)

    metadata = {
        "asset_id": f"{source}.convex_decompositions.{category}.{derived_asset_id}",
        "source": source,
        "source_asset_id": asset_id,
        "asset_type": "convex_decompositions",
        "category": category,
        "format": "obj_mjcf_include",
        "entry_file": "mjcf/convex_collision_include.xml",
        "license": license_name,
        "origin_url": origin_url,
        "path": derived_dir.relative_to(ROOT).as_posix(),
        "storage_mode": "derived",
        "derived_from": [raw_asset_dir.relative_to(ROOT).as_posix()],
        "derivation_method": "convex_decomposition",
        "decomposition_tool": args.tool,
        "decomposition_version": args.tool_version,
        "decomposition_params_file": "logs/decomposition.json",
        "validation_status": "scaffolded",
        "tags": [source, "convex_decomposition", "collision"],
    }
    if source_commit:
        metadata["source_commit"] = source_commit

    if "readiness_level" in raw_meta:
        metadata["readiness_level"] = raw_meta["readiness_level"]

    (derived_dir / "metadata.yaml").write_text("\n".join(dump_yaml(metadata)) + "\n")

    source_refs = {
        "raw_asset": raw_asset_dir.relative_to(ROOT).as_posix(),
        "raw_entry_file": (raw_asset_dir / raw_meta.get("entry_file", "model.xml")).relative_to(ROOT).as_posix(),
    }
    (derived_dir / "source_refs.yaml").write_text("\n".join(dump_yaml(source_refs)) + "\n")

    include_xml = f"""<!-- Scaffolded convex collision include for {raw_asset_dir.relative_to(ROOT).as_posix()} -->
<mujocoinclude>
  <!-- Replace with convex collision geoms generated by {args.tool} -->
</mujocoinclude>
"""
    (derived_dir / "mjcf" / "convex_collision_include.xml").write_text(include_xml)

    logs = {
        "tool": args.tool,
        "tool_version": args.tool_version,
        "created_at": str(date.today()),
        "raw_asset": raw_asset_dir.relative_to(ROOT).as_posix(),
        "derived_asset": derived_dir.relative_to(ROOT).as_posix(),
        "params": {},
        "inputs": [],
        "outputs": [],
    }
    (derived_dir / "logs" / "decomposition.json").write_text(json.dumps(logs, indent=2, ensure_ascii=False) + "\n")

    readme = f"""# Convex decomposition scaffold

Raw asset:

```text
{raw_asset_dir.relative_to(ROOT).as_posix()}
```

Derived asset:

```text
{derived_dir.relative_to(ROOT).as_posix()}
```

This directory is a scaffold only. Populate `meshes/` and replace the include file with real convex collision geometry before registering it in the manifest.
"""
    (derived_dir / "README.md").write_text(readme)

    print(derived_dir.relative_to(ROOT).as_posix())


if __name__ == "__main__":
    main()