matchmaker/

config.rs

//! Config Types.
//! See `src/bin/mm/config.rs` for an example

use std::{fmt, ops::Deref};

use crate::MAX_SPLITS;
use crate::{Result, action::Count, tui::IoStream};

use ratatui::style::Style;
use ratatui::text::Span;
use ratatui::{
    style::{Color, Modifier},
    widgets::{BorderType, Borders, Padding},
};
use regex::Regex;
use serde::de::IntoDeserializer;
use serde::ser::SerializeSeq;
use serde::{
    Deserialize, Deserializer,
    de::{self, Visitor},
};
use serde::{Serialize, Serializer};

pub use crate::utils::{
    Percentage,
    serde::{StringOrVec, escaped_opt_char, escaped_opt_string, serde_duration_ms},
};

/// Settings unrelated to event loop/picker_ui.
///
/// Does not deny unknown fields.
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MatcherConfig {
    #[serde(flatten)]
    pub matcher: NucleoMatcherConfig,
    #[serde(flatten)]
    pub worker: WorkerConfig,
    // only nit is that we would really prefer this config sit at top level since its irrelevant to [`crate::Matchmaker::new_from_config`] but it makes more sense under matcher in the config file
    #[serde(flatten)]
    pub start: StartConfig,
}

/// "Input/output specific". Configures the matchmaker worker.
///
/// Does not deny unknown fields.
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct WorkerConfig {
    pub columns: ColumnsConfig,
    #[serde(flatten)]
    pub exit: ExitConfig,
    pub trim: bool,           // todo
    pub format: FormatString, // todo: implement
}

/// Configures how input is fed to to the worker(s).
///
/// Does not deny unknown fields.
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct StartConfig {
    #[serde(default, deserialize_with = "escaped_opt_char")]
    pub input_separator: Option<char>,
    #[serde(default, deserialize_with = "escaped_opt_string")]
    pub output_separator: Option<String>,
    pub default_command: String,
    pub sync: bool,
}

/// Exit conditions of the render loop.
///
/// Does not deny unknown fields.
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct ExitConfig {
    pub select_1: bool,
    pub allow_empty: bool,
}

/// The ui config.
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct RenderConfig {
    pub ui: UiConfig,
    pub input: InputConfig,
    pub results: ResultsConfig,
    pub preview: PreviewConfig,
    pub footer: DisplayConfig,
    pub header: DisplayConfig,
    pub overlay: Option<OverlayConfig>, // pub overlay: OverlayConfig // overlay_config is seperate due to specificity
}

impl RenderConfig {
    pub fn tick_rate(&self) -> u8 {
        self.ui.tick_rate
    }
}

/// Terminal settings.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct TerminalConfig {
    pub stream: IoStream, // consumed
    pub restore_fullscreen: bool,
    pub redraw_on_resize: bool,
    // https://docs.rs/crossterm/latest/crossterm/event/struct.PushKeyboardEnhancementFlags.html
    pub extended_keys: bool,
    #[serde(with = "serde_duration_ms")]
    pub sleep_ms: std::time::Duration, // necessary to give ratatui a small delay before resizing after entering and exiting
    // todo: lowpri: will need a value which can deserialize to none when implementing cli parsing
    #[serde(flatten)]
    pub layout: Option<TerminalLayoutSettings>, // None for fullscreen
}

impl Default for TerminalConfig {
    fn default() -> Self {
        Self {
            stream: IoStream::default(),
            restore_fullscreen: true,
            redraw_on_resize: bool::default(),
            sleep_ms: std::time::Duration::default(),
            layout: Option::default(),
            extended_keys: true,
        }
    }
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct TerminalSettings {}

/// The container ui.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct UiConfig {
    pub border: BorderSetting,
    pub tick_rate: u8, // seperate from render, but best place ig
}

impl Default for UiConfig {
    fn default() -> Self {
        Self {
            border: Default::default(),
            tick_rate: 60,
        }
    }
}

/// The input bar ui.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct InputConfig {
    pub border: BorderSetting,

    // text styles
    pub fg: Color,
    #[serde(
        deserialize_with = "deserialize_modifier",
        serialize_with = "serialize_modifier"
    )]
    pub modifier: Modifier,

    pub prompt_fg: Color,
    #[serde(
        deserialize_with = "deserialize_modifier",
        serialize_with = "serialize_modifier"
    )]
    pub prompt_modifier: Modifier,

    #[serde(deserialize_with = "deserialize_string_or_char_as_double_width")]
    pub prompt: String,
    pub cursor: CursorSetting,
    pub initial: String,
}

impl Default for InputConfig {
    fn default() -> Self {
        Self {
            border: Default::default(),
            fg: Default::default(),
            modifier: Default::default(),
            prompt_fg: Default::default(),
            prompt_modifier: Default::default(),
            prompt: "> ".to_string(),
            cursor: Default::default(),
            initial: Default::default(),
        }
    }
}

#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct OverlayConfig {
    pub border: BorderSetting,
    pub outer_dim: bool,
    pub layout: OverlayLayoutSettings,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OverlayLayoutSettings {
    /// w, h
    pub percentage: [Percentage; 2],
    /// w, h
    pub min: [u16; 2],
    /// w, h
    pub max: [u16; 2],
}

impl Default for OverlayLayoutSettings {
    fn default() -> Self {
        Self {
            percentage: [Percentage::new(60), Percentage::new(30)],
            min: [10, 5],
            max: [200, 30],
        }
    }
}

// pub struct OverlaySize

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct ResultsConfig {
    pub border: BorderSetting,

    // prefixes
    #[serde(deserialize_with = "deserialize_string_or_char_as_double_width")]
    pub multi_prefix: String,
    pub default_prefix: String,

    // text styles
    pub fg: Color,
    #[serde(
        deserialize_with = "deserialize_modifier",
        serialize_with = "serialize_modifier"
    )]
    pub modifier: Modifier,

    #[serde(default = "default_green")]
    pub match_fg: Color,
    #[serde(
        deserialize_with = "deserialize_modifier",
        serialize_with = "serialize_modifier"
    )]
    pub match_modifier: Modifier,

    pub current_fg: Color,
    #[serde(default = "default_black")]
    pub current_bg: Color,
    #[serde(
        deserialize_with = "deserialize_modifier",
        serialize_with = "serialize_modifier",
        default = "default_bold"
    )]
    pub current_modifier: Modifier,

    // status
    #[serde(default = "default_green")]
    pub count_fg: Color,
    #[serde(
        deserialize_with = "deserialize_modifier",
        serialize_with = "serialize_modifier",
        default = "default_italic"
    )]
    pub count_modifier: Modifier,

    // todo(?): lowpri
    // pub selected_fg: Color,
    // pub selected_bg: Color,
    // pub selected_modifier: Color,

    // scroll
    #[serde(default = "default_true")]
    pub scroll_wrap: bool,
    pub scroll_padding: u16,
    #[serde(deserialize_with = "deserialize_option_auto")]
    pub reverse: Option<bool>,

    // wrap
    pub wrap: bool,
    pub wrap_scaling_min_width: u8,

    // experimental
    pub column_spacing: Count,
    pub current_prefix: String,
    pub right_align_last: bool,
}

impl Default for ResultsConfig {
    fn default() -> Self {
        ResultsConfig {
            border: Default::default(),

            multi_prefix: "▌ ".to_string(),
            default_prefix: Default::default(),

            fg: Default::default(),
            modifier: Default::default(), // or whatever your deserialize_modifier default function returns
            match_fg: default_green(),
            match_modifier: default_italic(),

            current_fg: Default::default(),
            current_bg: default_black(),
            current_modifier: default_bold(),

            count_fg: default_green(),
            count_modifier: default_italic(),

            scroll_wrap: default_true(),
            scroll_padding: 2,
            reverse: None,

            wrap: Default::default(),
            wrap_scaling_min_width: 5,

            column_spacing: Default::default(),
            current_prefix: Default::default(),
            right_align_last: true,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct DisplayConfig {
    pub border: BorderSetting,

    #[serde(default = "default_green")]
    pub fg: Color,
    #[serde(
        deserialize_with = "deserialize_modifier",
        serialize_with = "serialize_modifier",
        default = "default_italic"
    )]
    pub modifier: Modifier,

    #[serde(default = "default_true")]
    pub match_indent: bool,
    pub wrap: bool,
    #[serde(deserialize_with = "deserialize_option_auto")]
    pub content: Option<StringOrVec>,
}

impl Default for DisplayConfig {
    fn default() -> Self {
        DisplayConfig {
            border: Default::default(),
            match_indent: true,
            fg: default_green(),
            wrap: false,
            modifier: default_italic(), // whatever your `deserialize_modifier` default uses
            content: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct PreviewConfig {
    pub border: BorderSetting,

    pub layout: Vec<PreviewSetting>,
    #[serde(default = "default_true")]
    pub scroll_wrap: bool,
    pub wrap: bool,
    pub show: bool,
}

impl Default for PreviewConfig {
    fn default() -> Self {
        PreviewConfig {
            border: BorderSetting {
                padding: Padding::left(2),
                ..Default::default()
            },
            // layout: vec![
            // PreviewSetting {
            //     layout: PreviewLayoutSetting::default(),
            //     command: String::new()
            // }
            // ],
            layout: Default::default(),
            scroll_wrap: true,
            wrap: Default::default(),
            show: Default::default(),
        }
    }
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct PreviewerConfig {
    pub try_lossy: bool,

    // todo
    pub cache: u8,

    #[serde(default)]
    pub help_colors: TomlColorConfig,
}

/// Help coloring
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TomlColorConfig {
    pub section: Color,
    pub key: Color,
    pub string: Color,
    pub number: Color,
    pub section_bold: bool,
}

impl Default for TomlColorConfig {
    fn default() -> Self {
        Self {
            section: Color::Blue,
            key: Color::Yellow,
            string: Color::Green,
            number: Color::Cyan,
            section_bold: true,
        }
    }
}

// ----------- SETTING TYPES -------------------------
// Default config file -> write if not exists, then load

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct FormatString(String);

impl Deref for FormatString {
    type Target = str;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct BorderSetting {
    #[serde(with = "crate::utils::serde::fromstr")]
    pub r#type: BorderType,
    pub color: Color,
    #[serde(
        serialize_with = "serialize_borders",
        deserialize_with = "deserialize_borders"
    )]
    pub sides: Borders,
    #[serde(
        serialize_with = "serialize_padding",
        deserialize_with = "deserialize_padding"
    )]
    pub padding: Padding,
    pub title: String,
    #[serde(
        deserialize_with = "deserialize_modifier",
        serialize_with = "serialize_modifier"
    )]
    pub title_modifier: Modifier,
    pub bg: Color,
}

impl BorderSetting {
    pub fn as_block(&self) -> ratatui::widgets::Block<'_> {
        let mut ret = ratatui::widgets::Block::default()
            .padding(self.padding)
            .style(Style::default().bg(self.bg));

        if !self.title.is_empty() {
            let title = Span::styled(
                &self.title,
                Style::default().add_modifier(self.title_modifier),
            );

            ret = ret.title(title)
        };

        if self.sides != Borders::NONE {
            ret = ret
                .borders(self.sides)
                .border_type(self.r#type)
                .border_style(ratatui::style::Style::default().fg(self.color))
        }

        ret
    }

    pub fn as_static_block(&self) -> ratatui::widgets::Block<'static> {
        let mut ret = ratatui::widgets::Block::default()
            .padding(self.padding)
            .style(Style::default().bg(self.bg));

        if !self.title.is_empty() {
            let title: Span<'static> = Span::styled(
                self.title.clone(),
                Style::default().add_modifier(self.title_modifier),
            );

            ret = ret.title(title)
        };

        if self.sides != Borders::NONE {
            ret = ret
                .borders(self.sides)
                .border_type(self.r#type)
                .border_style(ratatui::style::Style::default().fg(self.color))
        }

        ret
    }

    pub fn height(&self) -> u16 {
        let mut height = 0;
        height += 2 * !self.sides.is_empty() as u16;
        height += self.padding.top + self.padding.bottom;
        height += (!self.title.is_empty() as u16).saturating_sub(!self.sides.is_empty() as u16);

        height
    }

    pub fn width(&self) -> u16 {
        let mut width = 0;
        width += 2 * !self.sides.is_empty() as u16;
        width += self.padding.left + self.padding.right;

        width
    }

    pub fn left(&self) -> u16 {
        let mut width = 0;
        width += !self.sides.is_empty() as u16;
        width += self.padding.left;

        width
    }

    pub fn top(&self) -> u16 {
        let mut height = 0;
        height += !self.sides.is_empty() as u16;
        height += self.padding.top;
        height += (!self.title.is_empty() as u16).saturating_sub(!self.sides.is_empty() as u16);

        height
    }
}

// how to determine how many rows to allocate?
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TerminalLayoutSettings {
    pub percentage: Percentage,
    pub min: u16,
    pub max: u16, // 0 for terminal height cap
}

impl Default for TerminalLayoutSettings {
    fn default() -> Self {
        Self {
            percentage: Percentage::new(50),
            min: 10,
            max: 120,
        }
    }
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Side {
    Top,
    Bottom,
    Left,
    #[default]
    Right,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PreviewSetting {
    #[serde(flatten)]
    pub layout: PreviewLayoutSetting,
    #[serde(default)]
    pub command: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PreviewLayoutSetting {
    pub side: Side,
    pub percentage: Percentage,
    pub min: i16,
    pub max: i16,
}

impl Default for PreviewLayoutSetting {
    fn default() -> Self {
        Self {
            side: Side::Right,
            percentage: Percentage::new(60),
            min: 30,
            max: 120,
        }
    }
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum CursorSetting {
    None,
    #[default]
    Default,
}

use crate::utils::serde::bounded_usize;
// todo: pass filter and hidden to mm
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct ColumnsConfig {
    pub split: Split,
    pub names: Vec<ColumnSetting>,
    #[serde(deserialize_with = "bounded_usize::<{crate::MAX_SPLITS},_>")]
    max_columns: usize,
}

impl ColumnsConfig {
    pub fn max_cols(&self) -> usize {
        self.max_columns.min(MAX_SPLITS)
    }
}

#[derive(Default, Debug, Clone, PartialEq)]
pub struct ColumnSetting {
    pub filter: bool,
    pub hidden: bool,
    pub name: String,
}

#[derive(Default, Debug, Clone)]
pub enum Split {
    Delimiter(Regex),
    Regexes(Vec<Regex>),
    #[default]
    None,
}

impl PartialEq for Split {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Split::Delimiter(r1), Split::Delimiter(r2)) => r1.as_str() == r2.as_str(),
            (Split::Regexes(v1), Split::Regexes(v2)) => {
                if v1.len() != v2.len() {
                    return false;
                }
                v1.iter()
                    .zip(v2.iter())
                    .all(|(r1, r2)| r1.as_str() == r2.as_str())
            }
            (Split::None, Split::None) => true,
            _ => false,
        }
    }
}

// --------- Deserialize Helpers ------------
pub fn serialize_borders<S>(borders: &Borders, serializer: S) -> Result<S::Ok, S::Error>
where
    S: serde::Serializer,
{
    use serde::ser::SerializeSeq;
    let mut seq = serializer.serialize_seq(None)?;
    if borders.contains(Borders::TOP) {
        seq.serialize_element("top")?;
    }
    if borders.contains(Borders::BOTTOM) {
        seq.serialize_element("bottom")?;
    }
    if borders.contains(Borders::LEFT) {
        seq.serialize_element("left")?;
    }
    if borders.contains(Borders::RIGHT) {
        seq.serialize_element("right")?;
    }
    seq.end()
}

pub fn deserialize_borders<'de, D>(deserializer: D) -> Result<Borders, D::Error>
where
    D: Deserializer<'de>,
{
    let input = StringOrVec::deserialize(deserializer)?;
    let mut borders = Borders::NONE;

    let borders = match input {
        StringOrVec::String(s) => match s.as_str() {
            "none" => Borders::NONE,
            "all" => Borders::ALL,
            other => {
                return Err(de::Error::custom(format!(
                    "invalid border value '{}'",
                    other
                )));
            }
        },
        StringOrVec::Vec(list) => {
            for item in list {
                match item.as_str() {
                    "top" => borders |= Borders::TOP,
                    "bottom" => borders |= Borders::BOTTOM,
                    "left" => borders |= Borders::LEFT,
                    "right" => borders |= Borders::RIGHT,
                    "all" => borders |= Borders::ALL,
                    "none" => borders = Borders::NONE,
                    other => return Err(de::Error::custom(format!("invalid side '{}'", other))),
                }
            }
            borders
        }
    };

    Ok(borders)
}

pub fn deserialize_borders_option<'de, D>(deserializer: D) -> Result<Option<Borders>, D::Error>
where
    D: Deserializer<'de>,
{
    let input = Option::<StringOrVec>::deserialize(deserializer)?;
    match input {
        Some(input) => {
            let mut borders = Borders::NONE;

            let borders = match input {
                StringOrVec::String(s) => match s.as_str() {
                    "none" => Borders::NONE,
                    "all" => Borders::ALL,
                    other => {
                        return Err(de::Error::custom(format!(
                            "invalid border value '{}'",
                            other
                        )));
                    }
                },
                StringOrVec::Vec(list) => {
                    for item in list {
                        match item.as_str() {
                            "top" => borders |= Borders::TOP,
                            "bottom" => borders |= Borders::BOTTOM,
                            "left" => borders |= Borders::LEFT,
                            "right" => borders |= Borders::RIGHT,
                            "all" => borders |= Borders::ALL,
                            "none" => borders = Borders::NONE,
                            other => {
                                return Err(de::Error::custom(format!("invalid side '{}'", other)));
                            }
                        }
                    }
                    borders
                }
            };

            Ok(Some(borders))
        }
        None => Ok(None),
    }
}

pub fn deserialize_modifier<'de, D>(deserializer: D) -> Result<Modifier, D::Error>
where
    D: Deserializer<'de>,
{
    let input = StringOrVec::deserialize(deserializer)?;
    let mut modifier = Modifier::empty();

    let add_modifier = |name: &str, m: &mut Modifier| -> Result<(), D::Error> {
        match name.to_lowercase().as_str() {
            "bold" => {
                *m |= Modifier::BOLD;
                Ok(())
            }
            "italic" => {
                *m |= Modifier::ITALIC;
                Ok(())
            }
            "underlined" => {
                *m |= Modifier::UNDERLINED;
                Ok(())
            }
            // "slow_blink" => {
            //     *m |= Modifier::SLOW_BLINK;
            //     Ok(())
            // }
            // "rapid_blink" => {
            //     *m |= Modifier::RAPID_BLINK;
            //     Ok(())
            // }
            // "reversed" => {
            //     *m |= Modifier::REVERSED;
            //     Ok(())
            // }
            // "dim" => {
            //     *m |= Modifier::DIM;
            //     Ok(())
            // }
            // "crossed_out" => {
            //     *m |= Modifier::CROSSED_OUT;
            //     Ok(())
            // }
            "none" => {
                *m = Modifier::empty();
                Ok(())
            } // reset all modifiers
            other => Err(de::Error::custom(format!("invalid modifier '{}'", other))),
        }
    };

    match input {
        StringOrVec::String(s) => add_modifier(&s, &mut modifier)?,
        StringOrVec::Vec(list) => {
            for item in list {
                add_modifier(&item, &mut modifier)?;
            }
        }
    }

    Ok(modifier)
}

pub fn serialize_modifier<S>(modifier: &Modifier, serializer: S) -> Result<S::Ok, S::Error>
where
    S: Serializer,
{
    let mut mods = Vec::new();

    if modifier.contains(Modifier::BOLD) {
        mods.push("bold");
    }
    if modifier.contains(Modifier::ITALIC) {
        mods.push("italic");
    }
    if modifier.contains(Modifier::UNDERLINED) {
        mods.push("underlined");
    }
    // add other flags if needed
    // if modifier.contains(Modifier::DIM) { mods.push("dim"); }

    match mods.len() {
        0 => serializer.serialize_str("none"),
        1 => serializer.serialize_str(mods[0]),
        _ => mods.serialize(serializer),
    }
}

pub fn deserialize_string_or_char_as_double_width<'de, D, T>(deserializer: D) -> Result<T, D::Error>
where
    D: Deserializer<'de>,
    T: From<String>,
{
    struct GenericVisitor<T> {
        _marker: std::marker::PhantomData<T>,
    }

    impl<'de, T> Visitor<'de> for GenericVisitor<T>
    where
        T: From<String>,
    {
        type Value = T;

        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
            formatter.write_str("a string or single character")
        }

        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
        where
            E: de::Error,
        {
            let s = if v.chars().count() == 1 {
                let mut s = String::with_capacity(2);
                s.push(v.chars().next().unwrap());
                s.push(' ');
                s
            } else {
                v.to_string()
            };
            Ok(T::from(s))
        }

        fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
        where
            E: de::Error,
        {
            self.visit_str(&v)
        }
    }

    deserializer.deserialize_string(GenericVisitor {
        _marker: std::marker::PhantomData,
    })
}

// ----------- Nucleo config helper
#[derive(Debug, Clone, PartialEq)]
pub struct NucleoMatcherConfig(pub nucleo::Config);

impl Default for NucleoMatcherConfig {
    fn default() -> Self {
        Self(nucleo::Config::DEFAULT)
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(default)]
#[derive(Default)]
struct MatcherConfigHelper {
    pub normalize: Option<bool>,
    pub ignore_case: Option<bool>,
    pub prefer_prefix: Option<bool>,
}

impl serde::Serialize for NucleoMatcherConfig {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        let helper = MatcherConfigHelper {
            normalize: Some(self.0.normalize),
            ignore_case: Some(self.0.ignore_case),
            prefer_prefix: Some(self.0.prefer_prefix),
        };
        helper.serialize(serializer)
    }
}

impl<'de> Deserialize<'de> for NucleoMatcherConfig {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let helper = MatcherConfigHelper::deserialize(deserializer)?;
        let mut config = nucleo::Config::DEFAULT;

        if let Some(norm) = helper.normalize {
            config.normalize = norm;
        }
        if let Some(ic) = helper.ignore_case {
            config.ignore_case = ic;
        }
        if let Some(pp) = helper.prefer_prefix {
            config.prefer_prefix = pp;
        }

        Ok(NucleoMatcherConfig(config))
    }
}

impl serde::Serialize for Split {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Split::Delimiter(r) => serializer.serialize_str(r.as_str()),
            Split::Regexes(rs) => {
                let mut seq = serializer.serialize_seq(Some(rs.len()))?;
                for r in rs {
                    seq.serialize_element(r.as_str())?;
                }
                seq.end()
            }
            Split::None => serializer.serialize_none(),
        }
    }
}

impl<'de> Deserialize<'de> for Split {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct SplitVisitor;

        impl<'de> Visitor<'de> for SplitVisitor {
            type Value = Split;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("string for delimiter or array of strings for regexes")
            }

            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
            where
                E: de::Error,
            {
                // Try to compile single regex
                Regex::new(value)
                    .map(Split::Delimiter)
                    .map_err(|e| E::custom(format!("Invalid regex: {}", e)))
            }

            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
            where
                A: serde::de::SeqAccess<'de>,
            {
                let mut regexes = Vec::new();
                while let Some(s) = seq.next_element::<String>()? {
                    let r = Regex::new(&s)
                        .map_err(|e| de::Error::custom(format!("Invalid regex: {}", e)))?;
                    regexes.push(r);
                }
                Ok(Split::Regexes(regexes))
            }
        }

        deserializer.deserialize_any(SplitVisitor)
    }
}

impl serde::Serialize for ColumnSetting {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut state = serializer.serialize_struct("ColumnSetting", 3)?;
        state.serialize_field("filter", &self.filter)?;
        state.serialize_field("hidden", &self.hidden)?;
        state.serialize_field("name", &self.name)?;
        state.end()
    }
}

impl<'de> Deserialize<'de> for ColumnSetting {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        #[derive(Deserialize)]
        #[serde(deny_unknown_fields)]
        struct ColumnStruct {
            #[serde(default = "default_true")]
            filter: bool,
            #[serde(default)]
            hidden: bool,
            name: String,
        }

        fn default_true() -> bool {
            true
        }

        #[derive(Deserialize)]
        #[serde(untagged)]
        enum Input {
            Str(String),
            Obj(ColumnStruct),
        }

        match Input::deserialize(deserializer)? {
            Input::Str(name) => Ok(ColumnSetting {
                filter: true,
                hidden: false,
                name,
            }),
            Input::Obj(obj) => Ok(ColumnSetting {
                filter: obj.filter,
                hidden: obj.hidden,
                name: obj.name,
            }),
        }
    }
}

pub fn serialize_padding<S>(padding: &Padding, serializer: S) -> Result<S::Ok, S::Error>
where
    S: serde::Serializer,
{
    use serde::ser::SerializeSeq;
    if padding.top == padding.bottom && padding.left == padding.right && padding.top == padding.left
    {
        serializer.serialize_u16(padding.top)
    } else if padding.top == padding.bottom && padding.left == padding.right {
        let mut seq = serializer.serialize_seq(Some(2))?;
        seq.serialize_element(&padding.left)?;
        seq.serialize_element(&padding.top)?;
        seq.end()
    } else {
        let mut seq = serializer.serialize_seq(Some(4))?;
        seq.serialize_element(&padding.top)?;
        seq.serialize_element(&padding.right)?;
        seq.serialize_element(&padding.bottom)?;
        seq.serialize_element(&padding.left)?;
        seq.end()
    }
}

pub fn deserialize_padding<'de, D>(deserializer: D) -> Result<Padding, D::Error>
where
    D: Deserializer<'de>,
{
    struct PaddingVisitor;

    impl<'de> Visitor<'de> for PaddingVisitor {
        type Value = Padding;

        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
            formatter.write_str("a number or an array of 1, 2, or 4 numbers")
        }

        fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
        where
            E: de::Error,
        {
            let v = u16::try_from(value).map_err(|_| {
                E::custom(format!("padding value {} is out of range for u16", value))
            })?;

            Ok(Padding {
                top: v,
                right: v,
                bottom: v,
                left: v,
            })
        }

        fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
        where
            E: de::Error,
        {
            let v = u16::try_from(value).map_err(|_| {
                E::custom(format!("padding value {} is out of range for u16", value))
            })?;

            Ok(Padding {
                top: v,
                right: v,
                bottom: v,
                left: v,
            })
        }

        // 3. Handle Sequences (Arrays)
        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
        where
            A: de::SeqAccess<'de>,
        {
            let first: u16 = seq
                .next_element()?
                .ok_or_else(|| de::Error::invalid_length(0, &self))?;

            let second: Option<u16> = seq.next_element()?;
            let third: Option<u16> = seq.next_element()?;
            let fourth: Option<u16> = seq.next_element()?;

            match (second, third, fourth) {
                (None, None, None) => Ok(Padding {
                    top: first,
                    right: first,
                    bottom: first,
                    left: first,
                }),
                (Some(v2), None, None) => Ok(Padding {
                    top: first,
                    bottom: first,
                    left: v2,
                    right: v2,
                }),
                (Some(v2), Some(v3), Some(v4)) => Ok(Padding {
                    top: first,
                    right: v2,
                    bottom: v3,
                    left: v4,
                }),
                _ => Err(de::Error::invalid_length(3, &self)),
            }
        }
    }

    deserializer.deserialize_any(PaddingVisitor)
}

pub fn deserialize_option_auto<'de, D, T>(deserializer: D) -> Result<Option<T>, D::Error>
where
    D: serde::Deserializer<'de>,
    T: Deserialize<'de>,
{
    let opt = Option::<String>::deserialize(deserializer)?;
    match opt.as_deref() {
        Some("auto") => Ok(None),
        Some(s) => Ok(Some(T::deserialize(s.into_deserializer())?)),
        None => Ok(None),
    }
}

impl<'de> Deserialize<'de> for BorderSetting {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        #[derive(Deserialize)]
        struct Helper {
            #[serde(default)]
            r#type: Option<String>,
            #[serde(default)]
            color: Option<Color>,
            #[serde(default, deserialize_with = "deserialize_borders_option")]
            sides: Option<Borders>, // <-- raw string first
            #[serde(default, deserialize_with = "deserialize_padding")]
            padding: Padding,
            #[serde(default)]
            title: String,
            #[serde(
                default,
                deserialize_with = "deserialize_modifier",
                serialize_with = "serialize_modifier"
            )]
            title_modifier: Modifier,
            #[serde(default)]
            bg: Color,
        }

        let h = Helper::deserialize(deserializer)?;

        // parse type
        let r#type = match h.r#type {
            Some(ref s) => s.parse::<BorderType>().map_err(serde::de::Error::custom)?,
            None => BorderType::default(),
        };

        // parse sides: if type or color is specified, override to ALL
        let sides = if let Some(sides) = h.sides {
            sides
        } else if h.r#type.is_some() || h.color.is_some() {
            Borders::ALL
        } else {
            Borders::NONE
        };

        Ok(BorderSetting {
            r#type,
            color: h.color.unwrap_or_default(),
            sides,
            padding: h.padding,
            title: h.title,
            title_modifier: h.title_modifier,
            bg: h.bg,
        })
    }
}

// --------------------------- DEFAULTS

fn default_true() -> bool {
    true
}

fn default_black() -> Color {
    Color::Black
}

fn default_green() -> Color {
    Color::Green
}

fn default_bold() -> Modifier {
    Modifier::BOLD
}

fn default_italic() -> Modifier {
    Modifier::ITALIC
}