use anyhow::{anyhow, Context, Result};
use regex::Regex;
use std::collections::{BTreeSet, HashMap};
use std::env;
use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;
use which::which;

mod ui_utils;
use ui_utils::{checklist, inputbox, menu, msgbox};

fn have(cmd: &str) -> bool {
    which(cmd).is_ok()
}

fn discover_connectors() -> Vec<String> {
    let mut found = BTreeSet::new();
    let re = Regex::new(r"\b(HDMI|DP|eDP|VGA|DVI|USB-C)(-[0-9]+)\b").unwrap();
    if have("gnome-monitor-config") {
        if let Ok(out) = Command::new("gnome-monitor-config").arg("list").output() {
            let s = String::from_utf8_lossy(&out.stdout);
            for cap in re.captures_iter(&s) {
                found.insert(cap.get(0).unwrap().as_str().to_string());
            }
        }
    }
    if found.is_empty() && have("xrandr") {
        if let Ok(out) = Command::new("xrandr").arg("--listmonitors").output() {
            let s = String::from_utf8_lossy(&out.stdout);
            for cap in re.captures_iter(&s) {
                found.insert(cap.get(0).unwrap().as_str().to_string());
            }
        }
    }
    if found.is_empty() {
        let manual = inputbox(
            "Enter connector names (space-separated):",
            "DP-3 DP-10 eDP-1",
        )
        .unwrap_or_default();
        for t in manual.split_whitespace() {
            found.insert(t.to_string());
        }
    }
    found.into_iter().collect()
}

fn describe_connector(conn: &str) -> String {
    if have("xrandr") {
        if let Ok(out) = Command::new("xrandr").arg("--query").output() {
            let s = String::from_utf8_lossy(&out.stdout);
            for line in s.lines() {
                if line.starts_with(conn) {
                    let status = line.split_whitespace().nth(1).unwrap_or("");
                    let primary = if line.contains(" primary ") {
                        " primary"
                    } else {
                        ""
                    };
                    let re = Regex::new(r"[0-9]{3,}x[0-9]{3,}\+[0-9]+\+[0-9]+").unwrap();
                    let respos = re
                        .find(line)
                        .map(|m| format!(" {}", m.as_str()))
                        .unwrap_or_default();
                    let mut desc = format!("[{}{}{}]", status, primary, respos);
                    if conn.starts_with("eDP-") {
                        desc.push_str(" internal");
                    }
                    return desc;
                }
            }
        }
    }
    if have("gnome-monitor-config") {
        if let Ok(out) = Command::new("gnome-monitor-config").arg("list").output() {
            let s = String::from_utf8_lossy(&out.stdout);
            if s.contains(conn) {
                let re = Regex::new(r"[0-9]{3,}x[0-9]{3,}@?[0-9.]*").unwrap();
                let wh = re.find(&s).map(|m| m.as_str().to_string());
                let mut desc = match wh {
                    Some(w) => format!("[present {}]", w),
                    None => "[present]".to_string(),
                };
                if conn.starts_with("eDP-") {
                    desc.push_str(" internal");
                }
                return desc;
            }
        }
    }
    let mut desc = "[present]".to_string();
    if conn.starts_with("eDP-") {
        desc.push_str(" internal");
    }
    desc
}

// Detect current resolution (width, height) for a connector, best-effort.
fn connector_size(conn: &str) -> Option<(i32, i32)> {
    // Try xrandr first (has precise current mode with +pos)
    if have("xrandr") {
        if let Ok(out) = Command::new("xrandr").arg("--query").output() {
            let s = String::from_utf8_lossy(&out.stdout);
            for line in s.lines() {
                if line.starts_with(conn) {
                    let re = Regex::new(r"([0-9]{3,})x([0-9]{3,})").ok()?;
                    if let Some(c) = re.captures(line) {
                        let w: i32 = c.get(1)?.as_str().parse().ok()?;
                        let h: i32 = c.get(2)?.as_str().parse().ok()?;
                        return Some((w, h));
                    }
                }
            }
        }
    }
    // Fallback: parse gnome-monitor-config list near the connector name
    if have("gnome-monitor-config") {
        if let Ok(out) = Command::new("gnome-monitor-config").arg("list").output() {
            let s = String::from_utf8_lossy(&out.stdout);
            if let Some(idx) = s.find(conn) {
                let end = (idx + 200).min(s.len());
                let window = &s[idx..end];
                if let Some(c) = Regex::new(r"([0-9]{3,})x([0-9]{3,})")
                    .ok()
                    .and_then(|re| re.captures(window))
                {
                    let w: i32 = c.get(1)?.as_str().parse().ok()?;
                    let h: i32 = c.get(2)?.as_str().parse().ok()?;
                    return Some((w, h));
                }
            }
        }
    }
    None
}

fn group_size(conns: &[String]) -> (i32, i32) {
    let mut max_w = 1920i32;
    let mut max_h = 1080i32;
    for c in conns {
        if let Some((w, h)) = connector_size(c) {
            if w > max_w {
                max_w = w;
            }
            if h > max_h {
                max_h = h;
            }
        }
    }
    (max_w, max_h)
}

fn build_command_args_auto(
    mirror_group: &[String],
    placement: &str,
    others: &[String],
) -> Vec<String> {
    let (gw, gh) = group_size(mirror_group);
    let mut args: Vec<String> = vec!["set".into()];
    // Primary logical monitor (mirrored group) at 0,0
    args.push("-Lp".into());
    for m in mirror_group {
        args.push("-M".into());
        args.push(m.clone());
    }
    args.push("-x".into());
    args.push("0".into());
    args.push("-y".into());
    args.push("0".into());

    // Tile the remaining monitors relative to the group size
    let mut cur_x = 0i32;
    let mut cur_y = 0i32;
    for o in others {
        let (ow, oh) = connector_size(o).unwrap_or((1920, 1080));
        let (x, y) = match placement {
            "right" => {
                let pos = (gw, cur_y);
                cur_y += oh;
                pos
            }
            "left" => {
                let pos = (-ow, cur_y);
                cur_y += oh;
                pos
            }
            "below" => {
                let pos = (cur_x, gh);
                cur_x += ow;
                pos
            }
            "above" => {
                let pos = (cur_x, -oh);
                cur_x += ow;
                pos
            }
            _ => (gw, 0),
        };
        args.push("-L".into());
        args.push("-M".into());
        args.push(o.clone());
        args.push("-x".into());
        args.push(x.to_string());
        args.push("-y".into());
        args.push(y.to_string());
    }
    args
}

// Build args for the CURRENT layout by parsing xrandr --query (best-effort)
fn current_layout_args() -> Option<Vec<String>> {
    if !have("xrandr") {
        return None;
    }
    let out = Command::new("xrandr").arg("--query").output().ok()?;
    let s = String::from_utf8_lossy(&out.stdout);
    let geom_re = Regex::new(r"([0-9]{3,})x([0-9]{3,})\+([0-9]+)\+([0-9]+)").ok()?;
    let mut entries: Vec<(String, i32, i32, bool)> = Vec::new();
    for line in s.lines() {
        let mut parts = line.split_whitespace();
        let name = match parts.next() {
            Some(n) => n,
            None => continue,
        };
        if !line.contains(" connected ") {
            continue;
        }
        if let Some(cap) = geom_re.captures(line) {
            let x: i32 = cap.get(3)?.as_str().parse().ok()?;
            let y: i32 = cap.get(4)?.as_str().parse().ok()?;
            let primary = line.contains(" primary ");
            entries.push((name.to_string(), x, y, primary));
        }
    }
    if entries.is_empty() {
        return None;
    }
    // primary first
    entries.sort_by_key(|e| (!e.3, e.1, e.2));
    let mut args: Vec<String> = vec!["set".into()];
    let mut first = true;
    for (name, x, y, _primary) in entries {
        if first {
            args.push("-Lp".into());
            first = false;
        } else {
            args.push("-L".into());
        }
        args.push("-M".into());
        args.push(name);
        args.push("-x".into());
        args.push(x.to_string());
        args.push("-y".into());
        args.push(y.to_string());
    }
    Some(args)
}

fn args_to_shell(cmd: &str, args: &[String]) -> String {
    let mut s = String::new();
    s.push_str(cmd);
    for a in args {
        s.push(' ');
        s.push_str(&shell_escape(a));
    }
    s
}

fn shell_escape(s: &str) -> String {
    if s.chars()
        .all(|c| c.is_ascii_alphanumeric() || "-_/.:@".contains(c))
    {
        s.to_string()
    } else {
        let escaped = s.replace('\'', "'\\''");
        format!("'{}'", escaped)
    }
}

fn snapshot_dir() -> PathBuf {
    let base = env::var("XDG_CONFIG_HOME")
        .map(PathBuf::from)
        .unwrap_or_else(|_| dirs_home_config());
    base.join("monitor-tui")
}

fn dirs_home_config() -> PathBuf {
    let home = env::var("HOME")
        .map(PathBuf::from)
        .unwrap_or_else(|_| PathBuf::from("."));
    home.join(".config")
}

fn snapshot_save(label: &str, cmdline: &str) -> Result<PathBuf> {
    let dir = snapshot_dir();
    fs::create_dir_all(&dir)?;
    let mut name = label.replace(|c: char| c.is_whitespace(), "_");
    name.retain(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-' || c == '.');
    if name.is_empty() {
        name = format!("snapshot_{}", chrono::Local::now().format("%Y%m%d_%H%M%S"));
    }
    let file = dir.join(format!("{}.sh", name));
    let content = format!("#!/usr/bin/env bash\nset -euo pipefail\n{}\n", cmdline);
    fs::write(&file, content)?;
    let _ = Command::new("chmod").arg("+x").arg(&file).status();
    Ok(file)
}

fn snapshot_pick() -> Result<Option<PathBuf>> {
    let dir = snapshot_dir();
    let mut entries: Vec<PathBuf> = if dir.exists() {
        fs::read_dir(&dir)?
            .filter_map(|e| e.ok().map(|e| e.path()))
            .collect()
    } else {
        vec![]
    };
    entries.sort();
    entries.retain(|p| p.extension().map(|e| e == "sh").unwrap_or(false));
    if entries.is_empty() {
        msgbox("No snapshots saved yet.");
        return Ok(None);
    }
    let opts: Vec<(String, String)> = entries
        .iter()
        .map(|p| {
            let base = p.file_name().unwrap().to_string_lossy().to_string();
            (base.clone(), format!("{}", base))
        })
        .collect();
    if let Some(sel) = menu("Snapshots:", &opts)? {
        return Ok(Some(dir.join(sel)));
    }
    Ok(None)
}

fn main() -> Result<()> {
    if !have("gnome-monitor-config") {
        msgbox("gnome-monitor-config is required (Wayland). Please install it (part of GNOME). Aborting.");
        return Ok(());
    }

    loop {
        let choice = menu(
            "Choose an action:",
            &[
                ("new".into(), "Create & apply a new layout".into()),
                ("apply".into(), "Apply a saved snapshot".into()),
                ("delete".into(), "Delete a saved snapshot".into()),
                ("snapshot".into(), "Save CURRENT layout as snapshot".into()),
                ("quit".into(), "Quit".into()),
            ],
        )?;
        match choice.as_deref() {
            Some("new") => new_layout()?,
            Some("apply") => {
                if let Some(p) = snapshot_pick()? {
                    let _ = Command::new("bash").arg(p).status();
                }
            }
            Some("delete") => {
                if let Some(p) = snapshot_pick()? {
                    let _ = fs::remove_file(&p);
                    msgbox(&format!(
                        "Deleted snapshot: {}",
                        p.file_name().unwrap().to_string_lossy()
                    ));
                }
            }
            Some("snapshot") => match current_layout_args() {
                Some(args) => {
                    let default =
                        format!("current_{}", chrono::Local::now().format("%Y%m%d_%H%M%S"));
                    let label = inputbox("Snapshot label:", &default)?;
                    let cmdline = args_to_shell("gnome-monitor-config", &args);
                    let file = snapshot_save(&label, &cmdline)?;
                    msgbox(&format!(
                        "Saved snapshot of CURRENT layout: {}",
                        file.display()
                    ));
                }
                None => {
                    msgbox("Could not detect current layout (xrandr geometry not available).\nTry applying a layout via this tool first, then snapshot.");
                }
            },
            Some("quit") | None => break,
            _ => {}
        }
    }
    Ok(())
}

fn new_layout() -> Result<()> {
    let conns = discover_connectors();
    let mut cl_args: Vec<(String, String, bool)> = Vec::new();
    for c in &conns {
        cl_args.push((c.clone(), describe_connector(c), false));
    }
    let picked = checklist("Pick one or more connectors to MIRROR as a single logical monitor (these will be your 'big' display):", &cl_args)?;
    if picked.is_empty() {
        msgbox("You must select at least one connector.");
        return Ok(());
    }

    // Summary
    let mut summary = String::new();
    for c in &conns {
        summary.push_str(&format!("{} {}\n", c, describe_connector(c)));
    }
    msgbox(&format!("Detected connectors:\n{}", summary));

    let place = match menu(
        "Where do you want to place the OTHER monitors relative to the mirrored group?",
        &[
            (
                "below".into(),
                "Below (typical laptop-under-desktop)".into(),
            ),
            ("above".into(), "Above".into()),
            ("left".into(), "Left".into()),
            ("right".into(), "Right".into()),
        ],
    )? {
        Some(p) => p.to_string(),
        None => return Ok(()),
    };

    let pick_set: BTreeSet<String> = picked.iter().cloned().collect();
    let mut others: Vec<String> = conns
        .iter()
        .filter(|c| !pick_set.contains(*c))
        .cloned()
        .collect();

    if !others.is_empty() {
        let mut cl2: Vec<(String, String, bool)> = Vec::new();
        for o in &others {
            cl2.push((o.clone(), describe_connector(o), true));
        }
        let picked2 = checklist(&format!("Select which of the remaining connectors to include (they will be placed {} the group):", place), &cl2)?;
        others = picked2;
    }

    // Auto-calculate offsets based on monitor sizes and placement
    let args = build_command_args_auto(&picked, &place, &others);
    let status = Command::new("gnome-monitor-config").args(&args).status()?;
    let cmdline = args_to_shell("gnome-monitor-config", &args);
    if status.success() {
        msgbox(&format!("Applied:\n{}", cmdline));
        if let Some(ans) = menu(
            "Snapshot this working layout?",
            &[
                ("yes".into(), "Save snapshot".into()),
                ("no".into(), "Skip".into()),
            ],
        )? {
            if ans == "yes" {
                let default = format!(
                    "mirrored_group_{}",
                    chrono::Local::now().format("%Y%m%d_%H%M%S")
                );
                let label = inputbox("Snapshot label:", &default)?;
                let file = snapshot_save(&label, &cmdline)?;
                msgbox(&format!("Saved snapshot: {}", file.display()));
            }
        }
    } else {
        msgbox(&format!(
            "Failed to apply the layout.\nCommand was:\n{}",
            cmdline
        ));
    }

    Ok(())
}