//! `ChatWidget` integration points for the `/keymap` picker flow.
//!
//! The picker model, capture view, and edit semantics live in [`crate::keymap_setup`]. This module
//! keeps only the `ChatWidget`-owned responsibilities: opening those views in the bottom pane,
//! routing users back to the right picker row after an edit, and synchronizing the committed
//! keymap config back into the live widget state. Keeping these methods outside `chatwidget.rs`
//! keeps the main transcript/event surface from also owning the `/keymap` navigation details.
//!
//! The important invariant is that any accepted keymap edit must update three places together:
//! the stored `Config.tui_keymap`, the cached copy-response binding used by app-level shortcuts,
//! and the bottom pane's runtime keymap bindings. Updating only one of those would make the UI
//! appear to accept a remap while some handlers still respond to the old keys.

use codex_config::types::TuiKeymap;
use codex_terminal_detection::terminal_info;

use super::ChatWidget;
use super::queued_message_edit_hint_binding;
use crate::app_event::KeymapEditIntent;
use crate::keymap::RuntimeKeymap;
use crate::keymap_setup;

impl ChatWidget {
    /// Opens the root `/keymap` picker using the current `tui.keymap` configuration.
    ///
    /// This validates the persisted keymap before building picker rows because every subsequent
    /// picker screen needs the effective runtime bindings, including preset defaults and user
    /// overrides. If the config is invalid, the user sees the parse error instead of a partial
    /// picker that could commit edits against stale runtime state.
    pub(crate) fn open_keymap_picker(&mut self) {
        match RuntimeKeymap::from_config(&self.config.tui_keymap) {
            Ok(runtime_keymap) => {
                let params = keymap_setup::build_keymap_picker_params_with_filter(
                    &runtime_keymap,
                    &self.config.tui_keymap,
                    self.keymap_action_filter(),
                );
                self.bottom_pane.show_selection_view(params);
            }
            Err(err) => {
                self.add_error_message(format!("Invalid `tui.keymap` configuration: {err}"));
            }
        }
    }

    /// Opens the per-action menu for one keymap action.
    ///
    /// Callers pass the already-resolved runtime keymap from the app event that selected the
    /// action. Recomputing it here would risk showing a menu for a different config if another
    /// keymap edit was applied between the picker event and this handler.
    pub(crate) fn open_keymap_action_menu(
        &mut self,
        context: String,
        action: String,
        runtime_keymap: &RuntimeKeymap,
    ) {
        let params = keymap_setup::build_keymap_action_menu_params(
            context,
            action,
            runtime_keymap,
            &self.config.tui_keymap,
        );
        self.bottom_pane.show_selection_view(params);
    }

    /// Opens the key-capture view for a set, replace, or alternate-binding edit.
    ///
    /// The capture view owns raw key interpretation, but `ChatWidget` supplies the event sender so
    /// the captured key can come back through the same app-event path as menu selections. Bypassing
    /// that path would skip config persistence and leave the runtime keymap cache unchanged.
    pub(crate) fn open_keymap_capture(
        &mut self,
        context: String,
        action: String,
        intent: KeymapEditIntent,
        runtime_keymap: &RuntimeKeymap,
    ) {
        let view = keymap_setup::build_keymap_capture_view(
            context,
            action,
            intent,
            runtime_keymap,
            self.app_event_tx.clone(),
        );
        self.bottom_pane.show_view(Box::new(view));
        self.request_redraw();
    }

    /// Opens the keypress inspector with the current runtime bindings.
    pub(crate) fn open_keymap_debug(&mut self, runtime_keymap: &RuntimeKeymap) {
        let view = keymap_setup::build_keymap_debug_view(runtime_keymap, &self.config.tui_keymap);
        self.bottom_pane.show_view(Box::new(view));
        self.request_redraw();
    }

    /// Opens the menu that lets the user choose which existing binding to replace.
    ///
    /// This is only used for actions with multiple effective bindings. The chosen binding is
    /// carried through the subsequent capture intent so replacement edits do not accidentally
    /// collapse alternate bindings that should remain available.
    pub(crate) fn open_keymap_replace_binding_menu(
        &mut self,
        context: String,
        action: String,
        runtime_keymap: &RuntimeKeymap,
    ) {
        let params =
            keymap_setup::build_keymap_replace_binding_menu_params(context, action, runtime_keymap);
        self.bottom_pane.show_selection_view(params);
    }

    /// Returns to the root picker with the edited action selected.
    ///
    /// The preferred path replaces any active keymap picker submenu in place so the bottom-pane
    /// back stack does not accumulate obsolete menus after each edit. If the expected view stack is
    /// no longer active, this falls back to showing a fresh picker rather than dropping the user on
    /// a stale screen.
    pub(crate) fn return_to_keymap_picker(
        &mut self,
        context: &str,
        action: &str,
        runtime_keymap: &RuntimeKeymap,
    ) {
        let params = keymap_setup::build_keymap_picker_params_for_selected_action_with_filter(
            runtime_keymap,
            &self.config.tui_keymap,
            self.keymap_action_filter(),
            context,
            action,
        );
        let replaced = self.bottom_pane.replace_active_views_with_selection_view(
            &[
                keymap_setup::KEYMAP_PICKER_VIEW_ID,
                keymap_setup::KEYMAP_ACTION_MENU_VIEW_ID,
                keymap_setup::KEYMAP_REPLACE_BINDING_MENU_VIEW_ID,
            ],
            params,
        );
        if !replaced {
            let params = keymap_setup::build_keymap_picker_params_for_selected_action_with_filter(
                runtime_keymap,
                &self.config.tui_keymap,
                self.keymap_action_filter(),
                context,
                action,
            );
            self.bottom_pane.show_selection_view(params);
        }
        self.request_redraw();
    }

    fn keymap_action_filter(&self) -> keymap_setup::KeymapActionFilter {
        keymap_setup::KeymapActionFilter {
            fast_mode_enabled: self.fast_mode_enabled(),
        }
    }

    /// Applies a committed keymap edit to the live chat widget.
    ///
    /// The caller is responsible for persisting the config file before invoking this method. This
    /// method updates the in-memory config, app-level copy binding cache, and bottom-pane keymap
    /// bindings as one unit; callers that update only `self.config.tui_keymap` would leave visible
    /// picker state and active key handlers disagreeing until the next restart.
    pub(crate) fn apply_keymap_update(
        &mut self,
        keymap_config: TuiKeymap,
        runtime_keymap: &RuntimeKeymap,
    ) {
        self.config.tui_keymap = keymap_config;
        self.copy_last_response_binding = runtime_keymap.app.copy.clone();
        self.chat_keymap = runtime_keymap.chat.clone();
        self.queued_message_edit_hint_binding = queued_message_edit_hint_binding(
            &self.chat_keymap.edit_queued_message,
            terminal_info(),
        );
        self.bottom_pane
            .set_queued_message_edit_binding(self.queued_message_edit_hint_binding);
        self.bottom_pane.set_keymap_bindings(runtime_keymap);
        self.request_redraw();
    }
}
