//! Terminal control utilities.

use crate::{error, openfiles, sys};

/// Encapsulates the state of a controlled terminal.
pub struct TerminalControl {
    prev_fg_pid: Option<sys::process::ProcessId>,
}

impl TerminalControl {
    /// Acquire the terminal for the shell.
    pub fn acquire() -> Result<Self, error::Error> {
        // Mask out SIGTTOU *first*. If `lead_new_process_group` succeeds in
        // moving us into a new process group, the subsequent `tcsetpgrp` call
        // in `move_self_to_foreground` is a "write to the controlling
        // terminal from a background process," which the kernel signals with
        // SIGTTOU. The default action for SIGTTOU is to stop the process,
        // leaving brush (and any downstream reads from the terminal) hung.
        // Installing the SIG_IGN handler before the tcsetpgrp makes that call
        // succeed instead of stopping us.
        sys::signal::mask_sigttou()?;

        let prev_fg_pid = sys::terminal::get_foreground_pid();

        // Break out into new process group.
        // TODO(jobs): Investigate why this sometimes fails with EPERM.
        let _ = sys::signal::lead_new_process_group();

        // Take ownership.
        sys::terminal::move_self_to_foreground()?;

        Ok(Self { prev_fg_pid })
    }

    fn try_release(&mut self) {
        // Restore the previous foreground process group.
        if let Some(pid) = self.prev_fg_pid
            && sys::terminal::move_to_foreground(pid).is_ok()
        {
            self.prev_fg_pid = None;
        }
    }
}

impl Drop for TerminalControl {
    fn drop(&mut self) {
        self.try_release();
    }
}

/// Describes high-level terminal settings that can be requested.
#[derive(Default, bon::Builder)]
pub struct Settings {
    /// Whether to enable input echoing.
    pub echo_input: Option<bool>,
    /// Whether to enable line input (sometimes known as canonical mode).
    pub line_input: Option<bool>,
    /// Whether to disable interrupt signals and instead yield the control characters.
    pub interrupt_signals: Option<bool>,
    /// Whether to output newline characters as CRLF pairs.
    pub output_nl_as_nlcr: Option<bool>,
}

/// Guard that automatically restores terminal settings on drop.
pub struct AutoModeGuard {
    initial: sys::terminal::Config,
    file: openfiles::OpenFile,
}

impl AutoModeGuard {
    /// Creates a new `AutoModeGuard` for the given file.
    ///
    /// # Arguments
    ///
    /// * `file` - The file representing the terminal to control.
    pub fn new(file: openfiles::OpenFile) -> Result<Self, error::Error> {
        let initial = sys::terminal::Config::from_term(&file)?;
        Ok(Self { initial, file })
    }

    /// Applies the given terminal settings.
    ///
    /// # Arguments
    ///
    /// * `settings` - The terminal settings to apply.
    pub fn apply_settings(&self, settings: &Settings) -> Result<(), error::Error> {
        let mut config = sys::terminal::Config::from_term(&self.file)?;
        config.update(settings);
        config.apply_to_term(&self.file)?;

        Ok(())
    }
}

impl Drop for AutoModeGuard {
    fn drop(&mut self) {
        let _ = self.initial.apply_to_term(&self.file);
    }
}
