//! This module contains a configuration of a Border to set its color via [`BorderColor`].

use crate::{
    grid::{
        color::AnsiColor,
        config::{Border, ColoredConfig, Entity},
        records::{ExactRecords, Records},
    },
    settings::{color::Color, CellOption, TableOption},
};

/// BorderColored represents a colored border of a Cell.
///
/// ```rust,no_run
/// # use tabled::{settings::{style::BorderColor, Style, Color, object::Rows, Modify}, Table};
/// #
/// # let data: Vec<&'static str> = Vec::new();
/// #
/// let table = Table::new(&data)
///     .with(Style::ascii())
///     .with(Modify::new(Rows::single(0)).with(BorderColor::default().top(Color::FG_RED)));
/// ```
#[derive(Debug, Clone, Default, Eq, PartialEq)]
pub struct BorderColor(Border<AnsiColor<'static>>);

impl BorderColor {
    /// This function constructs a cell borders with all sides set.
    #[allow(clippy::too_many_arguments)]
    pub fn full(
        top: Color,
        bottom: Color,
        left: Color,
        right: Color,
        top_left: Color,
        top_right: Color,
        bottom_left: Color,
        bottom_right: Color,
    ) -> Self {
        Self(Border::full(
            top.into(),
            bottom.into(),
            left.into(),
            right.into(),
            top_left.into(),
            top_right.into(),
            bottom_left.into(),
            bottom_right.into(),
        ))
    }

    /// This function constructs a cell borders with all sides's char set to a given character.
    /// It behaves like [`Border::full`] with the same character set to each side.
    pub fn filled(c: Color) -> Self {
        let c: AnsiColor<'_> = c.into();

        Self(Border {
            top: Some(c.clone()),
            bottom: Some(c.clone()),
            left: Some(c.clone()),
            right: Some(c.clone()),
            left_bottom_corner: Some(c.clone()),
            left_top_corner: Some(c.clone()),
            right_bottom_corner: Some(c.clone()),
            right_top_corner: Some(c),
        })
    }

    /// Set a top border character.
    pub fn top(mut self, c: Color) -> Self {
        self.0.top = Some(c.into());
        self
    }

    /// Set a bottom border character.
    pub fn bottom(mut self, c: Color) -> Self {
        self.0.bottom = Some(c.into());
        self
    }

    /// Set a left border character.
    pub fn left(mut self, c: Color) -> Self {
        self.0.left = Some(c.into());
        self
    }

    /// Set a right border character.
    pub fn right(mut self, c: Color) -> Self {
        self.0.right = Some(c.into());
        self
    }

    /// Set a top left intersection character.
    pub fn corner_top_left(mut self, c: Color) -> Self {
        self.0.left_top_corner = Some(c.into());
        self
    }

    /// Set a top right intersection character.
    pub fn corner_top_right(mut self, c: Color) -> Self {
        self.0.right_top_corner = Some(c.into());
        self
    }

    /// Set a bottom left intersection character.
    pub fn corner_bottom_left(mut self, c: Color) -> Self {
        self.0.left_bottom_corner = Some(c.into());
        self
    }

    /// Set a bottom right intersection character.
    pub fn corner_bottom_right(mut self, c: Color) -> Self {
        self.0.right_bottom_corner = Some(c.into());
        self
    }
}

impl<R> CellOption<R, ColoredConfig> for BorderColor
where
    R: Records + ExactRecords,
{
    fn change(self, records: &mut R, cfg: &mut ColoredConfig, entity: Entity) {
        let count_rows = records.count_rows();
        let count_columns = records.count_columns();

        let border_color = &self.0;

        for pos in entity.iter(count_rows, count_columns) {
            cfg.set_border_color(pos, border_color.clone());
        }
    }
}

impl<R, D> TableOption<R, D, ColoredConfig> for BorderColor
where
    R: Records + ExactRecords,
{
    fn change(self, records: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
        let count_rows = records.count_rows();
        let count_columns = records.count_columns();

        let border_color = &self.0;

        for row in 0..count_rows {
            for col in 0..count_columns {
                cfg.set_border_color((row, col), border_color.clone());
            }
        }
    }
}

impl From<BorderColor> for Border<AnsiColor<'static>> {
    fn from(val: BorderColor) -> Self {
        val.0
    }
}