#!/usr/bin/env python3
"""Interactive XIE 2.3 probe against the VT1200.

Keeps one X11 connection so the per-client XIE session state is preserved.
Usage:
  ./probe23.py session
  ./probe23.py defaults
  ./probe23.py raw <minor> <word0> [word1 ...]
  ./probe23.py create7 <id> <class>
  ./probe23.py sweep <id>
  ./probe23.py seq ...        # reserved for the client sequence
"""

import os
import struct
import sys
import socket
import time

HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.join(HERE, "evidence"))
import xie_raw as X  # noqa: E402


class Cli:
    def __init__(self, host=X.HOST, port=X.PORT, timeout=0.8):
        self.sock = socket.create_connection((host, port), timeout=5)
        self.sock.settimeout(timeout)
        X.setup(self.sock)
        present, self.opcode, self.first_event, self.first_error = X.query_extension(
            self.sock, "Xie"
        )
        if not present:
            raise SystemExit("Xie not present")
        self.seq = 2  # setup + QueryExtension
        self.id_base = X.LAST_SETUP.get("id_base", 0x00C00000)
        self.id_mask = X.LAST_SETUP.get("id_mask", 0x000FFFFF)
        self.root = X.LAST_SETUP.get("root", 0x8006B)
        self.sw = X.LAST_SETUP.get("screen_width", 0)
        self.sh = X.LAST_SETUP.get("screen_height", 0)

    def new_id(self, n=0x0AAAA):
        """A legal client resource id for this connection."""
        return (self.id_base | (n & self.id_mask)) & 0xFFFFFFFF

    def create_window(self, wid, w, h, x=10, y=10):
        """Core X CreateWindow (InputOutput, CopyFromParent depth/visual)."""
        body = struct.pack("<IIhhhhHHII", wid, self.root, x, y, w, h, 0, 1, 0, 0)
        self.sock.sendall(struct.pack("<BBH", 1, 0, 8) + body)

    def map_window(self, wid):
        self.sock.sendall(struct.pack("<BBHI", 8, 0, 2, wid))

    def create_pixmap(self, pid, w, h, depth=1):
        self.sock.sendall(struct.pack("<BBHIIHH", 53, depth, 4, pid, self.root, w, h))

    def send(self, minor, words, payload=b"", timeout=0.8):
        """Send one XIE request. `words` is the total request length in words."""
        assert len(payload) <= (words - 1) * 4, (minor, words, len(payload))
        data = payload.ljust((words - 1) * 4, b"\0")
        req = struct.pack("<BBH", self.opcode, minor, words) + data
        self.sock.sendall(req)
        packets = []
        deadline = time.monotonic() + timeout
        while time.monotonic() < deadline:
            self.sock.settimeout(max(0.01, deadline - time.monotonic()))
            try:
                kind, head, extra = X.read_packet(self.sock)
            except socket.timeout:
                break
            if kind == 1:
                packets.append(("REPLY", head, extra))
            elif kind == 0:
                packets.append(("ERROR", head, None))
            else:
                packets.append(("EVENT", head, None))
            # keep draining briefly in case the server emits a second error
            deadline = time.monotonic() + 0.15
        return packets

    def close(self):
        try:
            self.sock.close()
        except OSError:
            pass


def describe_all(rs):
    if not rs:
        return "NO PACKETS (success or ignored)"
    return " | ".join(describe(r) for r in rs)


def describe(r):
    kind, head, extra = r
    if kind == "NOREPLY":
        return "NO REPLY (success or ignored)"
    if kind == "REPLY":
        length = struct.unpack("<I", head[4:8])[0]
        return f"REPLY len={length}  {head.hex()}" + (f" +{len(extra)}B" if extra else "")
    if kind == "ERROR":
        code = head[1]
        bad = struct.unpack("<I", head[4:8])[0]
        minor = struct.unpack("<H", head[8:10])[0]
        major = head[10]
        return f"ERROR code={code} bad={bad:#x} minor_op={minor} major_op={major}"
    return f"EVENT type={head[0]}"


def session(c):
    print("extension opcode=%d first_event=%d" % (c.opcode, c.first_event))
    r = c.send(1, 2, struct.pack("<HH", 2, 3))
    print("init   (1,2w):", describe_all(r))
    return r


def defaults(c):
    r = c.send(4, 2, struct.pack("<I", 0x10))
    print("setdef (4,2w,0x10):", describe_all(r))
    r = c.send(3, 2, b"")
    print("qrydef (3,2w):", describe_all(r))
    return r


def create7(c, ident, cls):
    r = c.send(7, 4, struct.pack("<III", 1, ident, cls))
    print("create7 (7,4w op=1 id=%#x class=%#x):" % (ident, cls), describe_all(r))
    return r


def sweep(c, ident, cls=0xFFFF):
    # queries first, destructive-looking slots last
    plan = [
        (24, 4, [ident, 0, 0]),
        (33, 4, [ident, cls, 0]),
        (40, 4, [ident, cls, 0]),
        (44, 5, [ident, cls, 0, 0]),
        (11, 3, [ident, 0]),
        (13, 2, [ident]),
        (14, 4, [ident, 0, 0]),
        (15, 3, [ident, 0]),
        (12, 2, [ident]),
        (22, 2, [ident]),
    ]
    for minor, words, payload in plan:
        data = b"".join(struct.pack("<I", w) for w in payload)
        r = c.send(minor, words, data)
        print(f"slot {minor:2d} ({words}w id={ident:#x}):", describe_all(r))


def demo_export(c, seconds=10):
    """Create an exportable 2.3 image resource and export it into a window."""
    ID = c.new_id(0x0AAAA)
    w = [2, ID, 64, 64, 0, 0, 2, 0, 0, 0x00000100, 0]
    print("create:", describe_all(c.send(8, 12, b"".join(struct.pack("<I", x) for x in w))))
    wid = c.new_id(0x0BBBB)
    c.create_window(wid, 64, 64)
    c.map_window(wid)
    gcid = c.new_id(0x0CCCC)
    c.sock.sendall(struct.pack("<BBHIII", 55, 0, 4, gcid, wid, 0))
    time.sleep(0.2)
    ew = [0] * 15
    ew[0] = ID
    ew[1] = wid
    ew[2] = gcid
    ew[3] = 0
    ew[4] = 0
    ew[5] = 64
    ew[6] = 64
    ew[7] = 64
    ew[8] = 64
    print("export:", describe_all(c.send(21, 16, b"".join(struct.pack("<I", x) for x in ew), timeout=1.0)))
    print("window %#x up for %d s; image buffer is empty (PUT_TILE still blocked)" % (wid, seconds))
    time.sleep(seconds)


def raw(c, minor, words):
    payload = b"".join(struct.pack("<I", w & 0xFFFFFFFF) for w in words)
    r = c.send(minor, 1 + len(words), payload)
    print(f"raw {minor} {words}:", describe_all(r))


def main(argv):
    if len(argv) < 2:
        raise SystemExit(__doc__)
    c = Cli()
    try:
        cmd = argv[1]
        if cmd == "ids":
            print("id_base=%#x id_mask=%#x next_id=%#x" % (c.id_base, c.id_mask, c.new_id()))
        elif cmd == "session":
            session(c)
        elif cmd == "defaults":
            session(c)
            defaults(c)
        elif cmd == "create7":
            ident = int(argv[2], 0)
            cls = int(argv[3], 0) if len(argv) > 3 else 0xFFFF
            session(c)
            create7(c, ident, cls)
        elif cmd == "sweep":
            ident = int(argv[2], 0)
            cls = int(argv[3], 0) if len(argv) > 3 else 0xFFFF
            session(c)
            sweep(c, ident, cls)
        elif cmd == "cs7":
            ident = int(argv[2], 0)
            cls = int(argv[3], 0) if len(argv) > 3 else 0xFFFF
            session(c)
            create7(c, ident, cls)
            sweep(c, ident, cls)
        elif cmd == "export":
            session(c)
            demo_export(c, int(argv[2]) if len(argv) > 2 else 10)
        elif cmd == "raw":
            minor = int(argv[2], 0)
            words = [int(w, 0) for w in argv[3:]]
            session(c)
            raw(c, minor, words)
        else:
            raise SystemExit(__doc__)
    finally:
        c.close()


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