#!/usr/bin/env python3
"""t1141: flag picker, translations, persistence, no overflow."""
from __future__ import annotations

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

from playwright.sync_api import sync_playwright

ROOT = Path("/workspace/meteors")
SHOTS = Path("/workspace/meteors-shots")
SHOTS.mkdir(parents=True, exist_ok=True)
PHP = os.environ.get("PHP", "/home/box/.local/bin/php")
CHROME = "/usr/bin/google-chrome"
CHROME_ARGS = [
    "--use-gl=angle",
    "--use-angle=swiftshader",
    "--no-sandbox",
    "--disable-dev-shm-usage",
]
FAILURES = []
URL = None

MOBILE = {
    "viewport": {"width": 390, "height": 844},
    "device_scale_factor": 2,
    "is_mobile": True,
    "has_touch": True,
    "user_agent": (
        "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) "
        "AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 "
        "Mobile/15E148 Safari/604.1"
    ),
}

# Expected Play-button text per locale (menu.play)
PLAY = {
    "en": "Play",
    "nl": "Spelen",
    "de": "Spielen",
    "fr": "Jouer",
    "ja": "プレイ",
    "zh": "开始游戏",
    "ko": "플레이",
    "pl": "Graj",
    "ru": "Играть",
    "es": "Jugar",
}
FLAGS = {
    "en": "gb", "nl": "nl", "de": "de", "fr": "fr", "ja": "jp",
    "zh": "cn", "ko": "kr", "pl": "pl", "ru": "ru", "es": "es",
}


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


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


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


def start_php(port, data, log_path):
    env = os.environ.copy()
    env["METEORS_DATA_DIR"] = str(data)
    log = open(log_path, "w")
    proc = subprocess.Popen(
        [PHP, "-S", f"127.0.0.1:{port}", "-t", str(ROOT / "build"), str(ROOT / "build" / "router.php")],
        cwd=str(ROOT / "build"),
        env=env,
        stdout=log,
        stderr=log,
    )
    time.sleep(0.5)
    if proc.poll() is not None:
        err = Path(log_path).read_text(errors="replace")
        raise RuntimeError("php -S failed: " + err)
    return proc


def login(page, n=1):
    page.goto(f"{URL}auth.php?test={n}&next=index.html", wait_until="domcontentloaded", timeout=20000)
    page.wait_for_timeout(200)
    page.goto(f"{URL}index.html", wait_until="networkidle", timeout=20000)
    page.wait_for_function(
        "() => { const u = document.getElementById('menu-user'); return u && !u.hidden; }",
        timeout=10000,
    )
    page.wait_for_timeout(400)


def no_overflow(page, label):
    info = page.evaluate(
        """() => ({
            sw: document.documentElement.scrollWidth,
            iw: window.innerWidth,
            sh: document.documentElement.scrollHeight,
            ih: window.innerHeight,
            bodyOverflow: document.body.scrollWidth,
        })"""
    )
    ok = info["sw"] <= info["iw"] + 2 and info["bodyOverflow"] <= info["iw"] + 2
    check(ok, f"no overflow {label}: scrollW={info['sw']} innerW={info['iw']}")
    return ok


def goto_fresh(page, clear=True):
    if clear:
        page.goto(f"{URL}index.html", wait_until="domcontentloaded", timeout=20000)
        page.evaluate(
            """() => {
                try { localStorage.removeItem('meteors-locale'); } catch (e) {}
                document.cookie = 'meteors-locale=; path=/; max-age=0';
            }"""
        )
        page.reload(wait_until="networkidle", timeout=20000)
    else:
        page.goto(f"{URL}index.html", wait_until="networkidle", timeout=20000)
    page.wait_for_selector("#btn-play", timeout=10000)
    page.wait_for_timeout(200)


def current_play(page):
    # CSS text-transform: uppercase on the Play button
    return page.locator("#btn-play").inner_text().strip()

def play_eq(got, expected, msg):
    check(got.casefold() == expected.casefold(), msg)


def set_lang(page, loc):
    page.locator("#lang-current").click()
    page.wait_for_selector("#lang-list:not([hidden])", timeout=4000)
    page.locator(f'#lang-list .lang-option[data-locale="{loc}"]').click()
    page.wait_for_timeout(250)
    page.wait_for_function(
        f"() => document.documentElement.getAttribute('data-locale') === '{loc}'",
        timeout=4000,
    )


def run_desktop(browser, ctx_kwargs=None):
    ctx = browser.new_context(
        viewport={"width": 1280, "height": 800},
        device_scale_factor=1,
        **(ctx_kwargs or {}),
    )
    page = ctx.new_page()
    goto_fresh(page)

    # Default English
    play = current_play(page)
    play_eq(play, "Play", f"default Play is English, got {play!r}")
    html_lang = page.evaluate("() => document.documentElement.lang")
    check(html_lang == "en", f"html lang default en, got {html_lang}")
    stored = page.evaluate("() => localStorage.getItem('meteors-locale')")
    # After init, default en is written; that's ok. Fresh clear then reload should still be en.
    src = page.locator("#lang-current img").get_attribute("src") or ""
    check("gb.svg" in src, f"UK flag on current, src={src}")
    no_overflow(page, "desktop-en-closed")
    shot(page, "t1141-desktop-menu-en.png")

    # Open picker: 10 flags
    page.locator("#lang-current").click()
    page.wait_for_selector("#lang-list:not([hidden])", timeout=4000)
    n = page.locator("#lang-list .lang-option").count()
    check(n == 10, f"picker shows 10 flags, got {n}")
    for loc, flag in FLAGS.items():
        el = page.locator(f'#lang-list .lang-option[data-locale="{loc}"] img')
        check(el.count() == 1, f"flag for {loc}")
        if el.count():
            s = el.get_attribute("src") or ""
            check(flag + ".svg" in s, f"{loc} uses {flag}.svg, src={s}")
    no_overflow(page, "desktop-picker-open")
    shot(page, "t1141-desktop-picker-open.png")
    # close by clicking current again or Escape
    page.keyboard.press("Escape")
    page.wait_for_timeout(150)

    # Cycle a few languages
    for loc in ("nl", "de", "fr", "ja", "zh", "ko", "pl", "ru", "es"):
        set_lang(page, loc)
        txt = current_play(page)
        play_eq(txt, PLAY[loc], f"Play in {loc} is {PLAY[loc]!r}, got {txt!r}")
        src = page.locator("#lang-current img").get_attribute("src") or ""
        check(FLAGS[loc] + ".svg" in src, f"current flag {loc} = {FLAGS[loc]}")
        no_overflow(page, f"desktop-{loc}")
        shot(page, f"t1141-desktop-menu-{loc}.png")

    # Persistence via localStorage
    set_lang(page, "nl")
    stored = page.evaluate("() => localStorage.getItem('meteors-locale')")
    check(stored == "nl", f"localStorage meteors-locale=nl, got {stored!r}")
    page.reload(wait_until="networkidle", timeout=20000)
    page.wait_for_selector("#btn-play", timeout=10000)
    page.wait_for_timeout(250)
    txt = current_play(page)
    play_eq(txt, "Spelen", f"after reload still Dutch, got {txt!r}")
    shot(page, "t1141-desktop-persist-nl.png")

    # Login: server locale wins if set; first login pushes local
    login(page, 1)
    # After login applyFromProfile: if server null, client keeps nl and syncs
    page.wait_for_timeout(500)
    txt = current_play(page)
    play_eq(txt, "Spelen", f"logged in keeps Dutch (or applies profile), got {txt!r}")
    # Switch to Japanese while logged in — should POST set_locale
    set_lang(page, "ja")
    txt = current_play(page)
    play_eq(txt, PLAY["ja"], f"logged-in Japanese Play, got {txt!r}")
    shot(page, "t1141-desktop-logged-in-ja.png")
    # New context: no localStorage, login should load ja from profile
    ctx2 = browser.new_context(viewport={"width": 1280, "height": 800}, device_scale_factor=1)
    p2 = ctx2.new_page()
    login(p2, 1)
    p2.wait_for_timeout(600)
    txt2 = current_play(p2)
    play_eq(txt2, PLAY["ja"], f"fresh context login applies server ja, got {txt2!r}")
    shot(p2, "t1141-desktop-relogin-ja.png")
    ctx2.close()
    ctx.close()


def run_mobile(browser):
    ctx = browser.new_context(**MOBILE)
    page = ctx.new_page()
    goto_fresh(page)
    play = current_play(page)
    play_eq(play, "Play", f"mobile default English, got {play!r}")
    no_overflow(page, "mobile-en")
    shot(page, "t1141-mobile-menu-en.png")

    page.locator("#lang-current").click()
    page.wait_for_selector("#lang-list:not([hidden])", timeout=4000)
    n = page.locator("#lang-list .lang-option").count()
    check(n == 10, f"mobile picker 10 flags, got {n}")
    # list should be on screen (opens upward)
    box = page.locator("#lang-list").bounding_box()
    vp = page.viewport_size
    if box:
        on = box["y"] >= -2 and box["y"] + box["height"] <= vp["height"] + 4
        check(on, f"mobile picker on-screen y={box['y']} h={box['height']} vp={vp['height']}")
    no_overflow(page, "mobile-picker-open")
    shot(page, "t1141-mobile-picker-open.png")
    page.keyboard.press("Escape")
    page.wait_for_timeout(150)

    for loc in ("nl", "de", "ja", "zh", "ru"):
        set_lang(page, loc)
        txt = current_play(page)
        play_eq(txt, PLAY[loc], f"mobile Play {loc} = {PLAY[loc]!r}, got {txt!r}")
        no_overflow(page, f"mobile-{loc}")
        shot(page, f"t1141-mobile-menu-{loc}.png")
    ctx.close()


def main():
    global URL
    port = free_port()
    URL = f"http://127.0.0.1:{port}/"
    data = Path(tempfile.mkdtemp(prefix="meteors-i18n-"))
    log_path = "/tmp/t1141-php.log"
    proc = start_php(port, data, log_path)
    print("PHP at", URL, "data", data)
    try:
        with sync_playwright() as p:
            browser = p.chromium.launch(executable_path=CHROME, args=CHROME_ARGS, headless=True)
            run_desktop(browser)
            run_mobile(browser)
            browser.close()
    finally:
        proc.terminate()
        try:
            proc.wait(timeout=3)
        except Exception:
            proc.kill()

    if FAILURES:
        print("\nFAILURES:")
        for f in FAILURES:
            print(" -", f)
        return 1
    print("\nALL OK")
    return 0


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