#!/usr/bin/env python3
"""Reproducer server for crbug.com/505481952.

PWA/TWA does not respect the HTTP cache of a `start_url` document on first
open. This server reproduces the reporter's exact setup:

  1. `/` (the PWA start_url) is served with
        Cache-Control: private, max-age=1209600
     and its inline <script> immediately calls location.reload().
  2. The FIRST request for `/` returns the "bootstrap" document (VERSION 1).
     Every subsequent request returns the "real" document (VERSION 2+),
     simulating "the reload refetches a different document".
  3. There are NO service workers involved.

On-device status (confirmed on Pixel 6a, Android 16, Chrome 149, unpatched):
the bug REPRODUCES at the HTTP cache layer. See the caveats below.

How to use (Android TWA / installed PWA is where the bug shows up):

  # 1. Run this on a machine reachable by the phone / test device.
  python3 repro_server.py --port 8000

  # 2a. Quickest on-device path (localhost is a secure origin):
  #     adb reverse tcp:8000 tcp:8000    -> phone sees http://localhost:8000
  #     CAVEAT: a real WebAPK cannot be minted against a localhost origin
  #     (Google's minting server must fetch the manifest from a public HTTPS
  #     URL). Chrome falls back to the legacy standalone webapp shortcut
  #     (ACTION_START_WEBAPP -> WebappLauncherActivity -> WebappActivity,
  #     webapp_display_mode=3). That is the same launch/caching family as
  #     TWA/WebAPK and it already reds -- but it is NOT a minted WebAPK.
  # 2b. To confirm on a canonical minted WebAPK, expose over public HTTPS:
  #     ngrok http 8000       (or any TLS reverse proxy)

  # 3. Open the URL, install it as a PWA / generate the TWA, launch it.
  #    - First open shows "VERSION 2" (the reloaded document). Good.
  #    - Force-stop Chrome, cold-launch the installed app again.

  ****  DO NOT trust the final screen  ****
  The VERSION 1 bootstrap self-heals via location.reload(), so a stale
  relaunch is MASKED back to VERSION 2 on screen. A screen-only check is
  unreliable. The real signal on relaunch is BOTH of:
     - exactly ONE network `GET /` is made, AND
     - sessionStorage.reloaded == 1   (i.e. the V1 bootstrap ran again)
  which together prove the launch read the stale V1 out of the HTTP cache.
  Truth table (relaunch):
     cache serves fresh V2 directly -> 0 GET, reloaded=null            (OK)
     cold network load of `/`       -> 1 GET V2, reloaded=null         (OK)
     cache serves stale V1, reloads -> 1 GET V2, reloaded=1  (BUG, observed)

  To make the staleness DIRECTLY VISIBLE (no masking), run with a reload
  delay so the stale V1 (red) is shown on screen before it self-heals:
     python3 repro_server.py --port 8000 --reload-delay 4000
  Confirmed screen-visible on device: a stale cold relaunch renders the red
  "VERSION 1 (stale bootstrap)" for the delay, byte-identical to the first-open
  V1 frame, then self-heals to V2. The ground-truth signal still holds
  (1 network GET / on relaunch AND sessionStorage.reloaded == 1).

  Icons: the manifest ships raster PNGs (/icon-192.png, /icon-512.png maskable)
  so a real WebAPK can mint. An SVG-only icons array always downgrades to the
  legacy standalone webapp shortcut (WebappActivity) on ANY origin, so a PNG
  must be present to exercise the canonical minted-WebAPK/TWA surface.
  Verified on device: with the PNGs, the Chrome menu shows "Install ..." (the
  WebAPK label) and a genuine package (org.chromium.webapk.*) mints.

  NOTE (device requirement for a TRUE minted WebAPK): installing the minted
  WebAPK is done by Play Services and requires a signed-in Google account
  (Settings > Passwords & accounts > Add account > Google). With 0 accounts,
  Finsky rejects the install ("WebAPK service unknown_account") and Chrome
  falls back to the legacy WebappActivity shortcut -- which still reds. Add an
  account, then re-install to exercise the canonical WebAPK path.

The server logs every request so you can see exactly which document Chrome
fetched from the network vs. served from its cache on relaunch.
"""

import argparse
import http.server
import itertools
import threading

_counter = itertools.count(1)
_lock = threading.Lock()
# Milliseconds to wait before the bootstrap self-reloads. 0 = immediate (masks
# the staleness); a few thousand ms makes a stale relaunch visible on screen.
RELOAD_DELAY_MS = 0

MANIFEST = """{
  "name": "Cache Repro 505481952",
  "short_name": "CacheRepro",
  "start_url": "/",
  "scope": "/",
  "display": "standalone",
  "background_color": "#121212",
  "theme_color": "#121212",
  "icons": [
    { "src": "/icon-192.png", "sizes": "192x192", "type": "image/png", "purpose": "any" },
    { "src": "/icon-512.png", "sizes": "512x512", "type": "image/png", "purpose": "maskable" },
    { "src": "/icon.svg", "sizes": "any", "type": "image/svg+xml", "purpose": "any" }
  ]
}"""

ICON = ('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 192 192">'
        '<rect width="192" height="192" fill="#121212"/>'
        '<text x="96" y="120" font-size="90" text-anchor="middle" '
        'fill="#FFC107" font-family="monospace">C</text></svg>')


def make_png(width, height, rgba):
    """Build a valid solid-color RGBA PNG in-process (no binary asset needed).

    A raster PNG is required for WebAPK minting; an SVG-only icons array always
    downgrades to the legacy standalone webapp shortcut on any origin.
    """
    import struct
    import zlib

    def chunk(typ, data):
        body = typ + data
        return (struct.pack(">I", len(data)) + body +
                struct.pack(">I", zlib.crc32(body) & 0xFFFFFFFF))

    sig = b"\x89PNG\r\n\x1a\n"
    ihdr = struct.pack(">IIBBBBB", width, height, 8, 6, 0, 0, 0)  # 8-bit RGBA
    row = bytes([0]) + bytes(rgba) * width  # filter byte 0 + pixels
    idat = zlib.compress(row * height, 9)
    return (sig + chunk(b"IHDR", ihdr) + chunk(b"IDAT", idat) +
            chunk(b"IEND", b""))


# Solid amber icons, generated once at import.
ICON_192 = make_png(192, 192, (255, 193, 7, 255))
ICON_512 = make_png(512, 512, (255, 193, 7, 255))

def bootstrap_html(delay_ms):
    # The bootstrap sets sessionStorage.reloaded (the on-relaunch signal) and
    # then reloads -- immediately, or after `delay_ms` so the staleness is
    # visible on screen first.
    reload_js = (
        "setTimeout(function(){ location.reload(); }, %d);" % delay_ms
        if delay_ms > 0
        else "location.reload();"
    )
    return """<!doctype html>
<html><head><meta charset="utf-8">
<link rel="manifest" href="/manifest.webmanifest">
<meta name="theme-color" content="#121212">
<title>Cache Repro</title></head>
<body style="background:#121212;color:#D35F5F;font-family:monospace">
<h1>VERSION 1 (stale bootstrap)</h1>
<p>If you see this after closing and reopening the installed app, the stale
   start_url was served from the HTTP cache. It self-heals on reload.</p>
<script>
  // Reporter's repro: the start_url document reloads itself to a different doc.
  if (!sessionStorage.getItem('reloaded')) {
    sessionStorage.setItem('reloaded', '1');
    %s
  }
</script>
</body></html>""" % reload_js

REAL = """<!doctype html>
<html><head><meta charset="utf-8">
<link rel="manifest" href="/manifest.webmanifest">
<meta name="theme-color" content="#121212">
<title>Cache Repro</title></head>
<body style="background:#121212;color:#6abf69;font-family:monospace">
<h1>VERSION 2 (real document)</h1>
<p>If you see VERSION 1 after closing and reopening the installed app,
   the HTTP cache was not respected on relaunch.</p>
</body></html>"""


class Handler(http.server.BaseHTTPRequestHandler):
    def _send(self, body, ctype, cache=None):
        data = body if isinstance(body, bytes) else body.encode("utf-8")
        self.send_response(200)
        self.send_header("Content-Type", ctype)
        self.send_header("Content-Length", str(len(data)))
        if cache:
            self.send_header("Cache-Control", cache)
        self.end_headers()
        self.wfile.write(data)

    def do_GET(self):
        path = self.path.split("?", 1)[0]
        if path == "/manifest.webmanifest":
            self._send(MANIFEST, "application/manifest+json")
            return
        if path == "/icon.svg":
            self._send(ICON, "image/svg+xml")
            return
        if path == "/icon-192.png":
            self._send(ICON_192, "image/png", cache="public, max-age=86400")
            return
        if path == "/icon-512.png":
            self._send(ICON_512, "image/png", cache="public, max-age=86400")
            return
        if path == "/":
            with _lock:
                n = next(_counter)
            body = bootstrap_html(RELOAD_DELAY_MS) if n == 1 else REAL
            # Exactly the header from the bug report.
            self._send(body, "text/html", cache="private, max-age=1209600")
            self.log_message("served start_url request #%d -> %s", n,
                             "VERSION 1" if n == 1 else "VERSION 2")
            return
        self.send_error(404)


def main():
    global RELOAD_DELAY_MS
    ap = argparse.ArgumentParser()
    ap.add_argument("--port", type=int, default=8000)
    ap.add_argument("--reload-delay", type=int, default=0,
                    help="ms the stale V1 bootstrap waits before self-reloading "
                         "(use >0 to make a stale relaunch visible on screen)")
    args = ap.parse_args()
    RELOAD_DELAY_MS = args.reload_delay
    httpd = http.server.ThreadingHTTPServer(("0.0.0.0", args.port), Handler)
    print("Reproducer for crbug.com/505481952 on port %d" % args.port)
    print("Serve over HTTPS (or adb reverse to localhost) to install as PWA.")
    print("Reload delay: %d ms" % RELOAD_DELAY_MS)
    print("Real signal on relaunch: 1 network GET / AND "
          "sessionStorage.reloaded == 1 => stale (bug).")
    httpd.serve_forever()


if __name__ == "__main__":
    main()