embedded-charts 0.3.0

//! Builder pattern for axis configuration.

use crate::axes::{
    linear::LinearAxis,
    style::AxisStyle,
    ticks::{CustomTickGenerator, LinearTickGenerator},
    traits::{AxisValue, TickGenerator},
    AxisOrientation, AxisPosition,
};
use crate::error::ChartError;
use embedded_graphics::prelude::*;

/// Builder for creating linear axes with fluent configuration
#[derive(Debug)]
pub struct LinearAxisBuilder<T, C: PixelColor> {
    min: Option<T>,
    max: Option<T>,
    orientation: AxisOrientation,
    position: AxisPosition,
    tick_generator: LinearTickGenerator,
    style: AxisStyle<C>,
    show_line: bool,
    show_ticks: bool,
    show_labels: bool,
    show_grid: bool,
}

impl<T, C> LinearAxisBuilder<T, C>
where
    T: AxisValue,
    C: PixelColor + From<embedded_graphics::pixelcolor::Rgb565>,
{
    /// Create a new linear axis builder
    pub fn new(orientation: AxisOrientation, position: AxisPosition) -> Self {
        Self {
            min: None,
            max: None,
            orientation,
            position,
            tick_generator: LinearTickGenerator::new(5),
            style: AxisStyle::new(),
            show_line: true,
            show_ticks: true,
            show_labels: true,
            show_grid: false,
        }
    }

    /// Set the range of the axis
    pub fn range(mut self, min: T, max: T) -> Self {
        self.min = Some(min);
        self.max = Some(max);
        self
    }

    /// Set the minimum value
    pub fn min(mut self, min: T) -> Self {
        self.min = Some(min);
        self
    }

    /// Set the maximum value
    pub fn max(mut self, max: T) -> Self {
        self.max = Some(max);
        self
    }

    /// Set the number of ticks
    pub fn tick_count(mut self, count: usize) -> Self {
        <LinearTickGenerator as TickGenerator<T>>::set_preferred_tick_count(
            &mut self.tick_generator,
            count,
        );
        self
    }

    /// Enable minor ticks with the specified ratio
    pub fn with_minor_ticks(mut self, ratio: usize) -> Self {
        self.tick_generator = self.tick_generator.with_minor_ticks(ratio);
        self
    }

    /// Disable minor ticks
    pub fn without_minor_ticks(mut self) -> Self {
        self.tick_generator = self.tick_generator.without_minor_ticks();
        self
    }

    /// Set the axis style
    pub fn style(mut self, style: AxisStyle<C>) -> Self {
        self.style = style;
        self
    }

    /// Use minimal styling for small displays
    pub fn minimal_style(mut self) -> Self {
        self.style = AxisStyle::minimal();
        self
    }

    /// Use professional styling
    pub fn professional_style(mut self) -> Self {
        self.style = AxisStyle::professional();
        self
    }

    /// Enable or disable the axis line
    pub fn show_line(mut self, show: bool) -> Self {
        self.show_line = show;
        self
    }

    /// Enable or disable tick marks
    pub fn show_ticks(mut self, show: bool) -> Self {
        self.show_ticks = show;
        self
    }

    /// Enable or disable labels
    pub fn show_labels(mut self, show: bool) -> Self {
        self.show_labels = show;
        self
    }

    /// Enable or disable grid lines
    pub fn show_grid(mut self, show: bool) -> Self {
        self.show_grid = show;
        self
    }

    /// Build the linear axis
    pub fn build(self) -> Result<LinearAxis<T, C>, ChartError> {
        let min = self.min.ok_or(ChartError::ConfigurationError)?;
        let max = self.max.ok_or(ChartError::ConfigurationError)?;

        if min.to_f32() >= max.to_f32() {
            return Err(ChartError::ConfigurationError);
        }

        let axis = LinearAxis::new(min, max, self.orientation, self.position)
            .with_tick_generator(self.tick_generator)
            .with_style(self.style)
            .show_line(self.show_line)
            .show_ticks(self.show_ticks)
            .show_labels(self.show_labels)
            .show_grid(self.show_grid);

        Ok(axis)
    }
}

/// Builder for creating custom axes with manually specified ticks
#[derive(Debug)]
pub struct CustomAxisBuilder<T, C: PixelColor> {
    min: Option<T>,
    max: Option<T>,
    orientation: AxisOrientation,
    position: AxisPosition,
    tick_generator: CustomTickGenerator<T>,
    style: AxisStyle<C>,
    show_line: bool,
    show_ticks: bool,
    show_labels: bool,
    show_grid: bool,
}

impl<T, C> CustomAxisBuilder<T, C>
where
    T: AxisValue,
    C: PixelColor + From<embedded_graphics::pixelcolor::Rgb565>,
{
    /// Create a new custom axis builder
    pub fn new(orientation: AxisOrientation, position: AxisPosition) -> Self {
        Self {
            min: None,
            max: None,
            orientation,
            position,
            tick_generator: CustomTickGenerator::new(),
            style: AxisStyle::new(),
            show_line: true,
            show_ticks: true,
            show_labels: true,
            show_grid: false,
        }
    }

    /// Set the range of the axis
    pub fn range(mut self, min: T, max: T) -> Self {
        self.min = Some(min);
        self.max = Some(max);
        self
    }

    /// Add a major tick with a label
    pub fn add_major_tick(mut self, value: T, label: &str) -> Self {
        self.tick_generator = self.tick_generator.add_major_tick(value, label);
        self
    }

    /// Add a minor tick
    pub fn add_minor_tick(mut self, value: T) -> Self {
        self.tick_generator = self.tick_generator.add_minor_tick(value);
        self
    }

    /// Set the axis style
    pub fn style(mut self, style: AxisStyle<C>) -> Self {
        self.style = style;
        self
    }

    /// Enable or disable the axis line
    pub fn show_line(mut self, show: bool) -> Self {
        self.show_line = show;
        self
    }

    /// Enable or disable tick marks
    pub fn show_ticks(mut self, show: bool) -> Self {
        self.show_ticks = show;
        self
    }

    /// Enable or disable labels
    pub fn show_labels(mut self, show: bool) -> Self {
        self.show_labels = show;
        self
    }

    /// Enable or disable grid lines
    pub fn show_grid(mut self, show: bool) -> Self {
        self.show_grid = show;
        self
    }

    /// Build the custom axis (returns a LinearAxis with custom tick generator)
    pub fn build(self) -> Result<LinearAxis<T, C>, ChartError> {
        let min = self.min.ok_or(ChartError::ConfigurationError)?;
        let max = self.max.ok_or(ChartError::ConfigurationError)?;

        if min.to_f32() >= max.to_f32() {
            return Err(ChartError::ConfigurationError);
        }

        // Create a linear axis and replace its tick generator
        let axis = LinearAxis::new(min, max, self.orientation, self.position)
            .with_style(self.style)
            .show_line(self.show_line)
            .show_ticks(self.show_ticks)
            .show_labels(self.show_labels)
            .show_grid(self.show_grid);

        // Note: In a full implementation, we'd need to modify LinearAxis to accept
        // different tick generator types. For now, this is a simplified version.

        Ok(axis)
    }
}

/// Convenience functions for creating common axis configurations
pub mod presets {
    use super::*;
    use embedded_graphics::pixelcolor::Rgb565;

    /// Create a standard X-axis at the bottom
    pub fn x_axis_bottom<T: AxisValue>(min: T, max: T) -> LinearAxisBuilder<T, Rgb565> {
        LinearAxisBuilder::new(AxisOrientation::Horizontal, AxisPosition::Bottom).range(min, max)
    }

    /// Create a standard Y-axis on the left
    pub fn y_axis_left<T: AxisValue>(min: T, max: T) -> LinearAxisBuilder<T, Rgb565> {
        LinearAxisBuilder::new(AxisOrientation::Vertical, AxisPosition::Left).range(min, max)
    }

    /// Create a minimal X-axis for small displays
    pub fn minimal_x_axis<T: AxisValue>(min: T, max: T) -> LinearAxisBuilder<T, Rgb565> {
        x_axis_bottom(min, max)
            .minimal_style()
            .tick_count(3)
            .without_minor_ticks()
    }

    /// Create a minimal Y-axis for small displays
    pub fn minimal_y_axis<T: AxisValue>(min: T, max: T) -> LinearAxisBuilder<T, Rgb565> {
        y_axis_left(min, max)
            .minimal_style()
            .tick_count(3)
            .without_minor_ticks()
    }

    /// Create a professional X-axis with grid
    pub fn professional_x_axis<T: AxisValue>(min: T, max: T) -> LinearAxisBuilder<T, Rgb565> {
        x_axis_bottom(min, max)
            .professional_style()
            .show_grid(true)
            .with_minor_ticks(4)
    }

    /// Create a professional Y-axis with grid
    pub fn professional_y_axis<T: AxisValue>(min: T, max: T) -> LinearAxisBuilder<T, Rgb565> {
        y_axis_left(min, max)
            .professional_style()
            .show_grid(true)
            .with_minor_ticks(4)
    }

    /// Create a time-series X-axis (horizontal, bottom)
    pub fn time_axis<T: AxisValue>(start: T, end: T) -> LinearAxisBuilder<T, Rgb565> {
        x_axis_bottom(start, end).tick_count(6).show_grid(true)
    }

    /// Create a percentage Y-axis (0-100)
    pub fn percentage_axis() -> LinearAxisBuilder<f32, Rgb565> {
        y_axis_left(0.0, 100.0).tick_count(6).show_grid(true)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::axes::traits::Axis;
    use embedded_graphics::pixelcolor::Rgb565;

    #[test]
    fn test_linear_axis_builder() {
        let axis = LinearAxisBuilder::<f32, Rgb565>::new(
            AxisOrientation::Horizontal,
            AxisPosition::Bottom,
        )
        .range(0.0f32, 10.0f32)
        .tick_count(5)
        .show_grid(true)
        .build()
        .unwrap();

        assert_eq!(axis.min(), 0.0);
        assert_eq!(axis.max(), 10.0);
        assert_eq!(axis.orientation(), AxisOrientation::Horizontal);
    }

    #[test]
    fn test_builder_validation() {
        // Missing range should fail
        let result = LinearAxisBuilder::<f32, Rgb565>::new(
            AxisOrientation::Horizontal,
            AxisPosition::Bottom,
        )
        .tick_count(5)
        .build();
        assert!(result.is_err());

        // Invalid range should fail
        let result = LinearAxisBuilder::<f32, Rgb565>::new(
            AxisOrientation::Horizontal,
            AxisPosition::Bottom,
        )
        .range(10.0f32, 5.0f32)
        .build();
        assert!(result.is_err());
    }

    #[test]
    fn test_custom_axis_builder() {
        let axis =
            CustomAxisBuilder::<f32, Rgb565>::new(AxisOrientation::Vertical, AxisPosition::Left)
                .range(0.0f32, 100.0f32)
                .add_major_tick(0.0, "0%")
                .add_major_tick(50.0, "50%")
                .add_major_tick(100.0, "100%")
                .add_minor_tick(25.0)
                .add_minor_tick(75.0)
                .build()
                .unwrap();

        assert_eq!(axis.min(), 0.0);
        assert_eq!(axis.max(), 100.0);
    }

    #[test]
    fn test_preset_axes() {
        let x_axis = presets::x_axis_bottom(0.0f32, 10.0f32).build().unwrap();
        assert_eq!(x_axis.orientation(), AxisOrientation::Horizontal);
        assert_eq!(x_axis.position(), AxisPosition::Bottom);

        let y_axis = presets::y_axis_left(-5.0f32, 5.0f32).build().unwrap();
        assert_eq!(y_axis.orientation(), AxisOrientation::Vertical);
        assert_eq!(y_axis.position(), AxisPosition::Left);
    }

    #[test]
    fn test_minimal_preset() {
        let _axis: LinearAxis<f32, Rgb565> =
            presets::minimal_x_axis(0.0f32, 100.0f32).build().unwrap();
        // Note: Tick generator test commented out due to type inference issues
        // assert_eq!(axis.tick_generator().preferred_tick_count(), 3);
    }

    #[test]
    fn test_professional_preset() {
        let _axis = presets::professional_y_axis(0.0f32, 1000.0f32)
            .build()
            .unwrap();
        // Professional style should have grid enabled
        // Note: We'd need to expose the config to test this properly
    }
}