Draw Ui

#!/usr/bin/env bash
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
VENV_DIR="${DRAW_VENV:-$HOME/.cache/draw/venv}"
PYTHON_BIN="${DRAW_PYTHON:-$VENV_DIR/bin/python3}"

if [[ ! -x "$PYTHON_BIN" ]]; then
  mkdir -p "$VENV_DIR"
  python3 -m venv "$VENV_DIR"
fi

if ! "$PYTHON_BIN" -c "import google.genai, PIL" >/dev/null 2>&1; then
  PIP_DISABLE_PIP_VERSION_CHECK=1 "$PYTHON_BIN" -m pip install --quiet --upgrade pip google-genai pillow
fi

# --frame <path>: prepend a frame reference image before all other --ref args.
# Usage: ask_draw.sh --frame /path/to/frame.png [other args...]
# This injects --ref <frame> at the front so the frame is always ref[0].
FRAME_PATH=""
REMAINING_ARGS=()
while [[ $# -gt 0 ]]; do
  case "$1" in
    --frame)
      FRAME_PATH="$2"
      shift 2
      ;;
    *)
      REMAINING_ARGS+=("$1")
      shift
      ;;
  esac
done

if [[ -n "$FRAME_PATH" ]]; then
  exec "$PYTHON_BIN" "$SCRIPT_DIR/generate_image.py" --ref "$FRAME_PATH" "${REMAINING_ARGS[@]}"
else
  exec "$PYTHON_BIN" "$SCRIPT_DIR/generate_image.py" "${REMAINING_ARGS[@]}"
fi

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import json
import math
from pathlib import Path

from PIL import Image, ImageChops, ImageEnhance, ImageStat


def load_rgb(path: Path) -> Image.Image:
    return Image.open(path).convert("RGB")


def fit_to_reference(candidate: Image.Image, reference: Image.Image) -> Image.Image:
    if candidate.size == reference.size:
        return candidate
    return candidate.resize(reference.size, Image.Resampling.LANCZOS)


def rms(diff: Image.Image) -> float:
    stat = ImageStat.Stat(diff)
    return math.sqrt(sum(value * value for value in stat.rms) / len(stat.rms))


def mean_abs(diff: Image.Image) -> float:
    stat = ImageStat.Stat(diff)
    return sum(stat.mean) / len(stat.mean)


def make_heatmap(diff: Image.Image) -> Image.Image:
    gray = diff.convert("L")
    boosted = ImageEnhance.Contrast(gray).enhance(2.2)
    boosted = ImageEnhance.Brightness(boosted).enhance(1.5)
    heat = Image.new("RGB", diff.size, (255, 255, 255))
    red = Image.new("RGB", diff.size, (255, 55, 55))
    heat.paste(red, mask=boosted)
    return heat


def main() -> int:
    parser = argparse.ArgumentParser(description="Compare a browser screenshot against a reference UI mockup.")
    parser.add_argument("--reference", type=Path, required=True)
    parser.add_argument("--candidate", type=Path, required=True)
    parser.add_argument("--out-dir", type=Path, required=True)
    parser.add_argument("--prefix", default="comparison")
    parser.add_argument(
        "--clip",
        action="append",
        default=[],
        help="Named crop to compare, format name:x,y,w,h in reference coordinates. Repeatable.",
    )
    args = parser.parse_args()

    reference = load_rgb(args.reference)
    candidate = fit_to_reference(load_rgb(args.candidate), reference)

    args.out_dir.mkdir(parents=True, exist_ok=True)

    def compare_region(name: str, ref_img: Image.Image, cand_img: Image.Image) -> dict:
        diff = ImageChops.difference(ref_img, cand_img)
        normalized_candidate = args.out_dir / f"{args.prefix}-{name}-candidate.png"
        diff_path = args.out_dir / f"{args.prefix}-{name}-diff.png"
        heatmap_path = args.out_dir / f"{args.prefix}-{name}-heatmap.png"
        cand_img.save(normalized_candidate)
        diff.save(diff_path)
        make_heatmap(diff).save(heatmap_path)
        return {
            "name": name,
            "size": ref_img.size,
            "rms_diff": round(rms(diff), 3),
            "mean_abs_diff": round(mean_abs(diff), 3),
            "candidate": str(normalized_candidate),
            "diff": str(diff_path),
            "heatmap": str(heatmap_path),
        }

    regions = [compare_region("full", reference, candidate)]

    for raw_clip in args.clip:
        try:
            name, raw_box = raw_clip.split(":", 1)
            x, y, w, h = [int(part) for part in raw_box.split(",")]
        except Exception as exc:
            raise SystemExit(f"Invalid --clip value {raw_clip!r}; expected name:x,y,w,h") from exc
        box = (x, y, x + w, y + h)
        regions.append(compare_region(name, reference.crop(box), candidate.crop(box)))

    metrics_path = args.out_dir / f"{args.prefix}-metrics.json"
    metrics = {
        "reference": str(args.reference),
        "candidate": str(args.candidate),
        "reference_size": reference.size,
        "candidate_size_original": Image.open(args.candidate).size,
        "candidate_size_compared": candidate.size,
        "regions": regions,
    }
    metrics_path.write_text(json.dumps(metrics, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(metrics, ensure_ascii=False, indent=2))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import base64
import json
import mimetypes
import os
import re
import sys
import tempfile
import urllib.parse
import urllib.request
from dataclasses import dataclass
from datetime import datetime
from pathlib import Path
from typing import Iterable

DEFAULT_MODEL = os.getenv("DRAW_MODEL", "openai/gpt-image-2")
DEFAULT_BASE_URL = os.getenv("ZENMUX_VERTEX_BASE_URL", "https://zenmux.ai/api/vertex-ai")
DEFAULT_OUTPUT_ROOT = Path.home() / ".local" / "share" / "draw" / "outputs"
DEFAULT_MIME = "image/png"




def _read_env_value(path: Path, key: str) -> str:
    try:
        text = path.read_text(encoding="utf-8")
    except FileNotFoundError:
        return ""
    for line in text.splitlines():
        stripped = line.strip()
        if not stripped or stripped.startswith("#") or "=" not in stripped:
            continue
        name, value = stripped.split("=", 1)
        if name.strip() != key:
            continue
        value = value.strip().strip('"').strip("'")
        return value
    return ""


def resolve_api_key() -> str:
    env = os.getenv("ZENMUX_API_KEY", "").strip()
    if env:
        return env
    cwd = Path.cwd().resolve()
    for directory in [cwd, *cwd.parents]:
        found = _read_env_value(directory / ".env.local", "ZENMUX_API_KEY")
        if found:
            return found
    config_path = Path.home() / ".config" / "see" / "api_key"
    try:
        return config_path.read_text(encoding="utf-8").strip()
    except FileNotFoundError:
        return ""


def sanitize_name(value: str, fallback: str = "image") -> str:
    value = value.strip()
    value = re.sub(r"[\\/:*?\"<>|]+", "-", value)
    value = re.sub(r"\s+", "-", value)
    value = re.sub(r"-+", "-", value).strip("-_.")
    if not value:
        return fallback
    return value[:80]


def build_output_path(*, output_arg: str, image_type: str, topic: str, explicit_name: str, ext: str) -> Path:
    if output_arg:
        out = Path(output_arg).expanduser().resolve()
        if out.suffix:
            return out
        return out.with_suffix(ext)
    now = datetime.now()
    day_dir = DEFAULT_OUTPUT_ROOT / now.strftime("%Y-%m-%d")
    day_dir.mkdir(parents=True, exist_ok=True)
    base_name = sanitize_name(explicit_name or topic, fallback=image_type)
    return day_dir / f"{now.strftime('%Y%m%d-%H%M%S')}__{image_type}__{base_name}{ext}"


def metadata_path_for(image_path: Path) -> Path:
    return image_path.with_suffix(image_path.suffix + ".json")


def guess_extension(mime_type: str | None) -> str:
    if not mime_type:
        return ".png"
    guessed = mimetypes.guess_extension(mime_type)
    if guessed == ".jpe":
        return ".jpg"
    return guessed or ".png"


# Type only controls aspect ratio, prompt is fully controlled by caller
ASPECT_RATIOS = {
    "ultrawide": "21:9",
    "wide": "16:9",
    "square": "1:1",
    "portrait": "3:4",
    "classic": "4:3",
}


def download_file(url: str, dest: Path, timeout: int = 120) -> None:
    req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
    with urllib.request.urlopen(req, timeout=timeout) as response:
        dest.write_bytes(response.read())


def resolve_ref(raw: str, tmp_dir: Path) -> Path:
    parsed = urllib.parse.urlparse(raw)
    if parsed.scheme in {"http", "https"}:
        suffix = Path(parsed.path).suffix or ".png"
        dest = tmp_dir / f"ref-{len(list(tmp_dir.iterdir())) + 1}{suffix}"
        download_file(raw, dest)
        return dest
    path = Path(raw).expanduser().resolve()
    if not path.exists():
        raise FileNotFoundError(f"Reference not found: {raw}")
    return path


def load_genai():
    try:
        from google import genai
        from google.genai import types
    except ModuleNotFoundError as exc:
        raise SystemExit(
            "[ERROR] Missing dependency `google-genai`. Re-run via scripts/ask_draw.sh so it can auto-install it."
        ) from exc
    return genai, types


def build_contents(*, prompt: str, types, refs: Iterable[Path]):
    parts = [types.Part.from_text(text=prompt)]
    for ref in refs:
        mime = mimetypes.guess_type(ref.name)[0] or DEFAULT_MIME
        parts.append(types.Part.from_bytes(data=ref.read_bytes(), mime_type=mime))
    return parts


def extract_parts(response) -> list:
    if getattr(response, "parts", None):
        return list(response.parts)
    candidates = getattr(response, "candidates", None) or []
    parts = []
    for candidate in candidates:
        content = getattr(candidate, "content", None)
        if content and getattr(content, "parts", None):
            parts.extend(content.parts)
    return parts


def render_response(*, response, output_path: Path) -> tuple[str, str]:
    text_parts: list[str] = []
    image_written = False
    image_mime = DEFAULT_MIME
    pending_bytes: bytes | None = None

    for part in extract_parts(response):
        text = getattr(part, "text", None)
        if text:
            text_parts.append(text.strip())
        inline_data = getattr(part, "inline_data", None)
        if inline_data:
            data = inline_data.data
            if isinstance(data, str):
                pending_bytes = base64.b64decode(data)
            else:
                pending_bytes = data
            image_mime = getattr(inline_data, "mime_type", None) or DEFAULT_MIME

    if pending_bytes:
        final_path = output_path
        if not output_path.suffix:
            final_path = output_path.with_suffix(guess_extension(image_mime))
        final_path.write_bytes(pending_bytes)
        image_written = True
    else:
        final_path = output_path

    if not image_written:
        raise RuntimeError("Model returned no image data.")

    return final_path.as_posix(), "\n".join([t for t in text_parts if t]).strip()


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Generate images via ZenMux + GPT Image 2.")
    parser.add_argument("--type", choices=sorted(ASPECT_RATIOS.keys()), default="wide", help="Aspect ratio preset.")
    parser.add_argument("--prompt", required=True, help="Full prompt for image generation.")
    parser.add_argument("--ref", action="append", default=[], help="Reference image path or URL (repeatable).")
    parser.add_argument("--name", default="", help="Optional short output name.")
    parser.add_argument("-o", "--output", default="", help="Output image path.")
    parser.add_argument("--model", default=DEFAULT_MODEL, help="Model override.")
    parser.add_argument("--base-url", default=DEFAULT_BASE_URL, help=argparse.SUPPRESS)
    return parser.parse_args()


def _uses_generate_images_api(model: str) -> bool:
    """Models that require the generate_images / edit_image API instead of generate_content."""
    return model.startswith("openai/")


def _run_generate_images(*, client, model: str, prompt: str, refs: list[Path], types) -> tuple[bytes, str]:
    """Call generate_images (or edit_image when refs are provided) and return (image_bytes, response_text)."""
    if refs:
        # Use edit_image with reference images
        # First ref becomes the base image
        base_image_path = refs[0]
        base_mime = mimetypes.guess_type(base_image_path.name)[0] or DEFAULT_MIME
        base_image = types.Image(image_bytes=base_image_path.read_bytes(), mime_type=base_mime)
        reference_images = [
            types.RawReferenceImage(reference_id=1, reference_image=base_image)
        ]
        # Additional refs as extra references
        for i, ref_path in enumerate(refs[1:], start=2):
            ref_mime = mimetypes.guess_type(ref_path.name)[0] or DEFAULT_MIME
            ref_img = types.Image(image_bytes=ref_path.read_bytes(), mime_type=ref_mime)
            reference_images.append(
                types.RawReferenceImage(reference_id=i, reference_image=ref_img)
            )
        response = client.models.edit_image(
            model=model,
            prompt=prompt,
            reference_images=reference_images,
        )
    else:
        response = client.models.generate_images(
            model=model,
            prompt=prompt,
        )

    generated = getattr(response, "generated_images", None)
    if not generated:
        raise RuntimeError("Model returned no generated images.")

    image_obj = generated[0].image
    image_bytes = getattr(image_obj, "image_bytes", None)
    if image_bytes is None:
        # Some versions expose .data as base64
        raw = getattr(image_obj, "data", None)
        if isinstance(raw, str):
            image_bytes = base64.b64decode(raw)
        elif isinstance(raw, bytes):
            image_bytes = raw
    if not image_bytes:
        raise RuntimeError("Could not extract image bytes from generate_images response.")

    return image_bytes, ""


def main() -> int:
    args = parse_args()
    api_key = resolve_api_key()
    if not api_key:
        print(
            "[ERROR] No ZENMUX_API_KEY found. Set it as env var, in .env.local, or in ~/.config/see/api_key",
            file=sys.stderr,
        )
        return 1

    aspect_ratio = ASPECT_RATIOS[args.type]

    with tempfile.TemporaryDirectory(prefix="draw-refs-") as tmp:
        tmp_dir = Path(tmp)
        refs = [resolve_ref(raw, tmp_dir) for raw in args.ref]
        output_path = build_output_path(
            output_arg=args.output,
            image_type=args.type,
            topic=args.name or "image",
            explicit_name=args.name,
            ext=".png",
        )

        genai, types = load_genai()
        # OpenAI image models via ZenMux can take longer; bump timeout to 5 minutes.
        timeout = 300 if _uses_generate_images_api(args.model) else 120
        client = genai.Client(
            api_key=api_key,
            vertexai=True,
            http_options=types.HttpOptions(api_version="v1", base_url=args.base_url, timeout=timeout * 1000),
        )

        if _uses_generate_images_api(args.model):
            image_bytes, response_text = _run_generate_images(
                client=client, model=args.model, prompt=args.prompt, refs=refs, types=types,
            )
            final_path = output_path if output_path.suffix else output_path.with_suffix(".png")
            final_path.parent.mkdir(parents=True, exist_ok=True)
            final_path.write_bytes(image_bytes)
        else:
            response = client.models.generate_content(
                model=args.model,
                contents=build_contents(prompt=args.prompt, types=types, refs=refs),
                config=types.GenerateContentConfig(
                    response_modalities=["TEXT", "IMAGE"],
                    image_config=types.ImageConfig(aspect_ratio=aspect_ratio),
                ),
            )
            final_path_str, response_text = render_response(response=response, output_path=output_path)
            final_path = Path(final_path_str)

        meta_path = metadata_path_for(final_path)
        metadata = {
            "created_at": datetime.now().isoformat(timespec="seconds"),
            "type": args.type,
            "aspect_ratio": aspect_ratio,
            "prompt": args.prompt,
            "refs": [str(path) for path in refs],
            "provider": "zenmux",
            "model": args.model,
            "base_url": args.base_url,
            "output_path": str(final_path),
            "response_text": response_text,
        }
        meta_path.write_text(json.dumps(metadata, ensure_ascii=False, indent=2), encoding="utf-8")

    print(f"output_path={final_path}")
    print(f"metadata_path={meta_path}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
from __future__ import annotations

import argparse
from pathlib import Path

from PIL import Image


def foreground_mask(img: Image.Image, *, threshold: int) -> Image.Image:
    rgb = img.convert("RGB")
    return Image.eval(rgb, lambda px: 0 if px >= threshold else 255).convert("L")


def trim(img: Image.Image, *, threshold: int, padding: int) -> Image.Image:
    mask = foreground_mask(img, threshold=threshold)
    bbox = mask.getbbox()
    if bbox is None:
        return img

    left, top, right, bottom = bbox
    left = max(0, left - padding)
    top = max(0, top - padding)
    right = min(img.width, right + padding)
    bottom = min(img.height, bottom + padding)
    return img.crop((left, top, right, bottom))


def trim_alpha(img: Image.Image, *, padding: int) -> Image.Image:
    rgba = img.convert("RGBA")
    alpha = rgba.getchannel("A")
    bbox = alpha.getbbox()
    if bbox is None:
        return rgba

    left, top, right, bottom = bbox
    left = max(0, left - padding)
    top = max(0, top - padding)
    right = min(rgba.width, right + padding)
    bottom = min(rgba.height, bottom + padding)
    return rgba.crop((left, top, right, bottom))


def white_to_alpha(img: Image.Image, *, threshold: int, feather: int) -> Image.Image:
    rgba = img.convert("RGBA")
    pixels = rgba.load()

    for y in range(rgba.height):
        for x in range(rgba.width):
            red, green, blue, alpha = pixels[x, y]
            brightness = max(red, green, blue)
            if red >= threshold and green >= threshold and blue >= threshold:
                pixels[x, y] = (255, 255, 255, 0)
                continue
            if feather > 0 and brightness >= threshold - feather:
                new_alpha = int(alpha * (threshold - brightness + feather) / feather)
                pixels[x, y] = (red, green, blue, max(0, min(alpha, new_alpha)))

    return rgba


def parse_hex_color(value: str) -> tuple[int, int, int]:
    raw = value.strip().lstrip("#")
    if len(raw) != 6:
        raise ValueError("key color must be a 6-digit hex color, for example #00ff00")
    return int(raw[0:2], 16), int(raw[2:4], 16), int(raw[4:6], 16)


def key_color_to_alpha(
    img: Image.Image,
    *,
    key_color: tuple[int, int, int],
    threshold: int,
    feather: int,
    despill: bool,
    edge_contract: int,
) -> Image.Image:
    rgba = img.convert("RGBA")
    pixels = rgba.load()
    kr, kg, kb = key_color

    for y in range(rgba.height):
        for x in range(rgba.width):
            red, green, blue, alpha = pixels[x, y]
            distance = ((red - kr) ** 2 + (green - kg) ** 2 + (blue - kb) ** 2) ** 0.5
            if distance <= threshold:
                pixels[x, y] = (red, green, blue, 0)
                continue
            if feather > 0 and distance <= threshold + feather:
                new_alpha = int(alpha * (distance - threshold) / feather)
                pixels[x, y] = (red, green, blue, max(0, min(alpha, new_alpha)))

    if despill:
        pixels = rgba.load()
        for y in range(rgba.height):
            for x in range(rgba.width):
                red, green, blue, alpha = pixels[x, y]
                if alpha == 0:
                    continue
                # Remove green spill on semi-transparent and edge pixels.
                green_excess = green - max(red, blue)
                if green_excess <= 0:
                    continue
                edge_factor = 1.0 - (alpha / 255.0)
                reduction = int(green_excess * (0.72 + 0.28 * edge_factor))
                green = max(max(red, blue), green - reduction)
                pixels[x, y] = (red, green, blue, alpha)

    if edge_contract > 0:
        rgba = contract_alpha_edge(rgba, pixels=edge_contract)

    return rgba


def contract_alpha_edge(img: Image.Image, *, pixels: int) -> Image.Image:
    rgba = img.convert("RGBA")
    alpha = rgba.getchannel("A")
    try:
        from PIL import ImageFilter
        for _ in range(pixels):
            alpha = alpha.filter(ImageFilter.MinFilter(3))
        rgba.putalpha(alpha)
    except Exception:
        pass
    return rgba


def main() -> int:
    parser = argparse.ArgumentParser(
        description="Prepare AI-generated UI assets by trimming white padding and optionally making white background transparent."
    )
    parser.add_argument("input", type=Path)
    parser.add_argument("output", type=Path)
    parser.add_argument("--no-trim", action="store_true", help="Keep original canvas size.")
    parser.add_argument("--alpha", action="store_true", help="Convert near-white background to transparent alpha.")
    parser.add_argument("--key-color", help="Convert a chroma key color such as #00ff00 to transparent alpha.")
    parser.add_argument("--threshold", type=int, default=248, help="Near-white threshold, 0-255.")
    parser.add_argument("--key-threshold", type=int, default=28, help="Chroma key distance threshold.")
    parser.add_argument("--feather", type=int, default=12, help="Soft alpha range below threshold.")
    parser.add_argument("--despill", action="store_true", help="Reduce green spill on chroma-keyed edges.")
    parser.add_argument("--edge-contract", type=int, default=0, help="Shrink alpha edge by this many pixels after keying.")
    parser.add_argument("--padding", type=int, default=24, help="Padding kept around trimmed foreground.")
    args = parser.parse_args()

    img = Image.open(args.input).convert("RGBA")
    if args.key_color:
        img = key_color_to_alpha(
            img,
            key_color=parse_hex_color(args.key_color),
            threshold=args.key_threshold,
            feather=args.feather,
            despill=args.despill,
            edge_contract=args.edge_contract,
        )
        if not args.no_trim:
            img = trim_alpha(img, padding=args.padding)
    elif not args.no_trim:
        img = trim(img, threshold=args.threshold, padding=args.padding)
    if args.alpha:
        img = white_to_alpha(img, threshold=args.threshold, feather=args.feather)

    args.output.parent.mkdir(parents=True, exist_ok=True)
    img.save(args.output)
    print(f"wrote {args.output}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env bash
set -euo pipefail

usage() {
  cat <<'EOF'
Usage:
  scripts/verify_html_mockup.sh \
    --html /path/to/page.html \
    --reference /path/to/mockup.png \
    --out-dir /path/to/verify-output \
    [--viewport 1024x1536] \
    [--full-page] \
    [--session ui-verify]

Opens the HTML in an isolated agent-browser session, captures a viewport
screenshot at the requested viewport, then runs compare_mockup.py. Use
--full-page only when the reference image is also a full-page capture.
EOF
}

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
HTML_PATH=""
REFERENCE_PATH=""
OUT_DIR=""
VIEWPORT="1024x1536"
SESSION="ui-design-verify"
FULL_PAGE=0
CHROME_PATH="${AGENT_BROWSER_EXECUTABLE_PATH:-/Applications/Google Chrome.app/Contents/MacOS/Google Chrome}"

while [[ $# -gt 0 ]]; do
  case "$1" in
    --html)
      HTML_PATH="$2"
      shift 2
      ;;
    --reference)
      REFERENCE_PATH="$2"
      shift 2
      ;;
    --out-dir)
      OUT_DIR="$2"
      shift 2
      ;;
    --viewport)
      VIEWPORT="$2"
      shift 2
      ;;
    --session)
      SESSION="$2"
      shift 2
      ;;
    --full-page)
      FULL_PAGE=1
      shift
      ;;
    -h|--help)
      usage
      exit 0
      ;;
    *)
      echo "Unknown argument: $1" >&2
      usage >&2
      exit 2
      ;;
  esac
done

if [[ -z "$HTML_PATH" || -z "$REFERENCE_PATH" || -z "$OUT_DIR" ]]; then
  usage >&2
  exit 2
fi

if [[ ! -f "$HTML_PATH" ]]; then
  echo "HTML file not found: $HTML_PATH" >&2
  exit 1
fi

if [[ ! -f "$REFERENCE_PATH" ]]; then
  echo "Reference image not found: $REFERENCE_PATH" >&2
  exit 1
fi

if [[ "$VIEWPORT" != *x* ]]; then
  echo "Viewport must look like 1024x1536" >&2
  exit 2
fi

VIEWPORT_W="${VIEWPORT%x*}"
VIEWPORT_H="${VIEWPORT#*x}"
mkdir -p "$OUT_DIR"

case "$HTML_PATH" in
  file://*)
    URL="$HTML_PATH"
    ;;
  /*)
    URL="file://$HTML_PATH"
    ;;
  *)
    URL="file://$(cd "$(dirname "$HTML_PATH")" && pwd)/$(basename "$HTML_PATH")"
    ;;
esac

SCREENSHOT="$OUT_DIR/browser-screenshot.png"
FULL_SCREENSHOT="$OUT_DIR/browser-full-page.png"

agent-browser \
  --session "$SESSION" \
  --executable-path "$CHROME_PATH" \
  --allow-file-access \
  set viewport "$VIEWPORT_W" "$VIEWPORT_H"

agent-browser \
  --session "$SESSION" \
  --executable-path "$CHROME_PATH" \
  --allow-file-access \
  open "$URL"

if [[ "$FULL_PAGE" -eq 1 ]]; then
  agent-browser \
    --session "$SESSION" \
    --executable-path "$CHROME_PATH" \
    --allow-file-access \
    screenshot "$SCREENSHOT" --full
else
  agent-browser \
    --session "$SESSION" \
    --executable-path "$CHROME_PATH" \
    --allow-file-access \
    screenshot "$SCREENSHOT"

  agent-browser \
    --session "$SESSION" \
    --executable-path "$CHROME_PATH" \
    --allow-file-access \
    screenshot "$FULL_SCREENSHOT" --full
fi

python3 "$SCRIPT_DIR/compare_mockup.py" \
  --reference "$REFERENCE_PATH" \
  --candidate "$SCREENSHOT" \
  --out-dir "$OUT_DIR" \
  --prefix verify