#!/usr/bin/env python3
"""Smoke test for Offline Strijd (t1119), chain HUD, column warn (t1123)."""
from __future__ import annotations

import socket
import subprocess
import sys
import time
from pathlib import Path

from playwright.sync_api import sync_playwright

ROOT = Path("/workspace/meteors")
OUT = Path("/workspace/meteors-shots")
OUT.mkdir(parents=True, exist_ok=True)
CHROME = "/usr/bin/google-chrome"
CHROME_ARGS = [
    "--use-gl=angle",
    "--use-angle=swiftshader",
    "--no-sandbox",
    "--disable-dev-shm-usage",
    "--disable-gpu-sandbox",
]
FAILURES = []


def free_port():
    s = socket.socket()
    s.bind(("127.0.0.1", 0))
    port = s.getsockname()[1]
    s.close()
    return port


def check(cond, msg):
    if not cond:
        FAILURES.append(msg)
        print("FAIL", msg)
    else:
        print("OK  ", msg)
    return cond


def shot(page, name):
    path = OUT / name
    page.screenshot(path=str(path), full_page=False)
    print(f"wrote {path} ({path.stat().st_size} bytes)")
    return path


def start_http(port):
    proc = subprocess.Popen(
        ["python3", "-m", "http.server", str(port), "--bind", "127.0.0.1",
         "--directory", str(ROOT / "build")],
        stdout=subprocess.DEVNULL,
        stderr=subprocess.DEVNULL,
    )
    time.sleep(0.35)
    if proc.poll() is not None:
        raise RuntimeError("http.server failed to start")
    return proc


def open_offline(page, url):
    page.goto(url, wait_until="domcontentloaded", timeout=15000)
    page.wait_for_timeout(400)
    page.locator("#btn-offline").click()
    page.wait_for_selector("#planet-select:not([hidden])", timeout=8000)
    page.locator("#btn-planet-go").click()
    page.wait_for_function(
        "() => app && app.mode === 'playing' && app.offline && app.battle && app.core",
        timeout=10000,
    )


def run(page, tag):
    hud = page.evaluate("""() => ({
        round: document.getElementById('offline-round') && document.getElementById('offline-round').textContent,
        opponents: document.getElementById('offline-opponents') && document.getElementById('offline-opponents').textContent,
        skill: document.getElementById('offline-skill') && document.getElementById('offline-skill').textContent,
        hidden: document.getElementById('offline-hud') && document.getElementById('offline-hud').hidden,
        bots: app.battle && app.battle.bots.length,
        schedule: app.battle && app.battle.schedule,
        jump: app.planet && app.planet.baseJumpHeight,
        fall: app.planet && app.planet.fallSpeed,
        clusterFall: app.planet && app.planet.clusterFallSpeed,
    })""")
    print("HUD", hud)
    check(hud["hidden"] is False, f"{tag}: offline HUD visible")
    check(hud["round"] == "Ronde 1", f"{tag}: round is Ronde 1 ({hud['round']})")
    check("1 tegenstander" in (hud["opponents"] or ""), f"{tag}: one opponent ({hud['opponents']})")
    check(hud["skill"] == "Skill 5%", f"{tag}: skill 5% ({hud['skill']})")
    check(hud["bots"] == 1, f"{tag}: one bot field")
    check(abs(hud["jump"] - 1.5 * 13 / 2) < 1e-9, f"{tag}: +50% jump height ({hud['jump']})")
    check(abs(hud["fall"] - 13 / 3) < 1e-9, f"{tag}: full spawn fallSpeed ({hud['fall']})")
    check(abs(hud["clusterFall"] - 0.5 * 13 / 3) < 1e-9, f"{tag}: halved cluster float-down ({hud['clusterFall']})")
    mini = page.locator("#minis .mini")
    check(mini.count() >= 1, f"{tag}: at least one bot mini")
    name = mini.first.locator(".mini-name").inner_text()
    check(name.startswith("Bot 1"), f"{tag}: mini named {name!r}")
    shot(page, f"t1119-offline-ronde1-{tag}.png")

    # Many opponents: jump to a high-N schedule and check minis stay cheap.
    info = page.evaluate("""() => {
        app.battle.advanceRound(); // 2
        app.battle.advanceRound(); // 3, 3 opponents after two advances from 1? 
        // From round 1, advance → 2 (2 bots), advance → 3 (3 bots).
        // Call more to get 6 opponents (round 12 starts 6? let's set round).
        const Offline = window.Offline;
        app.battle.round = 8;
        app.battle.schedule = Offline.scheduleForRound(8);
        app.battle._initBots();
        if (typeof renderOfflineMinis === 'function') renderOfflineMinis();
        else if (app.battle) { /* tick will render */ }
        return { round: app.battle.round, n: app.battle.bots.length, skill: app.battle.schedule.skill };
    }""")
    print("many", info)
    page.wait_for_timeout(200)
    page.evaluate("() => { if (typeof renderOfflineMinis === 'function') renderOfflineMinis(); }")
    page.wait_for_timeout(150)
    nmini = page.locator("#minis .mini").count()
    check(nmini == info["n"], f"{tag}: {nmini} minis for {info['n']} bots")
    shot(page, f"t1119-offline-many-{tag}.png")

    # Column warn: 10 grounded in column 0, pulse visible on the player field.
    page.evaluate("""() => {
        const g = app.core;
        // Clear and fill column 0 with 10 still blocks.
        for (let i = g.blocks.length - 1; i >= 0; i--) {
            try { g.removeBlock(g.blocks[i]); } catch (e) {}
        }
        for (let r = 0; r < 10; r++) g.place(0, r, r % 5);
        if (typeof updateColumnWarn === 'function') updateColumnWarn(0.4);
    }""")
    page.wait_for_timeout(200)
    warn = page.evaluate("""() => ({
        needs: app.core.columnNeedsWarn(0),
        count: app.core.groundedCount(0),
        visible: !!(app.columnWarn && app.columnWarn[0] && app.columnWarn[0].renderer.visible),
        alpha: app.columnWarn && app.columnWarn[0] && app.columnWarn[0].renderer.alpha,
    })""")
    print("warn", warn)
    check(warn["needs"] is True and warn["count"] >= 10, f"{tag}: column 0 needs warn")
    check(warn["visible"] is True and warn["alpha"] > 0, f"{tag}: warn quad visible alpha={warn['alpha']}")
    shot(page, f"t1123-column-warn-{tag}.png")

    # Result screen.
    page.evaluate("""() => {
        app.core.state = 'gameover';
        app.battle.state = 'lost';
        if (typeof showOfflineResult === 'function') showOfflineResult();
    }""")
    page.wait_for_selector("#offline-result:not([hidden])", timeout=5000)
    reached = page.locator("#offline-reached").inner_text()
    check(reached.isdigit() and int(reached) >= 1, f"{tag}: reached round shown ({reached})")
    shot(page, f"t1119-offline-result-{tag}.png")


def main():
    # Ensure a fresh build is what we serve.
    port = free_port()
    proc = start_http(port)
    url = f"http://127.0.0.1:{port}/index.html"
    try:
        with sync_playwright() as p:
            browser = p.chromium.launch(executable_path=CHROME, args=CHROME_ARGS)
            # desktop
            ctx = browser.new_context(viewport={"width": 1280, "height": 900})
            page = ctx.new_page()
            open_offline(page, url)
            run(page, "desktop")
            ctx.close()
            # mobile
            ctx = browser.new_context(
                viewport={"width": 393, "height": 851},
                device_scale_factor=2,
                is_mobile=True,
                has_touch=True,
            )
            page = ctx.new_page()
            open_offline(page, url)
            run(page, "mobile")
            ctx.close()
            browser.close()
    finally:
        proc.terminate()
        try:
            proc.wait(timeout=2)
        except Exception:
            proc.kill()

    if FAILURES:
        print(f"\n{len(FAILURES)} FAILURES:")
        for f in FAILURES:
            print(" -", f)
        sys.exit(1)
    print("\nall offline playwright checks passed")


if __name__ == "__main__":
    main()
