#!/usr/bin/env python3
"""
gen.py — Generate images via ComfyUI API.

A token-saving script. Instead of the LLM spending 3-5K tokens planning
an image generation step-by-step, this does it in ONE deterministic call.

Usage:
  # Basic
  python3 gen.py --prompt "masterpiece, 1girl, blue hair, sitting" --count 1

  # Full config
  python3 gen.py --prompt "masterpiece, 1girl, cat ears, sitting" \\
    --negative "bad anatomy, ugly" \\
    --steps 70 --cfg 7.5 --width 1024 --height 1024 \\
    --sampler dpmpp_2m_sse --scheduler karras \\
    --model "animeModel.safetensors" \\
    --comfy-url http://10.0.0.14:8188 \\
    --output-dir ./outputs --prefix mygen --count 4

  # From stdin (one prompt per line)
  python3 gen.py --prompts-from-stdin << 'EOF'
  1girl, cat ears, sitting
  1boy, holding a sword, forest background
  EOF

Returns JSON to stdout for agent consumption.

Environment:
  COMFY_URL       — ComfyUI server URL (default: http://127.0.0.1:8188)
  COMFY_MODEL     — Default model name
  COMFY_OUTPUT_DIR — Default output directory (default: ./outputs)

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

import argparse
import json
import os
import random
import re
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

# ─── Auto-load .env from script dir or Hermes profiles ─────
_env_loaded = False
_env_candidates = [
    Path(__file__).parent / ".env",           # script directory
    Path(__file__).parent.parent / ".env",    # parent directory
    Path.home() / ".hermes" / ".env",
]
_hermes_profiles = Path.home() / ".hermes" / "profiles"
if _hermes_profiles.is_dir():
    try:
        for _prof in sorted(_hermes_profiles.iterdir()):
            if _prof.is_dir():
                _env_candidates.append(_prof / ".env")
    except OSError:
        pass
for _env_path in _env_candidates:
    if _env_path.exists():
        try:
            for _line in _env_path.read_text().splitlines():
                _line = _line.strip()
                if _line and not _line.startswith("#") and "=" in _line:
                    _k, _v = _line.split("=", 1)
                    _k, _v = _k.strip(), _v.strip().strip("'").strip('"')
                    if _k not in os.environ:  # don't override existing env
                        os.environ[_k] = _v
            _env_loaded = True
        except Exception:
            pass

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_COMFY_URL = os.environ.get("COMFY_URL", "http://127.0.0.1:8188")
FALLBACK_COMFY_URL = os.environ.get("COMFY_FALLBACK_URL", "http://localhost:8188")
DEFAULT_MODEL = os.environ.get("COMFY_MODEL", "animeModel.safetensors")
DEFAULT_OUTPUT = os.environ.get("COMFY_OUTPUT_DIR", "./outputs")
DEFAULT_STEPS = 30
DEFAULT_CFG = 7.0
DEFAULT_WIDTH = 1024
DEFAULT_HEIGHT = 1024
DEFAULT_SAMPLER = "euler"
DEFAULT_SCHEDULER = "normal"
TOKENS_PER_IMG = 4000  # Conservative estimate: ~3-5K vs LLM planning


# ─── ComfyUI API Client ────────────────────────────

def queue_prompt(prompt_workflow, client_id, comfy_url):
    """Queue a prompt on ComfyUI and return the prompt_id."""
    data = {
        "prompt": prompt_workflow,
        "client_id": client_id,
    }
    if HAS_REQUESTS:
        r = requests.post(f"{comfy_url}/prompt", json=data, timeout=60)
        r.raise_for_status()
        return r.json()["prompt_id"]
    else:
        body = json.dumps(data).encode("utf-8")
        req = urlreq.Request(
            f"{comfy_url}/prompt",
            data=body,
            headers={"Content-Type": "application/json"},
            method="POST",
        )
        with urlreq.urlopen(req, timeout=60) as resp:
            return json.loads(resp.read())["prompt_id"]


def get_history(prompt_id, comfy_url):
    """Fetch generation history for a prompt_id."""
    if HAS_REQUESTS:
        r = requests.get(f"{comfy_url}/history/{prompt_id}", timeout=30)
        r.raise_for_status()
        return r.json()
    else:
        req = urlreq.Request(f"{comfy_url}/history/{prompt_id}")
        with urlreq.urlopen(req, timeout=30) as resp:
            return json.loads(resp.read())


def wait_for_completion(prompt_id, comfy_url, timeout=300):
    """Poll until the prompt is done. Returns history on success, None on timeout."""
    start = time.time()
    while time.time() - start < timeout:
        try:
            history = get_history(prompt_id, comfy_url)
            if prompt_id in history:
                return history[prompt_id]
        except (URLError, json.JSONDecodeError, ConnectionError):
            pass
        time.sleep(1)
    return None


def get_image(filename, subfolder, folder_type, comfy_url):
    """Download a generated image from ComfyUI's output."""
    params = f"filename={filename}&subfolder={subfolder}&type={folder_type}"
    if HAS_REQUESTS:
        r = requests.get(f"{comfy_url}/view?{params}", timeout=30)
        r.raise_for_status()
        return r.content
    else:
        req = urlreq.Request(f"{comfy_url}/view?{params}")
        with urlreq.urlopen(req, timeout=30) as resp:
            return resp.read()


# ─── Workflow Builder ──────────────────────────────

def build_workflow(prompt, negative, model, steps, cfg, width, height, sampler, scheduler, seed):
    """Build a basic txt2img ComfyUI workflow."""
    # Use a simple integer-based node ID system (ComfyUI standard)
    seed = seed or random.randint(0, 2**32 - 1)

    workflow = {
        "3": {
            "class_type": "KSampler",
            "inputs": {
                "seed": seed,
                "steps": steps,
                "cfg": cfg,
                "sampler_name": sampler,
                "scheduler": scheduler,
                "denoise": 1.0,
                "model": ["4", 0],
                "positive": ["6", 0],
                "negative": ["7", 0],
                "latent_image": ["5", 0],
            },
        },
        "4": {
            "class_type": "CheckpointLoaderSimple",
            "inputs": {"ckpt_name": model},
        },
        "5": {
            "class_type": "EmptyLatentImage",
            "inputs": {"width": width, "height": height, "batch_size": 1},
        },
        "6": {
            "class_type": "CLIPTextEncode",
            "inputs": {"text": prompt, "clip": ["4", 1]},
        },
        "7": {
            "class_type": "CLIPTextEncode",
            "inputs": {"text": negative, "clip": ["4", 1]},
        },
        "8": {
            "class_type": "VAEDecode",
            "inputs": {"samples": ["3", 0], "vae": ["4", 2]},
        },
        "9": {
            "class_type": "SaveImage",
            "inputs": {"filename_prefix": "gen_script", "images": ["8", 0]},
        },
    }
    return workflow


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

def parse_args():
    parser = argparse.ArgumentParser(
        description="Generate images via ComfyUI API — saves 3K-5K tokens per image vs LLM planning.",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  python3 gen.py --prompt "1girl, blue hair, masterpiece" --count 4
  python3 gen.py --prompt "kitchen, warm lighting" --steps 50 --cfg 12
  python3 gen.py --prompts-from-stdin --comfy-url http://192.168.1.100:8188

Returns JSON to stdout. Handles errors gracefully.
"""
    )
    parser.add_argument("--prompt", type=str, help="Positive prompt (danbooru style tags)")
    parser.add_argument("--negative", type=str,
        default="lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, "
                "cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, "
                "username, blurry, ugly, deformed",
        help="Negative prompt")
    parser.add_argument("--model", type=str, default=DEFAULT_MODEL, help="Checkpoint model name")
    parser.add_argument("--steps", type=int, default=DEFAULT_STEPS, help="Sampling steps")
    parser.add_argument("--cfg", type=float, default=DEFAULT_CFG, help="CFG scale")
    parser.add_argument("--width", type=int, default=DEFAULT_WIDTH, help="Image width")
    parser.add_argument("--height", type=int, default=DEFAULT_HEIGHT, help="Image height")
    parser.add_argument("--sampler", type=str, default=DEFAULT_SAMPLER, help="Sampler name")
    parser.add_argument("--scheduler", type=str, default=DEFAULT_SCHEDULER, help="Scheduler name")
    parser.add_argument("--count", type=int, default=1, help="Number of images to generate")
    parser.add_argument("--comfy-url", type=str, default=DEFAULT_COMFY_URL, help="ComfyUI server URL")
    parser.add_argument("--output-dir", type=str, default=DEFAULT_OUTPUT, help="Output directory")
    parser.add_argument("--prefix", type=str, default="gen", help="Output filename prefix")
    parser.add_argument("--seed", type=int, help="Random seed (random if not set)")
    parser.add_argument("--jpeg", action="store_true",
        help="Convert output PNG to JPEG (much smaller files)")
    parser.add_argument("--jpeg-quality", type=int, default=92,
        help="JPEG quality 1-100 (default: 92)")
    parser.add_argument("--prompts-from-stdin", action="store_true",
        help="Read prompts from stdin, one per line")

    args = parser.parse_args()

    if not args.prompt and not args.prompts_from_stdin:
        parser.error("Either --prompt or --prompts-from-stdin is required")
    if args.prompts_from_stdin:
        if sys.stdin.isatty():
            parser.error("--prompts-from-stdin requires piped input, not a TTY")

    return args


def main():
    args = parse_args()

    # Collect prompts
    prompts = []
    if args.prompts_from_stdin:
        prompts = [line.strip() for line in sys.stdin if line.strip()]
    else:
        prompts = [args.prompt] * args.count

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

    # ── Auto-detect ComfyUI connection ─────────────────────────────────────
    comfy_url = args.comfy_url
    try:
        req = urlreq.Request(f"{comfy_url}/system_stats")
        urlreq.urlopen(req, timeout=5)
    except Exception:
        print(f"⚠️ Primary ComfyUI ({comfy_url}) not responding, trying fallback...", file=sys.stderr)
        try:
            req = urlreq.Request(f"{FALLBACK_COMFY_URL}/system_stats")
            urlreq.urlopen(req, timeout=5)
            comfy_url = FALLBACK_COMFY_URL
            print(f"✅ Connected via fallback: {comfy_url}", file=sys.stderr)
        except Exception:
            print(f"❌ ComfyUI not reachable at primary or fallback URL", file=sys.stderr)
            print(f"   Set COMFY_URL env or use --comfy-url to specify", file=sys.stderr)

    client_id = str(uuid.uuid4())
    results = []
    total_tokens = 0

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

        workflow = build_workflow(
            prompt=prompt,
            negative=args.negative,
            model=args.model,
            steps=args.steps,
            cfg=args.cfg,
            width=args.width,
            height=args.height,
            sampler=args.sampler,
            scheduler=args.scheduler,
            seed=seed,
        )

        try:
            # Queue
            prompt_id = queue_prompt(workflow, client_id, comfy_url)
            print(f"[{i+1}/{len(prompts)}] Queued: {prompt_id}", file=sys.stderr)

            # Wait
            history = wait_for_completion(prompt_id, comfy_url)
            if not history:
                results.append({
                    "success": False,
                    "error": f"Timeout waiting for generation (prompt: {prompt[:60]}...)",
                    "prompt": prompt[:200],
                })
                continue

            # Collect outputs
            outputs = history.get("outputs", {})
            image_paths = []
            for node_id, node_output in outputs.items():
                for output_type in node_output.get("images", []):
                    img_data = get_image(
                        output_type["filename"],
                        output_type.get("subfolder", ""),
                        output_type.get("type", "output"),
                        comfy_url,
                    )
                    if img_data:
                        ext = os.path.splitext(output_type["filename"])[1] or ".png"
                        fname = f"{args.prefix}_{i+1}_{uuid.uuid4().hex[:8]}{ext}"
                        fpath = out_dir / fname
                        with open(fpath, "wb") as f:
                            f.write(img_data)

                        # ── JPEG conversion (if requested) ─────────────
                        if args.jpeg and HAS_PIL:
                            try:
                                pil_img = Image.open(fpath).convert("RGB")
                                jpg_path = fpath.with_suffix(".jpg")
                                pil_img.save(jpg_path, "JPEG", quality=args.jpeg_quality, optimize=True)
                                orig_kb = fpath.stat().st_size // 1024
                                new_kb = jpg_path.stat().st_size // 1024
                                print(f"   JPEG: {orig_kb}KB → {new_kb}KB ({100 - (new_kb*100//orig_kb)}% smaller)", file=sys.stderr)
                                image_paths.append(str(jpg_path.resolve()))
                            except Exception as e:
                                print(f"   ⚠️ JPEG conversion failed: {e}", file=sys.stderr)
                                image_paths.append(str(fpath.resolve()))
                        else:
                            image_paths.append(str(fpath.resolve()))

            tokens_saved = TOKENS_PER_IMG
            total_tokens += tokens_saved

            results.append({
                "success": True,
                "files": image_paths,
                "seed": seed,
                "tokens_saved": tokens_saved,
                "prompt": prompt[:200],
                "model_used": args.model,
            })

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

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

    # Final 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()
