par_term/app/tab_ops/

lifecycle.rs

//! Tab lifecycle operations: create, close, navigate.
//!
//! Reopen (session undo) and tab-bar resize helpers live in `tab_reopen`.

use std::sync::Arc;

use super::super::window_state::WindowState;
use super::ClosedTabInfo;
use crate::tmux::TmuxWindowId;
use par_term_config::TabId;

impl WindowState {
    /// Create a new tab, or show profile picker if configured and profiles exist
    pub fn new_tab_or_show_profiles(&mut self) {
        if self.config.load().tabs.new_tab_shortcut_shows_profiles
            && !self.overlay_ui.profile_manager.is_empty()
        {
            self.tab_bar_ui.show_new_tab_profile_menu = !self.tab_bar_ui.show_new_tab_profile_menu;
            self.request_redraw();
            log::info!("Toggled new-tab profile menu via shortcut");
        } else {
            self.new_tab();
            log::info!("New tab created");
        }
    }

    /// The daemon window `tab_id` mirrors, when a mux transport is
    /// attached. `None` for local tabs and for every tab while no transport
    /// is installed (the tmux gateway keeps its own separate state).
    pub(crate) fn mux_window_for_tab(&self, tab_id: TabId) -> Option<TmuxWindowId> {
        self.tmux_state.transport.as_ref()?;
        self.tmux_state.tmux_sync.get_window(tab_id)
    }

    /// Create a new tab
    pub fn new_tab(&mut self) {
        // Check max tabs limit
        if self.config.load().tabs.max_tabs > 0
            && self.tab_manager.tab_count() >= self.config.load().tabs.max_tabs
        {
            log::warn!(
                "Cannot create new tab: max_tabs limit ({}) reached",
                self.config.load().tabs.max_tabs
            );
            return;
        }

        // While attached to a par-mux session, a new tab IS a daemon window
        // (the tmux -CC model): ask the daemon, and its %window-add
        // notification creates the display tab through the same path as
        // every other daemon window. No local shell tab is created — the
        // session outlives this client, so a local tab would be a window
        // the daemon cannot see or manage.
        let sent = self
            .tmux_state
            .transport
            .as_ref()
            .map(|t| t.send_command("new-window"));
        if let Some(result) = sent {
            match result {
                Ok(_) => {
                    log::info!("MUX: new-window sent; tab arrives via %window-add");
                }
                Err(e) => {
                    log::error!("MUX: new-window failed: {e}");
                    self.show_toast(format!("par-mux: new-window failed — {e}"));
                }
            }
            self.request_redraw();
            return;
        }

        // Remember tab count before creating new tab to detect tab bar visibility change
        let old_tab_count = self.tab_manager.tab_count();

        // Capture BEFORE creation — tab_manager switches active to the new tab inside new_tab()
        let prior_active_idx = self.tab_manager.active_tab_index();

        // Get current grid size from renderer to pass to new tab
        // This accounts for possible tab bar height changes
        let grid_size = self.renderer.as_ref().map(|r| r.grid_size());

        match self.tab_manager.new_tab(
            &self.config.load(),
            Arc::clone(&self.runtime),
            self.config.load().tabs.tab_inherit_cwd,
            grid_size,
        ) {
            Ok(tab_id) => {
                // Reposition new tab if configured
                if self.config.load().tabs.new_tab_position
                    == crate::config::NewTabPosition::AfterActive
                    && let Some(idx) = prior_active_idx
                {
                    self.tab_manager.move_tab_to_index(tab_id, idx + 1);
                }

                // Check if tab bar visibility changed (e.g., from 1 to 2 tabs with WhenMultiple mode)
                let new_tab_count = self.tab_manager.tab_count();
                let old_tab_bar_height = self
                    .tab_bar_ui
                    .get_height(old_tab_count, &self.config.load());
                let new_tab_bar_height = self
                    .tab_bar_ui
                    .get_height(new_tab_count, &self.config.load());
                let old_tab_bar_width = self
                    .tab_bar_ui
                    .get_width(old_tab_count, &self.config.load());
                let new_tab_bar_width = self
                    .tab_bar_ui
                    .get_width(new_tab_count, &self.config.load());

                // If tab bar dimensions changed, update content offsets and resize ALL existing tabs
                if ((new_tab_bar_height - old_tab_bar_height).abs() > 0.1
                    || (new_tab_bar_width - old_tab_bar_width).abs() > 0.1)
                    && let Some(renderer) = &mut self.renderer
                    && let Some((new_cols, new_rows)) = Self::apply_tab_bar_offsets_for_position(
                        self.config.load().tabs.tab_bar_position,
                        renderer,
                        new_tab_bar_height,
                        new_tab_bar_width,
                    )
                {
                    let cell_width = renderer.cell_width();
                    let cell_height = renderer.cell_height();
                    let width_px = (new_cols as f32 * cell_width) as usize;
                    let height_px = (new_rows as f32 * cell_height) as usize;

                    // Resize all EXISTING tabs (not including the new one yet)
                    for tab in self.tab_manager.tabs_mut() {
                        if tab.id != tab_id {
                            // try_lock: intentional — resize during new-tab creation in sync
                            // event loop. On miss: this tab keeps old dimensions; corrected
                            // on the next Resized event.
                            if let Ok(mut term) = tab.terminal.try_write() {
                                term.set_cell_dimensions(cell_width as u32, cell_height as u32);
                                if let Err(e) =
                                    term.resize_with_pixels(new_cols, new_rows, width_px, height_px)
                                {
                                    crate::debug_error!(
                                        "TERMINAL",
                                        "resize_with_pixels failed (new_tab): {e}"
                                    );
                                }
                            }
                            tab.active_cache_mut().cells = None;
                        }
                    }
                    log::info!(
                        "Tab bar appeared (position={:?}), resized existing tabs to {}x{}",
                        self.config.load().tabs.tab_bar_position,
                        new_cols,
                        new_rows
                    );
                }

                // Start refresh task for the new tab and resize to match window
                if let Some(window) = &self.window
                    && let Some(tab) = self.tab_manager.get_tab_mut(tab_id)
                {
                    tab.start_refresh_task(
                        Arc::clone(&self.runtime),
                        Arc::clone(window),
                        self.config.load().rendering.max_fps,
                        self.config.load().power.inactive_tab_fps,
                    );

                    // Resize terminal to match current renderer dimensions
                    // (which now has the correct content offset)
                    // try_lock: intentional — new-tab initialization in sync event loop.
                    // On miss: the new tab starts with default PTY dimensions; corrected
                    // on the next Resized event.
                    if let Some(renderer) = &self.renderer
                        && let Ok(mut term) = tab.terminal.try_write()
                    {
                        let (cols, rows) = renderer.grid_size();
                        let cell_width = renderer.cell_width();
                        let cell_height = renderer.cell_height();
                        let width_px = (cols as f32 * cell_width) as usize;
                        let height_px = (rows as f32 * cell_height) as usize;

                        // Set cell dimensions
                        term.set_cell_dimensions(cell_width as u32, cell_height as u32);

                        // Resize terminal to match window size
                        if let Err(e) = term.resize_with_pixels(cols, rows, width_px, height_px) {
                            crate::debug_error!(
                                "TERMINAL",
                                "resize_with_pixels failed (new_tab_init): {e}"
                            );
                        }
                        log::info!(
                            "Resized new tab {} terminal to {}x{} ({}x{} px)",
                            tab_id,
                            cols,
                            rows,
                            width_px,
                            height_px
                        );
                    }
                }

                // Play new tab alert sound if configured
                self.play_alert_sound(crate::config::AlertEvent::NewTab);

                self.focus_state.needs_redraw = true;
                self.request_redraw();
            }
            Err(e) => {
                log::error!("Failed to create new tab: {}", e);
            }
        }
    }

    /// Close the current tab
    /// Returns true if the window should close (last tab was closed)
    pub fn close_current_tab(&mut self) -> bool {
        log::info!(
            "[CLOSE_TAB] close_current_tab called, confirm_close_running_jobs={}",
            self.config.load().shell.confirm_close_running_jobs
        );

        // Check if we need to show confirmation for running jobs
        if self.config.load().shell.confirm_close_running_jobs
            && let Some(command_name) = self.check_current_tab_running_job()
            && let Some(tab) = self.tab_manager.active_tab()
        {
            let tab_id = tab.id;
            let tab_title = if tab.title.is_empty() {
                "Terminal".to_string()
            } else {
                tab.title.clone()
            };
            log::info!(
                "[CLOSE_TAB] Showing close confirmation for tab {} with running command: {}",
                tab_id,
                command_name
            );
            self.overlay_ui
                .close_confirmation_ui
                .show_for_tab(tab_id, &tab_title, &command_name);
            self.focus_state.needs_redraw = true;
            self.request_redraw();
            return false; // Don't close yet, waiting for confirmation
        }

        log::info!(
            "[CLOSE_TAB] No running job detected or confirmation disabled, closing immediately"
        );
        self.close_current_tab_immediately()
    }

    /// Close the current tab immediately without confirmation
    /// Returns true if the window should close (last tab was closed)
    pub fn close_current_tab_immediately(&mut self) -> bool {
        self.close_current_tab_inner(true)
    }

    /// The last-pane close of a mux tab (card 01a0d9b5568): the tab closes
    /// locally and the daemon window KEEPS RUNNING — the detach-like
    /// shape — so the window can come back on reattach. A TAB close (the
    /// public method above) kills the daemon window instead.
    #[cfg_attr(not(feature = "mux"), allow(dead_code))]
    pub(crate) fn close_current_tab_keeping_mux_window(&mut self) -> bool {
        self.close_current_tab_inner(false)
    }

    /// The shared close body. `kill_mux_window` decides a mux tab's
    /// daemon-window fate: `true` for tab closes (kill-window — the
    /// tmux -CC semantic, no stale mappings), `false` for the last-pane
    /// close's recorded keep-the-window decision.
    fn close_current_tab_inner(&mut self, kill_mux_window: bool) -> bool {
        if let Some(tab_id) = self.tab_manager.active_tab_id() {
            // If the tab being closed is the tmux gateway, send detach-client first so
            // that tmux can cleanly detach rather than treating the disconnect as a crash
            // (which may destroy the session if destroy-unattached is enabled).
            let is_tmux_gateway = self.config.load().tmux.tmux_enabled
                && self.tmux_state.tmux_gateway_tab_id == Some(tab_id)
                && self.is_gateway_active();
            if is_tmux_gateway {
                self.write_to_gateway("detach-client\n");
                self.disconnect_tmux_session();
            }

            // A mux tab mirrors a daemon window: closing it kills that
            // window daemon-side, and the %window-close notification runs
            // the tab teardown (close_tab_fast + unmap) — the same path as
            // a shell exiting in the daemon pane. Killing (rather than
            // detaching one window) matches tmux semantics and leaves no
            // stale mappings behind; the SESSION survives via detach.
            if kill_mux_window && let Some(window_id) = self.mux_window_for_tab(tab_id) {
                let killed = self
                    .tmux_state
                    .transport
                    .as_ref()
                    .map(|t| t.send_command(&format!("kill-window -t @{window_id}")));
                if matches!(&killed, Some(Ok(_))) {
                    log::info!("MUX: kill-window @{} sent for tab {tab_id}", window_id);
                    // No session-undo capture: a daemon window cannot
                    // be restored from local metadata — reopening is a
                    // new-window, not an undo.
                    return false; // the tab closes when %window-close lands
                }
                if let Some(Err(e)) = &killed {
                    log::error!("MUX: kill-window @{window_id} failed: {e}");
                    self.show_toast(format!("par-mux: kill-window failed — {e}"));
                    // Fall through to the local close: the daemon
                    // window is unreachable from this client either way.
                }
            }

            // Track whether this is a tmux display tab (non-gateway tab that shows tmux window
            // content) so we can restore the hidden gateway tab after it is closed.
            let is_tmux_display_tab = self.config.load().tmux.tmux_enabled
                && self.tmux_state.tmux_gateway_tab_id.is_some()
                && self.tmux_state.tmux_gateway_tab_id != Some(tab_id)
                && self.is_gateway_active();

            // Remember tab count before closing to detect tab bar visibility change
            let old_tab_count = self.tab_manager.tab_count();
            let old_tab_bar_height = self
                .tab_bar_ui
                .get_height(old_tab_count, &self.config.load());
            let old_tab_bar_width = self
                .tab_bar_ui
                .get_width(old_tab_count, &self.config.load());

            let is_last_tab = self.tab_manager.tab_count() <= 1;
            let preserve_shell = self
                .config
                .load()
                .session_restore
                .session_undo_preserve_shell
                && self.config.load().session_restore.session_undo_timeout_secs > 0;

            // Capture closed tab metadata for session undo (before destroying the tab)
            let is_last = if preserve_shell {
                // Preserve mode: extract the live Tab and store it in ClosedTabInfo
                if let Some(tab) = self.tab_manager.get_tab(tab_id) {
                    let cwd = tab.get_cwd();
                    let title = tab.title.clone();
                    let has_default_title = tab.has_default_title;
                    let custom_color = tab.custom_color;
                    let index = self.tab_manager.active_tab_index().unwrap_or(0);

                    if let Some((mut hidden_tab, is_empty)) = self.tab_manager.remove_tab(tab_id) {
                        // Stop refresh task to prevent invisible redraws
                        hidden_tab.stop_refresh_task();

                        let info = ClosedTabInfo {
                            cwd,
                            title,
                            has_default_title,
                            index,
                            closed_at: std::time::Instant::now(),
                            pane_layout: None, // Preserved inside the hidden Tab itself
                            custom_color,
                            hidden_tab: Some(hidden_tab),
                        };
                        self.overlay_state.closed_tabs.push_front(info);
                        while self.overlay_state.closed_tabs.len()
                            > self.config.load().session_restore.session_undo_max_entries
                        {
                            self.overlay_state.closed_tabs.pop_back();
                        }
                        is_empty
                    } else {
                        // Fallback: tab disappeared between get and remove
                        self.tab_manager.close_tab(tab_id)
                    }
                } else {
                    self.tab_manager.close_tab(tab_id)
                }
            } else {
                // Standard mode: capture metadata, then close (drops the Tab)
                if self.config.load().session_restore.session_undo_timeout_secs > 0
                    && let Some(tab) = self.tab_manager.get_tab(tab_id)
                {
                    let info = ClosedTabInfo {
                        cwd: tab.get_cwd(),
                        title: tab.title.clone(),
                        has_default_title: tab.has_default_title,
                        index: self.tab_manager.active_tab_index().unwrap_or(0),
                        closed_at: std::time::Instant::now(),
                        pane_layout: tab
                            .pane_manager
                            .as_ref()
                            .and_then(|pm| pm.root())
                            .map(crate::session::capture::capture_pane_node),
                        custom_color: tab.custom_color,
                        hidden_tab: None,
                    };
                    self.overlay_state.closed_tabs.push_front(info);
                    while self.overlay_state.closed_tabs.len()
                        > self.config.load().session_restore.session_undo_max_entries
                    {
                        self.overlay_state.closed_tabs.pop_back();
                    }
                }

                self.tab_manager.close_tab(tab_id)
            };

            // After closing a tmux display tab, check if the hidden gateway tab needs to
            // be restored.  This happens when the user manually closes all display tabs
            // while still connected — the gateway tab was hidden but is the only one left.
            if is_tmux_display_tab && self.is_gateway_active() {
                let gateway_tab_id = self.tmux_state.tmux_gateway_tab_id;
                let has_other_visible = self
                    .tab_manager
                    .tabs()
                    .iter()
                    .any(|t| !t.is_hidden && Some(t.id) != gateway_tab_id);
                if !has_other_visible {
                    self.show_gateway_tab();
                    // Switch focus to the gateway tab so the user can interact with it
                    if let Some(gtid) = gateway_tab_id {
                        self.tab_manager.switch_to(gtid);
                    }
                }
            }

            // Play tab close alert sound if configured
            self.play_alert_sound(crate::config::AlertEvent::TabClose);

            // Show undo toast (only if not the last tab — window is closing)
            if !is_last_tab {
                let key_hint = self
                    .config
                    .load()
                    .keybindings
                    .iter()
                    .find(|kb| kb.action == "reopen_closed_tab")
                    .map(|kb| kb.key.clone())
                    .unwrap_or_else(|| "keybinding".to_string());
                let timeout = self.config.load().session_restore.session_undo_timeout_secs;
                if timeout > 0 {
                    self.show_toast(format!(
                        "Tab closed. Press {} to undo ({timeout}s)",
                        key_hint
                    ));
                }
            }

            // Check if tab bar visibility changed (e.g., from 2 to 1 tabs with WhenMultiple mode)
            if !is_last {
                let new_tab_count = self.tab_manager.tab_count();
                let new_tab_bar_height = self
                    .tab_bar_ui
                    .get_height(new_tab_count, &self.config.load());
                let new_tab_bar_width = self
                    .tab_bar_ui
                    .get_width(new_tab_count, &self.config.load());

                if ((new_tab_bar_height - old_tab_bar_height).abs() > 0.1
                    || (new_tab_bar_width - old_tab_bar_width).abs() > 0.1)
                    && let Some(renderer) = &mut self.renderer
                    && let Some((new_cols, new_rows)) = Self::apply_tab_bar_offsets_for_position(
                        self.config.load().tabs.tab_bar_position,
                        renderer,
                        new_tab_bar_height,
                        new_tab_bar_width,
                    )
                {
                    let cell_width = renderer.cell_width();
                    let cell_height = renderer.cell_height();
                    let width_px = (new_cols as f32 * cell_width) as usize;
                    let height_px = (new_rows as f32 * cell_height) as usize;

                    // Resize all remaining tabs
                    for tab in self.tab_manager.tabs_mut() {
                        // try_lock: intentional — tab close resize in sync event loop.
                        // On miss: tab keeps old dimensions; fixed on the next Resized event.
                        if let Ok(mut term) = tab.terminal.try_write() {
                            term.set_cell_dimensions(cell_width as u32, cell_height as u32);
                            if let Err(e) =
                                term.resize_with_pixels(new_cols, new_rows, width_px, height_px)
                            {
                                crate::debug_error!(
                                    "TERMINAL",
                                    "resize_with_pixels failed (close_tab): {e}"
                                );
                            }
                        }
                        tab.active_cache_mut().cells = None;
                    }
                    log::info!(
                        "Tab bar visibility changed (position={:?}), resized remaining tabs to {}x{}",
                        self.config.load().tabs.tab_bar_position,
                        new_cols,
                        new_rows
                    );
                }
            }

            self.focus_state.needs_redraw = true;
            self.request_redraw();
            is_last
        } else {
            true // No tabs, window should close
        }
    }

    /// Switch to next tab
    pub fn next_tab(&mut self) {
        self.copy_mode.exit();
        self.tab_manager.next_tab();
        self.clear_and_invalidate();
    }

    /// Switch to previous tab
    pub fn prev_tab(&mut self) {
        self.copy_mode.exit();
        self.tab_manager.prev_tab();
        self.clear_and_invalidate();
    }

    /// Switch to tab by index (1-based)
    pub fn switch_to_tab_index(&mut self, index: usize) {
        self.copy_mode.exit();
        self.tab_manager.switch_to_index(index);
        self.clear_and_invalidate();
    }

    /// Move current tab left
    pub fn move_tab_left(&mut self) {
        self.tab_manager.move_active_tab_left();
        self.focus_state.needs_redraw = true;
        self.request_redraw();
    }

    /// Move current tab right
    pub fn move_tab_right(&mut self) {
        self.tab_manager.move_active_tab_right();
        self.focus_state.needs_redraw = true;
        self.request_redraw();
    }
}