#!/usr/bin/env python3
"""
Build precompiled Processing.o, Processing_defaults.o, and Processing.h.gch
for the current platform into cache/<platform>/.

Run this on each target platform before creating a release.
The CI workflow (build-cache.yml) runs this on Linux, Windows, and macOS runners.

Flags used are conservative (no -march=native) so the .o files work on any
x86-64 machine, not just the build machine.
"""
import os, sys, subprocess, platform, shutil
from pathlib import Path

root    = Path(__file__).parent.parent
src     = root / "src"
procH   = src / "Processing.h"
procCpp = src / "Processing.cpp"
defCpp  = src / "Processing_defaults.cpp"

def platform_subdir():
    s = platform.system().lower()
    m = platform.machine().lower()
    if s == "windows":   return "windows-x64"
    if s == "darwin":
        return "macos-arm64" if ("arm" in m or "aarch64" in m) else "macos-x64"
    return "linux-x64"

def find_gpp():
    # Windows: check portable gcc first, then MSYS2
    if platform.system() == "Windows":
        appdata = os.environ.get("APPDATA", "")
        portable = Path(appdata) / "CppMode/gcc/mingw64/bin/g++.exe"
        if portable.exists(): return str(portable)
        for p in [r"C:\msys64\mingw64\bin\g++.exe",
                  r"C:\msys2\mingw64\bin\g++.exe"]:
            if Path(p).exists(): return p
    return "g++"

def run(cmd, desc):
    print(f"  {desc}...")
    r = subprocess.run(cmd, capture_output=True, text=True)
    if r.returncode != 0:
        print(f"  FAILED: {r.stderr[:500]}")
        sys.exit(1)
    print(f"  OK")

subdir   = platform_subdir()
cacheDir = root / "cache" / subdir
cacheDir.mkdir(parents=True, exist_ok=True)

gpp = find_gpp()
print(f"Platform: {subdir}")
print(f"Compiler: {gpp}")
print(f"Cache:    {cacheDir}")

isMac = platform.system() == "Darwin"
isWin = platform.system() == "Windows"

# Conservative flags -- no -march=native, target baseline x86-64
baseFlags = [gpp, "-std=c++2c", "-O2", "-x86-64" if not isMac else ""]
baseFlags = [f for f in baseFlags if f]  # remove empty

includeFlags = ["-I", str(src)]
if isMac:
    for prefix in ["/opt/homebrew", "/usr/local"]:
        if Path(prefix + "/include").exists():
            includeFlags += ["-I", prefix + "/include"]
            break

defines = ["-DPROCESSING_HAS_STB_IMAGE", "-DPROCESSING_HAS_STB_TRUETYPE"]

# 1. Build Processing.h.gch
pchOut = cacheDir / "Processing.h.gch"
print(f"\nBuilding PCH...")
run([gpp, "-std=c++2c", "-O2",
     "-x", "c++-header",
     *includeFlags, *defines,
     str(procH), "-o", str(pchOut)],
    f"Processing.h → {pchOut.name}")

# 2. Build Processing.o
procO = cacheDir / "Processing.o"
print(f"\nBuilding Processing.o...")
run([gpp, "-std=c++2c", "-O2",
     *includeFlags, *defines,
     "-c", str(procCpp), "-o", str(procO)],
    f"Processing.cpp → {procO.name}")

# 3. Build Processing_defaults.o
defO = cacheDir / "Processing_defaults.o"
if defCpp.exists():
    print(f"\nBuilding Processing_defaults.o...")
    run([gpp, "-std=c++2c", "-O2",
         *includeFlags, *defines,
         "-c", str(defCpp), "-o", str(defO)],
        f"Processing_defaults.cpp → {defO.name}")

print(f"\nDone. Cache files in {cacheDir}:")
for f in sorted(cacheDir.iterdir()):
    print(f"  {f.name}  ({f.stat().st_size // 1024} KB)")