"""Tell the compositor where Houdini's view panes are.
 
 Under Xwayland a two-finger swipe never reaches Houdini as a trackpad
 gesture (Qt's X11 backend leaves the pixel deltas empty), so ``cce-fx``
 emulates the view tool instead: for every app in its ``touchpad_view_apps``
 it turns a swipe into a Space + button drag on the window. That is right
 over a 3D viewport or a network editor and wrong everywhere else -- the
 parameter editor, the geometry spreadsheet and every other pane want the
 swipe as the plain scroll it was, and got nothing at all.
 
 So this module publishes the rectangles of the panes that want the drag,
 per top-level window, through ``ccectl touchpad-view-regions``. The
 compositor confines the drag to them and passes a swipe anywhere else
 through untouched. Rectangles are window-local pixels as Houdini measures
 them, which for an X11 window under ``xwayland_hidpi`` are exactly the
 compositor's surface coordinates; the window is named by its X11 id, the
 one identifier the two sides share.
 
 The poll runs on Houdini's event loop and only talks to the compositor
 when a rectangle changed, so its steady-state cost is a few HOM calls
 every quarter second. Without ``ccectl`` on ``PATH`` (or a compositor
 that does not know the command) it is inert: every publish is
 fire-and-forget and errors are dropped.
 
 Fire-and-forget still has to reap. ``ccectl`` answers in ten milliseconds,
 but a child nobody waits on stays a zombie under houdini-bin until
 something calls ``waitpid`` -- and CPython only does that for a dropped
 ``Popen`` when the *next* ``Popen`` is made, which here is the next
 rectangle change, minutes later. So publishes are kept and polled on the
 tick (never waited on: the main thread must not block on the compositor's
 socket), and one that outlives ``PUBLISH_TIMEOUT`` is killed rather than
 left to pile up behind a stuck compositor.
 """
 import shutil
 import subprocess
 import time
 
 import hou
 
 #: Pane tab types that want the emulated view drag. Everything else gets
 #: the swipe as a scroll.
 VIEW_TAB_TYPES = ("SceneViewer", "NetworkEditor")
 #: Seconds between polls of the pane layout.
 POLL_INTERVAL = 0.25
 #: Seconds a ``ccectl`` child may run before it is killed. It normally
 #: returns in ten milliseconds; this only matters with a hung compositor.
 PUBLISH_TIMEOUT = 5.0
 #: Where the running callback is kept, so a reload can find and remove the
 #: one installed by the module it is replacing (see ``HCSession.reloadHC``).
 _SESSION_ATTR = "_hc_view_regions_callback"
 
 
 def ccectl():
     """Path of the compositor control client, or None when there is none."""
     return shutil.which("ccectl")
 
 
 #: Seconds to wait on the two ``ccectl`` calls a pointer move makes. These
 #: are waited on, unlike the region publishes: the caller wants the pointer
 #: moved before it returns, and the alternative is a warp nobody sees.
 POINTER_TIMEOUT = 1.0
 
 
 def move_pointer(point):
     """Put the pointer at a Qt global ``point``, and say whether it moved.
 
     ``QCursor.setPos`` is not enough under Xwayland: it moves X's idea of the
     pointer, so Qt and ``hou.ui.paneUnderCursor`` both report the new spot,
     but the cursor on screen stays where it was and the next real motion
     snaps X back to it. Only the compositor moves the one the user sees, so
     this goes through ``ccectl pointer-move-to`` when there is a compositor,
     and falls back to the X warp otherwise.
 
     ``ccectl`` speaks layout pixels, and the compositor pans the desktop
     under Houdini, so the window's layout position is read fresh each time
     from ``ccectl windows --json`` (one line per window, ``x11`` carrying
     the X window id). The scale between the two coordinate spaces is the
     window's Qt width over its layout width.
     """
     from PySide6.QtGui import QCursor
     exe = ccectl()
     if exe is None or not _move_pointer_via_compositor(exe, point):
         QCursor.setPos(point)
         return False
     return True
 
 
 def _move_pointer_via_compositor(exe, point):
     import json
     widget = _window_at(point)
     if widget is None:
         return False
     try:
         listing = subprocess.run(
             [exe, "windows", "--json"], stdin=subprocess.DEVNULL,
             capture_output=True, text=True, timeout=POINTER_TIMEOUT)
     except (OSError, subprocess.SubprocessError):
         return False
     win_id = int(widget.winId())
     entry = None
     for line in listing.stdout.splitlines():
         try:
             data = json.loads(line)
         except ValueError:
             continue
         if data.get("x11") == win_id:
             entry = data
             break
     if entry is None or not entry.get("w"):
         return False
     origin = widget.geometry().topLeft()
     scale = widget.geometry().width() / float(entry["w"])
     x = entry["x"] + (point.x() - origin.x()) / scale
     y = entry["y"] + (point.y() - origin.y()) / scale
     try:
         done = subprocess.run(
             [exe, "pointer-move-to", f"{x:.1f}", f"{y:.1f}"],
             stdin=subprocess.DEVNULL, capture_output=True,
             timeout=POINTER_TIMEOUT)
     except (OSError, subprocess.SubprocessError):
         return False
     return done.returncode == 0
 
 
 def _window_at(point):
     """The process's toplevel widget whose frame holds ``point``, or None."""
     for widget in HCViewRegions.windows():
         if widget.frameGeometry().contains(point):
             return widget
     return None
 
 
 def stop():
     """Remove the poll installed by any earlier ``HCViewRegions.start``."""
     cb = getattr(hou.session, _SESSION_ATTR, None)
     if cb is None:
         return
     try:
         hou.ui.removeEventLoopCallback(cb)
     except Exception:
         pass
     setattr(hou.session, _SESSION_ATTR, None)
 
 
 class HCViewRegions:
     """Publishes the view-pane rectangles of every Houdini window."""
 
     def __init__(self):
         self._exe = ccectl()
         self._last = {}
         self._next = 0.0
         #: ``[(Popen, monotonic start), ...]`` of publishes not yet reaped.
         self._pending = []
 
     def start(self):
         """Install the poll; a no-op without ``ccectl``. Returns whether it ran."""
         stop()
         if not self._exe:
             return False
         self._last = {}
         hou.ui.addEventLoopCallback(self._tick)
         setattr(hou.session, _SESSION_ATTR, self._tick)
         return True
 
     def _tick(self):
         now = time.monotonic()
         if now < self._next:
             return
         self._next = now + POLL_INTERVAL
         self.reap(now)
         try:
             regions = self.collect()
         except Exception:
             # A pane mid-teardown can raise from any of the calls below; the
             # next tick sees a settled layout.
             return
         for win_id, rects in regions.items():
             if self._last.get(win_id) != rects:
                 self.publish(win_id, rects)
         # A window that has gone is forgotten by the compositor with it;
         # nothing to send.
         self._last = regions
 
     def collect(self):
         """``{x11 window id: [(x, y, w, h), ...]}`` for every visible window.
 
         Rectangles are in the window's own pixels. Every toplevel the process
         shows is listed, most with no rectangles at all: the compositor
         gives a window it has heard nothing about the whole-window drag, and
         the HC Panel, HC Status, a floating settings tab and every dialog are
         separate X11 windows of the same app -- so a swipe over any of them
         was a drag too, and a list only selected the row under the pointer
         instead of scrolling. Popups and tooltips are skipped; they come and
         go faster than the poll.
         """
         out = {}
         for widget in self.windows():
             out[int(widget.winId())] = []
         for tab in hou.ui.paneTabs():
             if tab.type().name() not in VIEW_TAB_TYPES or not tab.isCurrentTab():
                 continue
             panel = tab.pane().floatingPanel()
             widget = hou.qt.floatingPanelWindow(panel) if panel else hou.qt.mainWindow()
             widget = widget.window()
             if not widget.isVisible():
                 continue
             g = tab.qtScreenGeometry()
             origin = widget.geometry().topLeft()
             out.setdefault(int(widget.winId()), []).append(
                 (g.x() - origin.x(), g.y() - origin.y(), g.width(), g.height()))
         return {k: sorted(v) for k, v in out.items()}
 
     @staticmethod
     def windows():
         """The process's visible toplevel windows, popups and tooltips aside."""
         from PySide6.QtCore import Qt
         from PySide6.QtWidgets import QApplication
         skip = (Qt.Popup, Qt.ToolTip, Qt.SplashScreen)
         found = []
         for widget in QApplication.topLevelWidgets():
             if not widget.isVisible() or widget.windowHandle() is None:
                 continue
             if widget.windowFlags() & Qt.WindowType_Mask in skip:
                 continue
             # Houdini keeps some fifty 0x0 placeholder toplevels "visible";
             # nothing can be swiped over them.
             if widget.width() <= 0 or widget.height() <= 0:
                 continue
             found.append(widget)
         return found
 
     @staticmethod
     def wire(rects):
         """The rectangle arguments for one window.
 
         No rectangles has to mean "drag nowhere", and the compositor's
         ``clear`` word means the opposite -- back to the whole window. A
         rectangle of no area is inside nothing (the test is half-open), so
         it is the wire form of an empty list.
         """
         if not rects:
             return ["0,0,0,0"]
         return [",".join(str(int(v)) for v in r) for r in rects]
 
     def publish(self, win_id, rects):
         """Start one ``ccectl`` call; it is reaped by a later ``reap``."""
         args = [self._exe, "touchpad-view-regions", f"x11:{win_id}"] + self.wire(rects)
         try:
             proc = subprocess.Popen(
                 args, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
                 stderr=subprocess.DEVNULL)
         except OSError:
             return
         self._pending.append((proc, time.monotonic()))
 
     def reap(self, now=None):
         """Collect finished publishes without blocking; kill the overdue.
 
         ``poll`` is a ``waitpid(WNOHANG)``, so a finished child is gone
         from the process table after this and a running one is left alone.
         A killed child is still running as far as this call is concerned
         and is collected on the next one. Returns how many are still out.
         """
         if now is None:
             now = time.monotonic()
         keep = []
         for proc, started in self._pending:
             if proc.poll() is not None:
                 continue
             if now - started > PUBLISH_TIMEOUT:
                 try:
                     proc.kill()
                 except OSError:
                     pass
             keep.append((proc, started))
         self._pending = keep
         return len(keep)