#!/usr/bin/env python3
"""Layout and flight-arc visuals for t1125 (wide / narrow / mobile)."""
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, round_n=1):
    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,
    )
    if round_n != 1:
        page.evaluate(
            """(round) => {
                teardownPlay();
                startPlay({ planet: app.planet, offline: true, round: round });
            }""",
            round_n,
        )
        page.wait_for_function(
            "() => app && app.mode === 'playing' && app.battle && app.miniLayout",
            timeout=8000,
        )
        page.wait_for_timeout(250)


LAYOUT_INFO = """() => {
    const plan = app.miniLayout || {};
    const fieldEl = app.scene && app.scene.canvas;
    const fr = fieldEl ? fieldEl.getBoundingClientRect() : null;
    const minis = [...document.querySelectorAll('#minis .mini')].map((el) => {
        const r = el.getBoundingClientRect();
        const c = el.querySelector('canvas');
        const cr = c ? c.getBoundingClientRect() : r;
        return {
            id: el.getAttribute('data-player'),
            left: r.left, right: r.right, top: r.top, bottom: r.bottom,
            cx: cr.left + cr.width / 2,
            cy: cr.top + cr.height / 2
        };
    });
    return {
        mode: plan.mode,
        sidesClass: document.getElementById('minis').classList.contains('sides'),
        n: plan.n,
        field: fr ? { left: fr.left, right: fr.right, top: fr.top, bottom: fr.bottom,
                       x: app.fieldX, y: app.fieldY, w: app.fieldW, h: app.fieldH } : null,
        positions: plan.positions || [],
        minis,
        tile: app.tile,
        vw: window.innerWidth,
        vh: window.innerHeight
    };
}"""


INJECT_FLIGHTS = """() => {
    const plan = app.miniLayout;
    const field = app.scene.canvas.getBoundingClientRect();
    const minis = [...document.querySelectorAll('#minis .mini')];
    function anchor(id, inner) {
        const el = document.querySelector('#minis .mini[data-player=\"' + id + '\"] canvas');
        if (!el) return { x: 80, y: 80 };
        const r = el.getBoundingClientRect();
        if (plan && plan.mode === 'sides') {
            const mid = field.left + field.width / 2;
            const left = (r.left + r.width / 2) < mid;
            if (inner) return { x: left ? r.right : r.left, y: r.top + r.height / 2 };
            return { x: r.left + r.width / 2, y: r.top + r.height / 2 };
        }
        return { x: r.left + r.width / 2, y: inner ? r.bottom : r.top };
    }
    const bots = (app.battle.bots || []).map(b => b.id);
    const a = bots[0] || 'bot-1';
    const b = bots[1] || bots[0] || 'bot-2';
    const pStart = {
        x: field.left + field.width / 2,
        y: field.top + 4
    };
    if (typeof Online.clearFlights === 'function') Online.clearFlights();
    const flights = [
        { id: 'vis-p2e', client_id: 'vis-p2e', from_id: 'player', target_id: a, miss: false, color: 0, flight_duration: 1.2, age: 0.55 },
        { id: 'vis-e2p', client_id: 'vis-e2p', from_id: a, target_id: 'player', miss: false, color: 1, flight_duration: 1.2, age: 0.55 },
        { id: 'vis-e2e', client_id: 'vis-e2e', from_id: a, target_id: b, miss: false, color: 2, flight_duration: 1.2, age: 0.55 },
        { id: 'vis-emiss', client_id: 'vis-emiss', from_id: b, target_id: null, miss: true, color: 3, flight_duration: 1.2, age: 0.45 }
    ];
    const aOut = anchor(a, true);
    const bOut = anchor(b, true);
    const locals = {
        'vis-p2e': { from_id: 'player', color: 0, startX: pStart.x, startY: pStart.y, col: 4 },
        'vis-e2p': { from_id: a, color: 1, startX: aOut.x, startY: aOut.y },
        'vis-e2e': { from_id: a, color: 2, startX: aOut.x, startY: aOut.y },
        'vis-emiss': { from_id: b, color: 3, startX: bOut.x, startY: bOut.y }
    };
    Online.spawnFlights(flights, locals);
    Online.tickFlights();
    const front = [...document.querySelectorAll('#flights .flight')].map(el => ({
        cls: el.className,
        transform: el.style.transform,
        opacity: el.style.opacity,
        parent: 'front'
    }));
    const back = [...document.querySelectorAll('#flights-back .flight')].map(el => ({
        cls: el.className,
        transform: el.style.transform,
        opacity: el.style.opacity,
        parent: 'back'
    }));
    return {
        front: front.length,
        back: back.length,
        kinds: (Online._flights || []).map(f => ({
            kind: f.kind, miss: f.miss,
            startScale: f.startScale, endScale: f.endScale,
            parent: (f.el && f.el.parentElement && f.el.parentElement.id) || ''
        }))
    };
}"""


def assert_sides(info, tag, expect_rows=False):
    check(info["mode"] == "sides", f"{tag}: mode is sides (got {info['mode']})")
    check(info["sidesClass"], f"{tag}: #minis has .sides")
    field = info["field"]
    minis = info["minis"]
    check(len(minis) >= 1, f"{tag}: at least one mini ({len(minis)})")
    if not field or not minis:
        return
    for i, m in enumerate(minis):
        if i % 2 == 0:
            check(m["right"] <= field["left"] + 2,
                  f"{tag}: mini {i} ({m['id']}) is on the left of the field "
                  f"(right={m['right']:.1f} field.left={field['left']:.1f})")
        else:
            check(m["left"] >= field["right"] - 2,
                  f"{tag}: mini {i} ({m['id']}) is on the right of the field "
                  f"(left={m['left']:.1f} field.right={field['right']:.1f})")
        check(m["bottom"] <= field["bottom"] + 8,
              f"{tag}: mini {i} does not hang below the field")
        check(m["top"] >= 50,
              f"{tag}: mini {i} stays under the HUD (top={m['top']:.1f})")
    if expect_rows and len(minis) >= 3:
        # 3rd (index 2) is left, stacked above the first
        check(minis[2]["bottom"] <= minis[0]["top"] + 4,
              f"{tag}: third mini is stacked above the first "
              f"(b={minis[2]['bottom']:.1f} vs top={minis[0]['top']:.1f})")


def assert_top(info, tag):
    check(info["mode"] == "top", f"{tag}: mode is top (got {info['mode']})")
    check(not info["sidesClass"], f"{tag}: #minis is not .sides")
    field = info["field"]
    minis = info["minis"]
    check(len(minis) >= 1, f"{tag}: at least one mini")
    if not field or not minis:
        return
    for i, m in enumerate(minis):
        check(m["bottom"] <= field["top"] + 12,
              f"{tag}: mini {i} sits above the field "
              f"(bottom={m['bottom']:.1f} field.top={field['top']:.1f})")


def assert_flights(info, tag, expect_behind=True):
    check(info["front"] >= 3, f"{tag}: front flights present ({info['front']})")
    kinds = {k["kind"]: k for k in info["kinds"]}
    check("player-to-enemy" in kinds, f"{tag}: player-to-enemy")
    check("enemy-to-player" in kinds, f"{tag}: enemy-to-player")
    check("enemy-miss" in kinds, f"{tag}: enemy-miss")
    if "player-to-enemy" in kinds:
        k = kinds["player-to-enemy"]
        check(k["startScale"] > k["endScale"],
              f"{tag}: player-to-enemy shrinks ({k['startScale']:.2f}→{k['endScale']:.2f})")
    if "enemy-to-player" in kinds:
        k = kinds["enemy-to-player"]
        check(k["endScale"] > k["startScale"],
              f"{tag}: enemy-to-player grows ({k['startScale']:.2f}→{k['endScale']:.2f})")
    if "enemy-to-enemy" in kinds:
        k = kinds["enemy-to-enemy"]
        check(abs(k["startScale"] - k["endScale"]) < 0.05,
              f"{tag}: enemy-to-enemy stays small ({k['startScale']:.2f})")
        check(k["parent"] == "flights-back",
              f"{tag}: enemy-to-enemy is in #flights-back (got {k['parent']})")
        if expect_behind:
            check(info["back"] >= 1, f"{tag}: at least one behind-field flight")
    if "enemy-miss" in kinds:
        k = kinds["enemy-miss"]
        check(k["startScale"] < 0.7,
              f"{tag}: enemy-miss starts small ({k['startScale']:.2f})")
        check(k["parent"] == "flights",
              f"{tag}: enemy-miss is in #flights (got {k['parent']})")


def run_viewport(browser, url, name, width, height, is_mobile, round_n, expect_mode):
    context = browser.new_context(
        viewport={"width": width, "height": height},
        device_scale_factor=1,
        is_mobile=is_mobile,
        has_touch=is_mobile,
    )
    page = context.new_page()
    open_offline(page, url, round_n=round_n)
    page.wait_for_timeout(300)
    info = page.evaluate(LAYOUT_INFO)
    print(f"--- {name} layout:", {k: info[k] for k in ('mode', 'n', 'tile', 'vw', 'vh', 'sidesClass')})
    if expect_mode == "sides":
        assert_sides(info, name, expect_rows=(round_n >= 12))
    else:
        assert_top(info, name)
    shot(page, f"t1125-{name}-layout.png")

    flights = page.evaluate(INJECT_FLIGHTS)
    print(f"--- {name} flights:", flights)
    assert_flights(flights, name)
    shot(page, f"t1125-{name}-flights.png")
    context.close()


def main():
    port = free_port()
    http = start_http(port)
    url = f"http://127.0.0.1:{port}/"
    try:
        with sync_playwright() as p:
            browser = p.chromium.launch(
                executable_path=CHROME,
                args=CHROME_ARGS,
                headless=True,
            )
            # Desktop wide: 2 opponents (round 2) alternating L/R
            run_viewport(browser, url, "desktop-wide", 1280, 900, False, 2, "sides")
            # Many opponents, stacked rows (round 25 → 8 bots)
            run_viewport(browser, url, "desktop-wide-many", 1400, 900, False, 25, "sides")
            # Desktop narrow: top layout
            run_viewport(browser, url, "desktop-narrow", 720, 800, False, 2, "top")
            # Mobile
            run_viewport(browser, url, "mobile", 393, 851, True, 2, "top")
            browser.close()
    finally:
        http.terminate()
        try:
            http.wait(timeout=3)
        except subprocess.TimeoutExpired:
            http.kill()

    if FAILURES:
        print(f"\n{len(FAILURES)} failure(s):")
        for f in FAILURES:
            print(" -", f)
        return 1
    print("\nall minis/flights checks passed")
    return 0


if __name__ == "__main__":
    sys.exit(main())
