Plugins + Scripts HeelAdjust3

"""Migrate old HeelAdjust plugin blobs to HeelAdjustSettingsHost storable.
Replaces plugin paths and creates HeelAdjustSettingsHost atom-level storables
from old plugin data blobs so the new host-based architecture finds its data.
For each atom:
  1. PluginManager path: "CheesyFX.HeelAdjust2.*" or "Nickon7777.HeelAdjust3.*"
     → "Nickon7777.HeelAdjust3.latest:/Custom/Scripts/Nickon/HeelAdjust2/HeelAdjust3.dll"
  2. Person atom: copy the first matching plugin blob → new storable id=HeelAdjustSettingsHost
     (skipped if HeelAdjustSettingsHost already exists)
  3. CoreControl atom: the blob may contain per-person data keyed by atom uid
     under "HeelAdjust" key.  For each uid found, create HeelAdjustSettingsHost
     on the matching Person atom with that person's settings.
Usage:
    python !migrate_heel_adjust.py scene.json [scene2.json ...]
    python !migrate_heel_adjust.py --dir /path/to/scenes
    python !migrate_heel_adjust.py --session scene.json  # remove plugin refs instead of replacing
    python !migrate_heel_adjust.py --restore scene.json  # restore from .bak
    python !migrate_heel_adjust.py --restore --dir /path/to/scenes
"""
import json
import os
import sys
import glob
OLD_PREFIXES = ("CheesyFX.HeelAdjust2.", "CheesyFX.HeelAdjustScene.", "Nickon7777.HeelAdjust3.", "Custom/Scripts/Nickon/HeelAdjust")
NEW_PATH = "Nickon7777.HeelAdjust3.latest:/Custom/Scripts/Nickon/HeelAdjust3/HeelAdjust3.dll"
HOST_ID = "HeelAdjustSettingsHost"

def _is_old_plugin(storable_id):
    s = storable_id or ""
    if not s.startswith("plugin#"):
        return False
    return any(p.rstrip(".") in s for p in OLD_PREFIXES)

def _replace_plugin_paths(storables, session=False):
    changed = False
    for storable in storables:
        if storable.get("id") != "PluginManager":
            continue
        plugins = storable.get("plugins", {})
        for key, value in list(plugins.items()):
            if not isinstance(value, str):
                continue
            for prefix in OLD_PREFIXES:
                if value.startswith(prefix):
                    if session:
                        del plugins[key]
                        print(f"  removed: {key}")
                    else:
                        plugins[key] = NEW_PATH
                        print(f"  path: {key} -> {NEW_PATH}")
                    changed = True
                    break
    return changed

def _find_settings_key(blob):
    if "HeelAdjust" in blob:
        return "HeelAdjust"
    if "HeelAdjust2" in blob:
        return "HeelAdjust2"
    if "HeelAdjust3" in blob:
        return "HeelAdjust3"
    return None

def _has_host(storables):
    return any(s.get("id") == HOST_ID for s in storables)

CLS_SUFFIX = "Custom/Scripts/Nickon/CLS/CLS.cslist"

def _person_has_cls(person):
    for s in person.get("storables", []):
        if s.get("id") != "PluginManager":
            continue
        for path in s.get("plugins", {}).values():
            if isinstance(path, str) and path.endswith(CLS_SUFFIX):
                return True
    return False

def process_file(filepath, data, session=False):
    print(f"\n{filepath}")
    atoms = data.get("atoms", [])
    if not atoms:
        print("  no atoms")
        return False
    persons = {a["id"] for a in atoms if a.get("type") == "Person"}
    changed = False
    for atom in atoms:
        storables = atom.get("storables", [])
        atom_id = atom.get("id", "?")
        atom_type = atom.get("type", "")
        changed |= _replace_plugin_paths(storables, session)
        old_blobs = [s for s in storables if _is_old_plugin(s.get("id", ""))]
        if atom_type == "Person":
            if _has_host(storables) or not old_blobs:
                continue
            blob = old_blobs[0]
            blob["id"] = HOST_ID
            # Rename key to "Preset" which is what Mechanics.RestoreFromJSON reads
            for old_key in ("HeelAdjust", "HeelAdjust2"):
                if old_key in blob:
                    blob["Preset"] = blob.pop(old_key)
            # CLS auto-detection for Person atoms
            ach = blob.get("adjustControllerHeight")
            ha = blob.get("Preset", {})
            if not ach:
                ach = ha.get("adjustControllerHeight") if isinstance(ha, dict) else None
            if ach == "Root" and _person_has_cls(atom):
                # Update in the outer fields (new host format)
                if "adjustControllerHeight" in blob:
                    blob["adjustControllerHeight"] = "CLS"
                elif isinstance(ha, dict) and "adjustControllerHeight" in ha:
                    ha["adjustControllerHeight"] = "CLS"
                print(f"    adjustControllerHeight: Root -> CLS (CLS plugin found on '{atom_id}')")
            changed = True
            print(f"  Person '{atom_id}': created {HOST_ID}")
        elif atom_type == "CoreControl" and old_blobs:
            for blob in old_blobs:
                key = _find_settings_key(blob)
                if key is None or not isinstance(blob[key], dict):
                    continue
                per_person = blob[key]
                # Shared scene-level fields to copy into each person's host
                skip_keys = {"id", "enabled", "pluginLabel", key}
                shared = {k: v for k, v in blob.items() if k not in skip_keys}
                for uid, settings in list(per_person.items()):
                    if uid not in persons:
                        continue
                    person = next((a for a in atoms if a.get("id") == uid), None)
                    if person is None:
                        continue
                    ps = person.get("storables", [])
                    if _has_host(ps):
                        continue
                    host = {"id": HOST_ID, "Preset": settings}
                    host.update(shared)
                    ach = host.get("adjustControllerHeight") or settings.get("adjustControllerHeight")
                    if ach == "Root" and _person_has_cls(person):
                        settings["adjustControllerHeight"] = "CLS"
                        print(f"    adjustControllerHeight: Root -> CLS (CLS plugin found on '{uid}')")
                    ps.append(host)
                    person["storables"] = ps
                    changed = True
                    print(f"  CoreControl '{atom_id}' -> Person '{uid}': created {HOST_ID}")
    if not changed:
        print("  no changes")
        return False
    return True

def write_file(filepath, data):
    backup = filepath + ".bak"
    if os.path.exists(backup):
        print(f"  backup exists, overwriting")
    else:
        os.rename(filepath, backup)
        print(f"  backup: {backup}")
    with open(filepath, "w", encoding="utf-8") as f:
        json.dump(data, f, indent=2, ensure_ascii=False)
    # Touch .bak so its mtime is >= the new .json we just wrote.
    # Without this, --restore's freshness check (json_mtime > bak_mtime)
    # would falsely trigger after a re-migration where .bak predates .json.
    os.utime(backup)

def main():
    if len(sys.argv) < 2:
        print(__doc__.strip())
        sys.exit(1)
    session = "--session" in sys.argv
    restore = "--restore" in sys.argv
    args = [a for a in sys.argv[1:] if a not in ("--session", "--restore")]
    if restore:
        if args and args[0] == "--dir":
            files = sorted(glob.glob(os.path.join(args[1], "*.json.bak")))
        elif args:
            files = [a + ".bak" for a in args if os.path.isfile(a + ".bak")]
        else:
            print("usage: --restore file.json [--dir /path]")
            sys.exit(1)
        for bak in files:
            if not os.path.isfile(bak):
                print(f"  not found: {bak}")
                continue
            original = bak[:-4]
            if os.path.isfile(original):
                bak_mtime = os.path.getmtime(bak)
                json_mtime = os.path.getmtime(original)
                if json_mtime > bak_mtime:
                    rel = os.path.basename(original)
                    ans = input(f"  {rel}: scene was saved after backup was created, restore anyway? [y/n] ").strip().lower()
                    if ans != "y":
                        print(f"  skipped: {original}")
                        continue
            os.replace(bak, original)
            print(f"  restored: {original}")
        return
    if args[0] == "--dir":
        files = sorted(glob.glob(os.path.join(args[1], "*.json")))
        if not files:
            print(f"no .json files in {args[1]}")
            sys.exit(1)
        for f in files:
            with open(f, "r", encoding="utf-8") as fh:
                data = json.load(fh)
            if process_file(f, data, session):
                write_file(f, data)
    else:
        for arg in args:
            if os.path.isfile(arg):
                with open(arg, "r", encoding="utf-8") as fh:
                    data = json.load(fh)
                if process_file(arg, data, session):
                    write_file(arg, data)
            else:
                print(f"not found: {arg}")

if __name__ == "__main__":
    main()