"""
neural-vault CLI. Dependency-free except `mount` (needs WinFsp + winfspy).

  store  <vault> <src_folder> [--k K --m M]   ingest a folder (dedup + RS)
  ls     <vault>                              list stored files
  stat   <vault>                              dedup / redundancy stats
  export <vault> <dst_folder>                 reconstruct all files (RS-healed)
  heal   <vault>                              regenerate any missing shards
  mount  <vault> <mountpoint>                 expose as a drive (WinFsp)

  image         <device> <out.pt> [--k --m --part-mb]   scan a whole drive/partition
                (e.g. \\\\.\\C: or an .img, may need admin) into a self-healing .pt
  image-verify  <out.pt>                      report archive health
  image-heal    <out.pt>                      repair detected bit-rot
  image-restore <out.pt> <out.img>            reconstruct the image bit-exact
"""
import argparse
from storage.vault import Vault
from storage.vaultfs import winfsp_available
from storage import diskimage


def main():
    ap = argparse.ArgumentParser(prog="neural-vault")
    sub = ap.add_subparsers(dest="cmd", required=True)
    p = sub.add_parser("store"); p.add_argument("vault"); p.add_argument("src")
    p.add_argument("--k", type=int, default=4); p.add_argument("--m", type=int, default=2)
    for name in ("ls", "stat", "heal"):
        q = sub.add_parser(name); q.add_argument("vault")
    e = sub.add_parser("export"); e.add_argument("vault"); e.add_argument("dst")
    mo = sub.add_parser("mount"); mo.add_argument("vault"); mo.add_argument("mountpoint")
    im = sub.add_parser("image"); im.add_argument("device"); im.add_argument("out")
    im.add_argument("--k", type=int, default=4); im.add_argument("--m", type=int, default=2)
    im.add_argument("--part-mb", type=int, default=64); im.add_argument("--label")
    iv = sub.add_parser("image-verify"); iv.add_argument("out")
    ih = sub.add_parser("image-heal"); ih.add_argument("out")
    ir = sub.add_parser("image-restore"); ir.add_argument("out"); ir.add_argument("dst")
    args = ap.parse_args()

    if args.cmd == "store":
        v = Vault(args.vault, args.k, args.m)
        v.store_folder(args.src)
        s = v.stats()
        print(f"stored {len(v.list_files())} files, {s['unique_chunks']} unique chunks, "
              f"{s['stored']//1024} KB on disk ({s['overhead']:.2f}x, RS {args.k}+{args.m})")
    elif args.cmd == "ls":
        for rel, sz in Vault(args.vault).list_files():
            print(f"{sz:>10}  {rel}")
    elif args.cmd == "stat":
        s = Vault(args.vault).stats()
        print(f"logical {s['logical']//1024} KB | stored {s['stored']//1024} KB | "
              f"{s['unique_chunks']} chunks | overhead {s['overhead']:.2f}x")
    elif args.cmd == "heal":
        print(f"regenerated {Vault(args.vault).heal()} missing shard(s)")
    elif args.cmd == "export":
        print(f"exported {Vault(args.vault).export(args.dst)} files")
    elif args.cmd == "mount":
        if not winfsp_available():
            print("WinFsp/winfspy not installed. Install WinFsp (https://winfsp.dev) "
                  "and `pip install winfspy`, or use `export` for now.")
            return
        from storage.vaultfs import mount
        fs = mount(Vault(args.vault), args.mountpoint)
        print(f"mounted vault at {args.mountpoint} (Ctrl+C to unmount)")
        try:
            import time
            while True:
                time.sleep(1)
        except KeyboardInterrupt:
            fs.stop()
            print("unmounted")
    elif args.cmd == "image":
        r = diskimage.create(args.device, args.out, k=args.k, m=args.m,
                             part_mb=args.part_mb, label=args.label)
        red = (args.k + args.m) / args.k
        print(f"imaged {r['bytes']//1024} KB -> {r['out']} ({r['mode']}, {r['parts']} part(s), "
              f"RS {args.k}+{args.m} ~{red:.2f}x). bad sectors: {r['bad_sectors']}")
        if r["bad_sectors"]:
            print(f"  WARNING: {r['bad_sectors']} sectors unreadable at scan (zero-filled).")
    elif args.cmd == "image-verify":
        h = diskimage.verify(args.out)
        print(f"health: {'HEALTHY' if h['healthy'] else 'DAMAGED'}  "
              f"chunks={h['chunks']} corrupted_shards={h['corrupted_shards']} "
              f"repairable={h['repairable_chunks']} lost={h['lost_chunks']}")
    elif args.cmd == "image-heal":
        print(f"repaired {diskimage.heal(args.out)} shard(s)")
    elif args.cmd == "image-restore":
        n = diskimage.restore(args.out, args.dst)
        print(f"restored {n//1024} KB -> {args.dst}")


if __name__ == "__main__":
    main()