// cce-ctl — IPC client for cce
  
 use std::env;
 use std::io::{Read, Write};
 use std::os::unix::net::UnixStream;
 use std::process;
  
 fn get_socket_path() -> String {
     match env::var("WAYLAND_DISPLAY") {
         Ok(display) => format!("/tmp/cce-{}.sock", display),
         Err(_) => "/tmp/cce.sock".to_string(),
     }
 }
  
 #[allow(dead_code)]
 fn get_windows_path() -> String {
     match env::var("WAYLAND_DISPLAY") {
         Ok(display) => format!("/tmp/cce-windows-{}", display),
         Err(_) => "/tmp/cce-windows".to_string(),
     }
 }
  
 fn usage(name: &str, to_stderr: bool) {
     let print = |s: &str| {
         if to_stderr {
             eprintln!("{}", s);
         } else {
             println!("{}", s);
         }
     };
     print(&format!("usage: {} <command> [args...]", name));
     print("");
     print("commands:");
     print("  layout <gap|gap_top|gap_left|gap_right|gap_bottom|offset|grid_gap|bar_height> <value>");
     print("  close");
     print("  minimize");
     print("  focus-next");
     print("  focus-prev");
     print("  focus-up | focus-down | focus-left | focus-right");
     print("  window-switcher            # open the alt-tab window switcher (cce-cloud overlay)");
     print("  fullscreen");
     print("  mode-next");
     print("  mode-next-shared");
     print("  set-mode <floating|tiled|fullscreen> [app_id|id]  # set a window's mode (focused if omitted)");
     print("  zoom-in");
     print("  zoom-out");
     print("  zoom-reset");
     print("  pan-left");
     print("  pan-right");
     print("  pan-up");
     print("  pan-down");
     print("  overlay-left");
     print("  overlay-right");
     print("  focus-window [--no-wait] <app_id|id>  # focus and raise; replies once the window");
     print("                              # stops moving (a pan into view), 3s at most");
     print("  close-window <app_id|id> [title-substring]  # close a specific window");
     print("  center-window [<app_id>]   # pan focused/named window on-screen; replies x= y= w= h=");
     print("  move-window <square> [<app_id>] # put focused/named window on a desktop square (e.g. C-9)");
     print("  resize-window <w> <h> [<app_id|id>] # set focused/named window's size (logical px),");
     print("                              # top-left fixed, clamped to its min/max hints");
     print("  min-size [list]            # X11 minimum sizes learned from refusals (X11 px), numbered");
     print("  min-size forget <app_id|id> # drop an open X11 window's learned minimum (relearned on refusal)");
     print("  min-size forget-entry <n>  # drop stored entry n from `min-size list`");
     print("  move-window-left|-right|-up|-down    # step the focused window one grid cell;");
     print("                              # tiled swaps with the tiled window already there,");
     print("                              # floating just moves");
     print("  place-next <app_id> <x> <y> # one-shot: next map of app_id lands near this layout pos");
     print("  place-next-cell <app_id> <x> <y> # one-shot: next map covers the grid square at this pos,");
     print("                              # keeping its size and growing away from its neighbours");
     print("  overview                   # toggle; the exit lands on the focused window, not the pointer");
     print("  windows [--json]           # list windows; --json emits one JSON object per line");
     print("  outputs [--json]           # list outputs: mode, scale, logical size, physical mm, px/mm, and where the mm came from");
     print("  idle [status]              # idle timeouts in force, idle time, inhibited and by whom (app ids), displays_off/sleeping, and the power plan's override of each (plan_*)");
     print("  idle wake|sleep|display on|display off   # act now: wake darkened outputs, lock, then run the sleep command; darken/wake outputs");
     print("  idle timeouts <display_off_s> <sleep_s>  # set the config timeouts live (0 = off); config.kdl `idle { }` on reload; a Power-plan file under /run/cce overrides either while it exists");
     print("  idle inhibit <token> <ttl_s> <who>  # hold the idle timers off for a holder with no surface (cce-desktop-portal: portal Inhibit, org.freedesktop.ScreenSaver); lapses after ttl_s (1-600) unless renewed");
     print("  idle uninhibit <token> | idle inhibit-clear  # end one lease now / drop every lease");
     print("  lock                       # lock the session now (cce-lock takes the prompt); replies `ok locked` once every output shows the locked scene");
     print("  status-hide-mode [true|false]");
     print("  adjust-position-mode [true|false|query]");
     print("  exit [force]               # log out; waits for windows to close, cancels if one stays (a save prompt); force skips the wait");
     print("  restart");
     print("  restart-compositor        # exit cleanly; cce-display-manager relaunches the session");
     print("  reload");
     print("  repeat [<rate> <delay>]    # key repeat for hardware keyboards: repeats/s (0 = off), ms before the first; until the next config load. No args prints it");
     print("  input <device_name|*> scroll-factor <value>");
     print("  config-done");
     print("  spawn <command>");
     print("  screenshot                          # capture the screen to ~/Pictures/screenshots");
     print("  screenshot region <x> <y> <w> <h>   # capture an on-screen region (logical px)");
     print("  screenshot window [app_id|id]       # capture a window (focused if omitted; works off-screen)");
     print("  debug-buffers [app_id|id]           # dump a window's scene buffers (pos/dest/natural/surface)");
     print("  notify <title> [body]");
     print("  bind <mods> <keysym> <action> [args...]");
     print("  pbind <mods> <button> <action>");
     print("  retile");
     print("  mode <floating|tiled|fullscreen|popup|overlay> <app_id> [title]");
     print("  pointer-location");
     print("  camera                             (pan, zoom, and the pan target being eased to)");
     print("  selection                          (overview drag-selection: window ids, image ids, band)");
     print("  pointer-move-to <x> <y>            (layout pixels)");
     print("  pointer-move-by <dx> <dy>");
     print("  pointer-scroll <dy> [dx] [finger] [natural]");
     print("                                     (positive dy scrolls down; 15 = one notch; finger = a");
     print("                                      two-finger swipe, ended by finger-stop; natural = from");
     print("                                      a natural-scrolling touchpad, deltas already flipped)");
     print("  pointer-scroll finger-stop");
     print("  pointer-swipe <fingers> <dx> <dy> [steps] | begin <fingers> | update <dx> <dy> | end");
     print("                                     (a 3/4-finger touchpad swipe; drives input.kdl gesture");
     print("                                      chords such as focus_left \"swipe3_left\"; the staged");
     print("                                      form holds a swipe short of its threshold)");
     print("  pointer-pinch <scale> [rotation] [steps] | begin | update <scale> [rotation] | end");
     print("  touchpad-view-regions <x11:ID|id|app_id> clear | <x,y,w,h> ...");
     print("                                     (limit a touchpad_view_apps drag to these window-local");
     print("                                      rects; a swipe elsewhere scrolls the app normally)");
     print("  pointer-click [button]             (left|right|middle|back|forward or evdev code)");
     print("  pointer-press [button]             (held until pointer-release — drives drags)");
     print("  pointer-release [button]");
     print("  touch down <id> <x> <y> | motion <id> <x> <y> | up <id> | cancel <id> | tap <x> <y>");
     print("                                     (a touchscreen finger, layout pixels; a client that");
     print("                                      bound wl_touch gets touch, anything else the pointer)");
     print("  migrate-input                      (local: move config.kdl keybindings to input.kdl)");
     print("  keypress <keycode>                 (evdev code; press+release to the focused client)");
     print("  key-down <keycode>                 (modifier codes — ctrl 29/97, shift 42/54,");
     print("  key-up <keycode>                    alt 56/100, super 125/126 — update client");
     print("                                      xkb state, so e.g. 29+36 lands as ctrl+j)");
     print("  shortcut bind <session> <id> <trigger>   (portal GlobalShortcuts backend: CTRL+SHIFT+space)");
     print("  shortcut unbind <session> [<id>] | clear | list");
 }
  
 /// The line sent for `args` (the command and its arguments). `focus-window`
 /// waits for the window to settle unless told `--no-wait`: focusing can pan
 /// the window into view, and a script's next pointer command would
 /// otherwise land where the window was mid-flight. Apps reach the
 /// compositor directly and keep the immediate reply.
 fn command_line(args: &[String]) -> String {
     let mut args: Vec<&str> = args.iter().map(String::as_str).collect();
     if args.first() == Some(&"focus-window") {
         match args.get(1) {
             Some(&"--no-wait") => {
                 args.remove(1);
             }
             Some(&"--wait") => {}
             _ => args.insert(1, "--wait"),
         }
     }
     args.join(" ") + "\n"
 }
 
 pub fn run_cce_ctl(args: Vec<String>) {
     if args.len() < 2 {
         usage(&args[0], true);
         process::exit(1);
     }
  
     if args[1] == "--help" || args[1] == "-h" || args[1] == "help" {
         usage(&args[0], false);
         return;
     }
 
     // Local file operation — no compositor needed.
     if args[1] == "migrate-input" {
         crate::migrate_input::run();
         return;
     }
  
  
     // Connect to IPC socket
     let stream = match UnixStream::connect(get_socket_path()) {
         Ok(s) => s,
         Err(e) => {
             eprintln!("connect: {}", e);
             process::exit(1);
         }
     };
  
     let mut stream = stream;
     // Build command string from args
     let cmd = command_line(&args[1..]);
     if let Err(e) = stream.write_all(cmd.as_bytes()) {
         eprintln!("write: {}", e);
         process::exit(1);
     }
  
     // Read response
     let mut buf = [0u8; 4096];
     loop {
         match stream.read(&mut buf) {
             Ok(0) => break,
             Ok(n) => {
                 let s = String::from_utf8_lossy(&buf[..n]);
                 print!("{}", s);
             }
             Err(e) => {
                 eprintln!("read: {}", e);
                 break;
             }
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::command_line;
 
     fn line(args: &[&str]) -> String {
         command_line(&args.iter().map(|s| s.to_string()).collect::<Vec<_>>())
     }
 
     #[test]
     fn focus_window_waits_unless_told_not_to() {
         assert_eq!(line(&["focus-window", "cce-fonts"]), "focus-window --wait cce-fonts\n");
         assert_eq!(line(&["focus-window", "--wait", "12"]), "focus-window --wait 12\n");
         assert_eq!(line(&["focus-window", "--no-wait", "cce-fonts"]), "focus-window cce-fonts\n");
         assert_eq!(line(&["windows", "--json"]), "windows --json\n");
     }
 }