"""Extract a Commercial-Safe edition of the dataset (MP + JARVIS only).

OQMD is non-commercial only, limiting use for commercial ML training.
This script creates a clearly-labeled subset containing only entries with
CC BY 4.0 (MP) and CC0 1.0 (JARVIS) licenses.

Outputs:
  - dataset/commercial_safe_subset_v3.json: ~94,952 entries
  - dataset/manifests/manifest_commercial_safe.json: checksums

Usage:
    python scripts/extract_commercial_safe_edition.py
    python scripts/extract_commercial_safe_edition.py --stats-only
    python scripts/extract_commercial_safe_edition.py --output-dir /tmp
"""
import json, os, sys, hashlib, time, argparse
from pathlib import Path

COMMERCIAL_LICENSES = {"CC-BY-4.0", "CC0-1.0"}
COMMERCIAL_SOURCES = {"mp", "jarvis"}


def main():
    parser = argparse.ArgumentParser(description="Extract Commercial-Safe dataset edition")
    parser.add_argument("--stats-only", action="store_true", help="Print stats only, no output")
    parser.add_argument("--output-dir", type=str, default=None, help="Custom output directory")
    args = parser.parse_args()
    
    BASE_DIR = Path(__file__).resolve().parent.parent
    DATASET_PATH = BASE_DIR / "dataset"
    
    if args.output_dir:
        OUTPUT_DIR = Path(args.output_dir)
    else:
        OUTPUT_DIR = DATASET_PATH
    
    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
    
    print("=" * 60)
    print("  COMMERCIAL-SAFE EDITION EXTRACTION")
    print("  Filtering entries by license: CC-BY-4.0 (MP), CC0-1.0 (JARVIS)")
    print("=" * 60)
    
    print("\nLoading entries...")
    t0 = time.time()
    with open(DATASET_PATH / "entries_final_v3.json") as f:
        all_entries = json.load(f)
    print(f"  {len(all_entries):,} entries ({time.time()-t0:.1f}s)")
    
    # Filter by license
    commercial = []
    oqmd_entries = []
    for e in all_entries:
        lic = e.get("license", "")
        if lic in COMMERCIAL_LICENSES:
            commercial.append(e)
        else:
            oqmd_entries.append(e)
    
    print(f"\n  Commercial-safe: {len(commercial):,} entries")
    print(f"  OQMD (non-commercial): {len(oqmd_entries):,} entries")
    print(f"  Commercial fraction: {len(commercial)/len(all_entries)*100:.1f}%")
    
    # Stats by source
    source_counts = {}
    for e in commercial:
        src = e.get("source", "unknown")
        source_counts[src] = source_counts.get(src, 0) + 1
    
    print(f"\n  Commercial-safe source breakdown:")
    for src, count in sorted(source_counts.items(), key=lambda x: -x[1]):
        print(f"    {src}: {count:,}")
    
    # Stats by tier
    tier_counts = {}
    for e in commercial:
        t = e.get("tier", "unknown")
        tier_counts[t] = tier_counts.get(t, 0) + 1
    
    print(f"\n  Commercial-safe tier breakdown:")
    for t, count in sorted(tier_counts.items(), key=lambda x: -x[1]):
        print(f"    {t}: {count:,}")
    
    # Stats by SSE family
    family_counts = {}
    for e in commercial:
        fam = e.get("sse_family", "unknown")
        family_counts[fam] = family_counts.get(fam, 0) + 1
    
    print(f"\n  Commercial-safe SSE family breakdown:")
    for fam, count in sorted(family_counts.items(), key=lambda x: -x[1])[:15]:
        print(f"    {fam}: {count:,}")
    
    # Stats for OQMD battery/electrolyte entries (what users lose)
    oqmd_battery = sum(1 for e in oqmd_entries if any(f in e.get("families", []) for f in 
                       ["sulfide_sse", "halide_sse", "layered_oxide"]))
    oqmd_electrolyte = sum(1 for e in oqmd_entries if e.get("sse_family") not in ("none", "oxide"))
    
    print(f"\n  OQMD entries lost (not in commercial-safe):")
    print(f"    Battery-relevant families: {oqmd_battery:,}")
    print(f"    SSE-family tagged: {oqmd_electrolyte:,}")
    
    if args.stats_only:
        print(f"\n  (stats only — no file written)")
        return
    
    # Write commercial-safe edition
    output_path = OUTPUT_DIR / "commercial_safe_subset_v3.json"
    print(f"\n  Writing commercial-safe edition ({len(commercial):,} entries)...")
    print(f"    -> {output_path}")
    
    t_write = time.time()
    with open(output_path, "w") as f:
        json.dump(commercial, f)
    print(f"    Done ({time.time()-t_write:.1f}s)")
    
    # Compute SHA256
    sha256 = hashlib.sha256()
    with open(output_path, "rb") as f:
        for chunk in iter(lambda: f.read(8192), b""):
            sha256.update(chunk)
    file_size = output_path.stat().st_size
    
    print(f"    SHA256: {sha256.hexdigest()}")
    print(f"    Size: {file_size/1024/1024:.1f} MB")
    
    # Write manifest
    manifest = {
        "edition": "commercial_safe",
        "description": "MP (CC-BY-4.0) + JARVIS (CC0-1.0) entries only. No OQMD.",
        "total_entries": len(commercial),
        "file": "commercial_safe_subset_v3.json",
        "sha256": sha256.hexdigest(),
        "size_bytes": file_size,
        "sources": {src: count for src, count in source_counts.items()},
        "created": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
    }
    
    manifest_path = OUTPUT_DIR / "manifests" / "manifest_commercial_safe.json"
    manifest_path.parent.mkdir(parents=True, exist_ok=True)
    with open(manifest_path, "w") as f:
        json.dump(manifest, f, indent=2)
    print(f"    Manifest: {manifest_path}")
    
    # Also generate battery and electrolyte subsets from commercial-safe
    battery_edition = [e for e in commercial if any(
        f in e.get("families", []) for f in 
        ["sulfide_sse", "halide_sse", "layered_oxide", "garnet", "nasicon", 
         "perovskite", "anti_perovskite", "lisicon", "lGPS_type", "argyrodite",
         "borohydride", "battery", "oxide"]) or e.get("sse_family") not in ("none",)]
    
    battery_output = OUTPUT_DIR / "commercial_safe_battery_candidate_subset_v1.json"
    print(f"\n  Writing commercial-safe battery edition ({len(battery_edition):,} entries)...")
    with open(battery_output, "w") as f:
        json.dump(battery_edition, f)
    print(f"    -> {battery_output} ({time.time()-t_write:.1f}s)")
    
    print(f"\n  Manual filtering by license field is also supported:")
    print(f'    entries = [e for e in data if e["license"] in ("CC-BY-4.0", "CC0-1.0")]')
    print("=" * 60)


if __name__ == "__main__":
    main()