#!/usr/bin/env python3
"""
gen-sd.py — Generate images via Stable Diffusion WebUI API (A1111 / Forge / ReForge).

One-shot deterministic call. Replaces 3-5K tokens of step-by-step API planning.

Uses the standard SD WebUI txt2img endpoint (/sdapi/v1/txt2img).
Supports all common samplers, hires fix, controlnet, and more.

Usage:
  python3 gen-sd.py --prompt "masterpiece, 1girl, blue hair, sunset"
  python3 gen-sd.py --prompt "1girl" --steps 20 --cfg 7 --width 512 --height 768
  python3 gen-sd.py --prompt "..." --sampler "DPM++ 2M Karras" --batch 4
  python3 gen-sd.py --prompt "..." --hires --denoising 0.5 --upscale 2
  python3 gen-sd.py --prompts-from-stdin << 'EOF'
  1girl, cat ears
  1boy, sword
  EOF

  # Non-default URL:
  python3 gen-sd.py --prompt "..." --sd-url http://10.0.0.14:7860

  # Via env:
  SD_URL=http://my-pc:7860 python3 gen-sd.py --prompt "..."

Returns JSON to stdout for agent consumption.

Token savings: ~3,000-5,000 tokens per image vs LLM planning it.
"""

import argparse
import base64
import json
import os
import random
import sys
import time
import uuid
from io import BytesIO
from pathlib import Path
from urllib import request as urlreq
from urllib.error import URLError

try:
    from PIL import Image
    HAS_PIL = True
except ImportError:
    HAS_PIL = False

try:
    import requests
    HAS_REQUESTS = True
except ImportError:
    HAS_REQUESTS = False


# ─── Defaults ──────────────────────────────────────
DEFAULT_SD_URL = os.environ.get("SD_URL", "http://127.0.0.1:7860")
DEFAULT_STEPS = 20
DEFAULT_CFG = 7.0
DEFAULT_WIDTH = 512
DEFAULT_HEIGHT = 768
DEFAULT_SAMPLER = "Euler"
DEFAULT_OUTPUT = os.environ.get("SD_OUTPUT_DIR", "./outputs")
TOKENS_PER_IMG = 4000  # Conservative estimate: ~3-5K vs LLM planning

# ─── Common samplers (for reference) ──────────────
SAMPLERS = [
    "Euler", "Euler a", "DPM++ 2M Karras", "DPM++ 2M SDE Karras",
    "DPM++ SDE Karras", "DPM++ 2M", "DPM++ 2S a", "DPM++ 2M SDE",
    "DPM++ 3M SDE", "DPM++ 3M SDE Karras", "DDIM", "PLMS",
    "UniPC", "LCM", "TCD"
]


# ─── SD WebUI API Client ───────────────────────────

def check_sd_healthy(sd_url, timeout=5):
    """Quick health check — does the SD WebUI respond?"""
    try:
        if HAS_REQUESTS:
            r = requests.get(f"{sd_url}/sdapi/v1/options", timeout=timeout)
            return r.ok
        else:
            req = urlreq.Request(f"{sd_url}/sdapi/v1/options")
            with urlreq.urlopen(req, timeout=timeout) as resp:
                return True
    except Exception:
        return False


def txt2img(prompt, negative, steps, cfg, width, height, sampler, seed, batch_size, sd_url, hires=False, denoising=0.5, upscale=1):
    """Call SD WebUI txt2img endpoint."""
    payload = {
        "prompt": prompt,
        "negative_prompt": negative,
        "steps": steps,
        "cfg_scale": cfg,
        "width": width,
        "height": height,
        "sampler_name": sampler,
        "seed": seed if seed else -1,
        "batch_size": batch_size,
        "save_images": False,
        "send_images": True,
    }

    if hires:
        payload["enable_hr"] = True
        payload["denoising_strength"] = denoising
        payload["hr_scale"] = upscale
        payload["hr_upscaler"] = "R-ESRGAN 4x+"

    if HAS_REQUESTS:
        r = requests.post(f"{sd_url}/sdapi/v1/txt2img", json=payload, timeout=600)
        r.raise_for_status()
        return r.json()
    else:
        body = json.dumps(payload).encode("utf-8")
        req = urlreq.Request(
            f"{sd_url}/sdapi/v1/txt2img",
            data=body,
            headers={"Content-Type": "application/json"},
            method="POST",
        )
        with urlreq.urlopen(req, timeout=600) as resp:
            return json.loads(resp.read())


def decode_and_save(b64_str, output_dir, prefix, index, seed):
    """Decode a base64 image and save to disk."""
    img_data = base64.b64decode(b64_str)
    fname = f"{prefix}_{index}_{uuid.uuid4().hex[:8]}.png"
    fpath = Path(output_dir) / fname
    with open(fpath, "wb") as f:
        f.write(img_data)
    return str(fpath.resolve())


# ─── CLI ───────────────────────────────────────────

def parse_args():
    parser = argparse.ArgumentParser(
        description="Generate images via SD WebUI API — saves 3K-5K tokens per image vs LLM planning.",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  python3 gen-sd.py --prompt "masterpiece, 1girl" --steps 20
  python3 gen-sd.py --prompt "fantasy landscape, mountains" --width 768 --height 768 --sampler "DPM++ 2M Karras"
  python3 gen-sd.py --prompt "landscape" --hires --upscale 2
  python3 gen-sd.py --prompts-from-stdin --batch 2
        """,
    )
    parser.add_argument("--prompt", type=str, help="Text prompt (Danbooru tags or natural language)")
    parser.add_argument("--negative", "--neg", type=str, default="", help="Negative prompt")
    parser.add_argument("--steps", type=int, default=DEFAULT_STEPS, help=f"Sampling steps (default: {DEFAULT_STEPS})")
    parser.add_argument("--cfg", "--cfg-scale", type=float, default=DEFAULT_CFG, help=f"CFG scale (default: {DEFAULT_CFG})")
    parser.add_argument("--width", "-w", type=int, default=DEFAULT_WIDTH, help=f"Image width (default: {DEFAULT_WIDTH})")
    parser.add_argument("--height", type=int, default=DEFAULT_HEIGHT, help=f"Image height (default: {DEFAULT_HEIGHT})")
    parser.add_argument("--sampler", type=str, default=DEFAULT_SAMPLER, help=f"Sampler name (default: {DEFAULT_SAMPLER})")
    parser.add_argument("--batch", "--count", type=int, default=1, help="Number of images (default: 1)")
    parser.add_argument("--seed", type=int, help="Random seed (-1 for random)")
    parser.add_argument("--sd-url", type=str, default=DEFAULT_SD_URL, help="SD WebUI URL (default: $SD_URL or http://127.0.0.1:7860)")
    parser.add_argument("--output-dir", type=str, default=DEFAULT_OUTPUT, help="Output directory")
    parser.add_argument("--prefix", type=str, default="sd", help="Output filename prefix")
    parser.add_argument("--hires", action="store_true", help="Enable hires fix")
    parser.add_argument("--denoising", type=float, default=0.5, help="Hires denoising strength (0-1, default: 0.5)")
    parser.add_argument("--upscale", type=float, default=2, help="Hires upscale factor (default: 2)")
    parser.add_argument("--prompts-from-stdin", action="store_true", help="Read prompts from stdin, one per line")
    return parser.parse_args()


# ─── Main ──────────────────────────────────────────

def main():
    args = parse_args()

    # Collect prompts
    prompts = []
    if args.prompts_from_stdin:
        if sys.stdin.isatty():
            parser.error("--prompts-from-stdin requires piped input, not a TTY")
        prompts = [line.strip() for line in sys.stdin if line.strip()]
    else:
        if not args.prompt:
            print("ERROR: Either --prompt or --prompts-from-stdin is required", file=sys.stderr)
            sys.exit(1)
        prompts = [args.prompt] * args.batch

    # Ensure output dir
    out_dir = Path(args.output_dir)
    out_dir.mkdir(parents=True, exist_ok=True)

    # ── Check SD WebUI is reachable ─────────────────────────────────
    sd_url = args.sd_url
    if not check_sd_healthy(sd_url):
        print(f"⚠️  SD WebUI ({sd_url}) not responding, trying fallback...", file=sys.stderr)
        fallback = os.environ.get("SD_FALLBACK_URL", "")
        if fallback and check_sd_healthy(fallback):
            sd_url = fallback
            print(f"✅ Connected via fallback: {sd_url}", file=sys.stderr)
        else:
            print(f"❌ SD WebUI not reachable at {sd_url}", file=sys.stderr)
            print(f"   Set SD_URL env var or use --sd-url", file=sys.stderr)
            print(f"   Make sure the WebUI is running with --api flag", file=sys.stderr)
            print(json.dumps({
                "success": False,
                "total_images": 0,
                "total_attempted": len(prompts),
                "total_tokens_saved": 0,
                "results": [],
                "error": f"SD WebUI not reachable at {sd_url}",
                "note": "Set SD_URL env var or use --sd-url. WebUI must be running with --api.",
            }, indent=2))
            sys.exit(1)

    # ── Generate ────────────────────────────────────────────────────
    results = []
    total_tokens = 0
    seed = args.seed if args.seed else -1

    for i, prompt in enumerate(prompts):
        actual_seed = seed if seed >= 0 else random.randint(0, 2**32 - 1)

        print(f"[{i+1}/{len(prompts)}] Generating...", file=sys.stderr)

        try:
            data = txt2img(
                prompt=prompt,
                negative=args.negative,
                steps=args.steps,
                cfg=args.cfg,
                width=args.width,
                height=args.height,
                sampler=args.sampler,
                seed=actual_seed,
                batch_size=args.batch,
                sd_url=sd_url,
                hires=args.hires,
                denoising=args.denoising,
                upscale=args.upscale,
            )

            images = data.get("images", [])
            saved = []

            for j, b64_str in enumerate(images):
                fpath = decode_and_save(b64_str, out_dir, args.prefix, i * args.batch + j + 1, actual_seed)
                saved.append(fpath)

            info = json.loads(data.get("info", "{}"))
            actual_seed = info.get("seed", actual_seed)

            tokens_saved = TOKENS_PER_IMG
            total_tokens += tokens_saved

            results.append({
                "success": True,
                "files": saved,
                "seed": actual_seed,
                "tokens_saved": tokens_saved,
                "prompt": prompt[:200],
                "info": info.get("infotexts", [""])[0] if info.get("infotexts") else "",
            })

            print(f"[{i+1}/{len(prompts)}] ✅ {len(saved)} image(s) saved", file=sys.stderr)

        except Exception as e:
            results.append({
                "success": False,
                "error": str(e),
                "prompt": prompt[:200],
            })
            print(f"[{i+1}/{len(prompts)}] ❌ Error: {e}", file=sys.stderr)

    # ── Output ──────────────────────────────────────────────────────
    total_generated = sum(1 for r in results if r.get("success"))
    output = {
        "success": total_generated > 0,
        "total_images": total_generated,
        "total_attempted": len(prompts),
        "total_tokens_saved": total_tokens,
        "results": results,
        "note": f"Generated {total_generated}/{len(prompts)} images. "
                f"Saved ~{total_tokens} tokens vs LLM planning each step.",
    }

    print(json.dumps(output, indent=2))


if __name__ == "__main__":
    main()
