use super::colors::Color;
use super::types::Float;

#[derive(Copy, Clone, PartialEq, Debug)]
#[non_exhaustive]
pub enum Pattern {
    Solid(Color),
    None,
}

impl Pattern {
    pub fn is_none(&self) -> bool {
        matches!(self, Pattern::None)
    }
}

impl Default for Pattern {
    fn default() -> Self {
        Pattern::Solid(Color::default())
    }
}

#[derive(Clone, PartialEq, Debug)]
pub struct FillStyle {
    pub(crate) pattern: Pattern,
}

impl FillStyle {
    pub fn solid(color: Color) -> Self {
        FillStyle {
            pattern: Pattern::Solid(color),
        }
    }

    pub fn pattern(&self) -> Pattern {
        self.pattern
    }

    pub fn set_pattern(&mut self, pattern: Pattern) {
        self.pattern = pattern;
    }
}

impl Default for FillStyle {
    fn default() -> Self {
        FillStyle {
            pattern: Pattern::None,
        }
    }
}

// TODO: probably move Float into an enum with Defined(f64) and Variable(handle)
#[derive(Clone, Debug)]
pub struct StrokeStyle {
    pub(crate) pattern: Pattern,
    pub(crate) dash: Option<DashStyle>,
    pub(crate) line_width: Option<Float>,
}

impl StrokeStyle {
    pub fn solid(color: Color) -> Self {
        StrokeStyle {
            pattern: Pattern::Solid(color),
            dash: None,
            line_width: None,
        }
    }

    pub fn builder() -> StrokeStyleBuilder {
        StrokeStyleBuilder::default()
    }

    pub fn pattern(&self) -> Pattern {
        self.pattern
    }

    pub fn set_pattern(&mut self, pattern: Pattern) {
        self.pattern = pattern;
    }

    pub fn dash(&self) -> Option<&DashStyle> {
        self.dash.as_ref()
    }

    pub fn set_dash(&mut self, dash: Option<DashStyle>) {
        self.dash = dash;
    }

    pub fn line_width(&self) -> Option<Float> {
        self.line_width
    }

    pub fn set_line_width(&mut self, line_width: Option<Float>) {
        self.line_width = line_width;
    }
}

impl Default for StrokeStyle {
    fn default() -> Self {
        Self::builder().build()
    }
}

#[derive(Clone, Default)]
pub struct StrokeStyleBuilder {
    pattern: Option<Pattern>,
    dash: Option<DashStyle>,
    line_width: Option<Float>,
}

impl StrokeStyleBuilder {
    pub fn pattern(&mut self, pattern: Pattern) -> &mut Self {
        self.pattern = Some(pattern);
        self
    }

    pub fn dash(&mut self, dash: DashStyle) -> &mut Self {
        self.dash = Some(dash);
        self
    }

    pub fn line_width(&mut self, width: Float) -> &mut Self {
        self.line_width = Some(width);
        self
    }

    pub fn build(&mut self) -> StrokeStyle {
        StrokeStyle {
            pattern: self.pattern.unwrap_or_default(),
            dash: self.dash.clone(),
            line_width: self.line_width,
        }
    }

}

#[derive(Clone, Debug, Default)]
pub struct DashStyle {
    pub(crate) dashes: Vec<Float>,
    pub(crate) offset: Float,
}

impl DashStyle {
    pub fn new(dashes: Vec<Float>, offset: Float) -> Self {
        Self { dashes, offset }
    }

    pub fn dashes(&self) -> &[Float] {
        &self.dashes
    }

    pub fn dashes_mut(&mut self) -> &mut Vec<Float> {
        &mut self.dashes
    }

    pub fn offset(&self) -> Float {
        self.offset
    }

    // TODO: does this makes sense?
    pub fn offset_mut(&mut self) -> &mut Float {
        &mut self.offset
    }
}

#[derive(Clone, PartialEq, Debug, Default)]
pub struct DefinedStrokeStyle {
    pub(crate) pattern: Pattern,
    pub(crate) dash: Option<DefinedDashStyle>,
    pub(crate) line_width: f64,
}

#[derive(Clone, PartialEq, Debug, Default)]
pub struct DefinedDashStyle {
    pub(crate) dashes: Vec<f64>,
    pub(crate) offset: f64,
}

impl DefinedDashStyle {
    pub fn dashes(&self) -> &[f64] {
        &self.dashes
    }

    pub fn offset(&self) -> f64 {
        self.offset
    }
}