//! Region selection overlay.
//!
//! Input modes (all available simultaneously):
//!   - Window pick: hover over a window → it highlights; single click captures it.
//!   - Drag:        press and drag → rubber-band selection (overrides window pick).
//!   - Two-click:   click once (anchor), move, click again → selection.
//!
//! Coordinate system:
//!   egui screen_rect == physical pixels of the monitor.
//!   capture::Region also uses physical pixels.
//!   Window rects from hyprctl are logical pixels — multiplied by scale to get physical.
//!   No scale division anywhere: Region handed to capture.rs is in physical pixels,
//!   and capture.rs crops from the physical full-screen capture directly.

use eframe::egui::{self, Color32, CursorIcon, Pos2, Rect, Rounding, Stroke, Vec2};
use image::RgbaImage;

use crate::capture::Region;
use crate::hyprland::WindowRect;

/// Result returned when the user completes or cancels the selection.
#[derive(Debug)]
pub enum SelectionResult {
    Selected(Region),
    Cancelled,
}

/// Input state machine.
#[derive(Default)]
enum SelectionState {
    #[default]
    Idle,
    Dragging { start: Pos2 },
    AwaitingSecondClick { start: Pos2 },
    Done { start: Pos2, end: Pos2 },
    Cancelled,
}

const MAX_TEX: u32 = 2048;

pub struct SelectionOverlay {
    background: egui::TextureHandle,
    /// Hyprland monitor scale (logical→physical). Used only for window rect conversion.
    scale: f32,
    state: SelectionState,
    result: Option<SelectionResult>,
    windows: Vec<WindowRect>,
    hovered_window: Option<usize>,
    diag_printed: bool,
}

impl SelectionOverlay {
    pub fn new(cc: &eframe::CreationContext<'_>, background_snapshot: RgbaImage, scale: f32) -> Self {
        let tex_image = fit_to_max_texture(background_snapshot);
        let (tw, th) = tex_image.dimensions();
        let color_image = egui::ColorImage::from_rgba_unmultiplied(
            [tw as usize, th as usize],
            tex_image.as_raw(),
        );
        let texture =
            cc.egui_ctx
                .load_texture("background", color_image, egui::TextureOptions::LINEAR);

        let windows = crate::hyprland::active_workspace_windows();

        Self {
            background: texture,
            scale,
            state: SelectionState::default(),
            result: None,
            windows,
            hovered_window: None,
            diag_printed: false,
        }
    }

    pub fn take_result(&mut self) -> Option<SelectionResult> {
        self.result.take()
    }

    /// Convert a hyprctl WindowRect (logical px) to an egui Rect (logical points).
    fn window_to_egui_rect(win: &WindowRect, _scale: f32) -> Rect {
        Rect::from_min_size(
            Pos2::new(win.x as f32, win.y as f32),
            Vec2::new(win.width as f32, win.height as f32),
        )
    }
}

impl eframe::App for SelectionOverlay {
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        ctx.set_cursor_icon(CursorIcon::Crosshair);

        if ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
            self.state = SelectionState::Cancelled;
        }

        let screen_rect = ctx.screen_rect();

        if !self.diag_printed {
            self.diag_printed = true;
            eprintln!(
                "[overlay diag] screen_rect={screen_rect:?} ppp={} scale={}",
                ctx.pixels_per_point(),
                self.scale,
            );
        }

        let dim = Color32::from_black_alpha(140);

        const DRAG_THRESHOLD: f32 = 4.0;

        let (hover_pos, press_origin, primary_down, primary_released) =
            ctx.input(|i| {
                (
                    i.pointer.hover_pos(),
                    i.pointer.press_origin(),
                    i.pointer.primary_down(),
                    i.pointer.primary_released(),
                )
            });

        let travel: f32 = match (press_origin, hover_pos) {
            (Some(o), Some(p)) => o.distance(p),
            _ => 0.0,
        };
        let is_click = primary_released && travel <= DRAG_THRESHOLD;
        let is_drag  = primary_down    && travel >  DRAG_THRESHOLD;

        // ── Window hover detection ────────────────────────────────────────────
        self.hovered_window = None;
        if matches!(self.state, SelectionState::Idle) {
            if let Some(pos) = hover_pos {
                for (i, win) in self.windows.iter().enumerate().rev() {
                    if Self::window_to_egui_rect(win, self.scale).contains(pos) {
                        self.hovered_window = Some(i);
                        break;
                    }
                }
            }
        }

        // ── State transitions ─────────────────────────────────────────────────
        match &self.state {
            SelectionState::Idle => {
                if is_drag {
                    self.hovered_window = None;
                    self.state = SelectionState::Dragging {
                        start: press_origin.unwrap_or_default(),
                    };
                } else if is_click {
                    if let Some(idx) = self.hovered_window {
                        let win = &self.windows[idx];
                        let rect = Self::window_to_egui_rect(win, self.scale).intersect(screen_rect);
                        self.state = SelectionState::Done {
                            start: rect.min,
                            end: rect.max,
                        };
                    } else {
                        self.state = SelectionState::AwaitingSecondClick {
                            start: press_origin.unwrap_or_default(),
                        };
                    }
                }
            }
            SelectionState::Dragging { start } => {
                let start = *start;
                if primary_released {
                    if let Some(end) = hover_pos {
                        self.state = SelectionState::Done { start, end };
                    } else {
                        self.state = SelectionState::Idle;
                    }
                }
                if !primary_down && !primary_released {
                    self.state = SelectionState::AwaitingSecondClick { start };
                }
            }
            SelectionState::AwaitingSecondClick { start } => {
                let start = *start;
                if is_click {
                    if let Some(end) = hover_pos {
                        self.state = SelectionState::Done { start, end };
                    }
                }
            }
            SelectionState::Done { .. } | SelectionState::Cancelled => {}
        }

        // ── Current live rect ─────────────────────────────────────────────────
        let current_rect: Option<Rect> = match &self.state {
            SelectionState::Dragging { start } => hover_pos.map(|p| Rect::from_two_pos(*start, p)),
            SelectionState::AwaitingSecondClick { start } => hover_pos.map(|p| Rect::from_two_pos(*start, p)),
            SelectionState::Done { start, end } => Some(Rect::from_two_pos(*start, *end)),
            _ => None,
        };

        // ── Draw ──────────────────────────────────────────────────────────────
        egui::CentralPanel::default()
            .frame(egui::Frame::none())
            .show(ctx, |ui| {
                let painter = ui.painter();

                // 1. Background screenshot.
                painter.image(
                    self.background.id(),
                    screen_rect,
                    Rect::from_min_max(Pos2::ZERO, Pos2::new(1.0, 1.0)),
                    Color32::WHITE,
                );

                // 2. Dim overlay.
                let active_rect = current_rect.or_else(|| {
                    self.hovered_window
                        .map(|i| Self::window_to_egui_rect(&self.windows[i], self.scale).intersect(screen_rect))
                });

                if let Some(sel) = active_rect {
                    let s = sel.intersect(screen_rect);
                    painter.rect_filled(
                        Rect::from_min_max(screen_rect.min, Pos2::new(screen_rect.max.x, s.min.y)),
                        Rounding::ZERO, dim,
                    );
                    painter.rect_filled(
                        Rect::from_min_max(Pos2::new(screen_rect.min.x, s.max.y), screen_rect.max),
                        Rounding::ZERO, dim,
                    );
                    painter.rect_filled(
                        Rect::from_min_max(
                            Pos2::new(screen_rect.min.x, s.min.y),
                            Pos2::new(s.min.x, s.max.y),
                        ),
                        Rounding::ZERO, dim,
                    );
                    painter.rect_filled(
                        Rect::from_min_max(
                            Pos2::new(s.max.x, s.min.y),
                            Pos2::new(screen_rect.max.x, s.max.y),
                        ),
                        Rounding::ZERO, dim,
                    );

                    let border_color = if self.hovered_window.is_some() && current_rect.is_none() {
                        Color32::from_rgb(255, 190, 50)
                    } else {
                        Color32::from_rgb(100, 180, 255)
                    };
                    painter.rect_stroke(s, Rounding::ZERO, Stroke::new(1.5, border_color));

                    // Size label in physical pixels.
                    let label = format!("{} × {}", s.width().round() as u32, s.height().round() as u32);
                    let lp = Pos2::new(s.min.x + 4.0, s.min.y - 18.0)
                        .clamp(Pos2::ZERO, screen_rect.max);
                    painter.text(lp, egui::Align2::LEFT_TOP, label,
                        egui::FontId::monospace(13.0), Color32::WHITE);

                    if let Some(idx) = self.hovered_window {
                        if current_rect.is_none() {
                            let title = &self.windows[idx].title;
                            if !title.is_empty() {
                                painter.text(
                                    Pos2::new(s.min.x + 4.0, s.min.y + 4.0),
                                    egui::Align2::LEFT_TOP,
                                    title,
                                    egui::FontId::proportional(12.0),
                                    Color32::from_rgba_unmultiplied(255, 190, 50, 220),
                                );
                            }
                        }
                    }
                } else {
                    painter.rect_filled(screen_rect, Rounding::ZERO, dim);
                }

                // 3. Crosshair.
                if let Some(pos) = hover_pos {
                    let s = Stroke::new(1.0, Color32::from_white_alpha(180));
                    painter.line_segment(
                        [Pos2::new(screen_rect.min.x, pos.y), Pos2::new(screen_rect.max.x, pos.y)], s);
                    painter.line_segment(
                        [Pos2::new(pos.x, screen_rect.min.y), Pos2::new(pos.x, screen_rect.max.y)], s);
                }

                // 4. Hint text.
                let hint = match &self.state {
                    SelectionState::Idle if self.hovered_window.is_some() =>
                        "Click to capture window   |   Drag for custom selection   |   Esc to cancel",
                    SelectionState::Idle =>
                        "Click or drag to select   |   Esc to cancel",
                    SelectionState::Dragging { .. } => "Release to capture",
                    SelectionState::AwaitingSecondClick { .. } =>
                        "Click to set the second corner   |   Esc to cancel",
                    _ => "",
                };
                if !hint.is_empty() {
                    painter.text(
                        Pos2::new(screen_rect.center().x, screen_rect.max.y - 28.0),
                        egui::Align2::CENTER_BOTTOM,
                        hint,
                        egui::FontId::proportional(14.0),
                        Color32::from_white_alpha(200),
                    );
                }
            });

        // ── Resolve ───────────────────────────────────────────────────────────
        match &self.state {
            SelectionState::Done { start, end } => {
                let rect = Rect::from_two_pos(*start, *end).intersect(screen_rect);
                if rect.width() > 2.0 && rect.height() > 2.0 {
                    let ppp = ctx.pixels_per_point();
                    // egui coords are logical points — scale to physical pixels.
                    let x = ((rect.min.x - screen_rect.min.x) * ppp).round() as i32;
                    let y = ((rect.min.y - screen_rect.min.y) * ppp).round() as i32;
                    let width  = (rect.width() * ppp).round()  as u32;
                    let height = (rect.height() * ppp).round() as u32;

                    eprintln!("[overlay] physical x={x} y={y} w={width} h={height}");

                    self.result = Some(SelectionResult::Selected(Region {
                        x: x.max(0),
                        y: y.max(0),
                        width,
                        height,
                    }));
                    ctx.send_viewport_cmd(egui::ViewportCommand::Close);
                } else {
                    self.state = SelectionState::Idle;
                }
            }
            SelectionState::Cancelled => {
                self.result = Some(SelectionResult::Cancelled);
                ctx.send_viewport_cmd(egui::ViewportCommand::Close);
            }
            _ => {}
        }

        ctx.request_repaint_after(std::time::Duration::from_millis(16));
    }

    fn clear_color(&self, _visuals: &egui::Visuals) -> [f32; 4] {
        [0.0, 0.0, 0.0, 0.0]
    }
}

fn fit_to_max_texture(img: RgbaImage) -> RgbaImage {
    let (w, h) = img.dimensions();
    if w <= MAX_TEX && h <= MAX_TEX {
        return img;
    }
    let scale = (MAX_TEX as f32 / w as f32).min(MAX_TEX as f32 / h as f32);
    image::imageops::resize(
        &img,
        (w as f32 * scale) as u32,
        (h as f32 * scale) as u32,
        image::imageops::FilterType::Triangle,
    )
}