ruviz 0.7.0

//! Plot configuration system for DPI-independent rendering
//!
//! This module provides a comprehensive configuration system that uses physical
//! units (inches for dimensions, points for typography) to ensure consistent
//! proportions regardless of output DPI.
//!
//! # Design Philosophy
//!
//! - **Figure size** is in inches (like matplotlib's `figsize`)
//! - **Typography** is in points (1 point = 1/72 inch)
//! - **DPI** only affects output resolution, not proportions
//!
//! # Example
//!
//! ```rust,ignore
//! use ruviz::core::{PlotConfig, FigureConfig, TypographyConfig};
//!
//! // Using defaults (matplotlib-compatible)
//! let config = PlotConfig::default();
//!
//! // Custom configuration
//! let config = PlotConfig::builder()
//!     .figure(8.0, 6.0)
//!     .dpi(300.0)
//!     .typography(|t| t.base_size(12.0))
//!     .build();
//! ```

use crate::core::units::{REFERENCE_DPI, RenderScale, in_to_px, pt_to_px, px_to_in};
use crate::core::{PlottingError, Result};
use crate::render::{FontFamily, FontWeight};

/// Default autoscale margin added to each side of an auto-scaled axis.
///
/// Expressed as a fraction of the data span, matching matplotlib's
/// `rcParams["axes.xmargin"]` / `rcParams["axes.ymargin"]` default of 0.05.
pub const DEFAULT_AUTOSCALE_MARGIN: f64 = 0.05;

// =============================================================================
// Figure Configuration
// =============================================================================

/// Figure size and resolution configuration
///
/// Dimensions are specified in inches for DPI-independent layout.
/// The DPI setting only affects the output pixel resolution.
#[derive(Debug, Clone, PartialEq)]
pub struct FigureConfig {
    /// Figure width in inches (default: 6.4)
    pub width: f32,
    /// Figure height in inches (default: 4.8)
    pub height: f32,
    /// Output resolution in pixels per inch (default: 100)
    pub dpi: f32,
}

impl FigureConfig {
    /// Create a new figure configuration
    pub fn new(width: f32, height: f32, dpi: f32) -> Self {
        Self { width, height, dpi }
    }

    /// Calculate canvas size in pixels
    ///
    /// # Returns
    ///
    /// `(width_px, height_px)` tuple
    pub fn canvas_size(&self) -> (u32, u32) {
        (
            in_to_px(self.width, self.dpi) as u32,
            in_to_px(self.height, self.dpi) as u32,
        )
    }

    /// Get aspect ratio (width / height)
    pub fn aspect_ratio(&self) -> f32 {
        self.width / self.height
    }

    /// Build the shared render scale for this figure configuration.
    pub fn render_scale(&self) -> RenderScale {
        RenderScale::new(self.dpi).with_figure(self.width, self.height)
    }
}

impl Default for FigureConfig {
    fn default() -> Self {
        Self {
            width: 6.4,  // matplotlib default
            height: 4.8, // matplotlib default (4:3 aspect)
            dpi: 100.0,  // Good for screen
        }
    }
}

// =============================================================================
// Typography Configuration
// =============================================================================

/// Typography configuration with font sizes in points
///
/// Font sizes can be specified as absolute values or as scale factors
/// relative to `base_size`. Scale factors are multipliers (e.g., 1.4 = 140% of base).
#[derive(Debug, Clone, PartialEq)]
pub struct TypographyConfig {
    /// Base font size in points (default: 10.0)
    pub base_size: f32,
    /// Title size scale factor (default: 1.4)
    pub title_scale: f32,
    /// Axis label size scale factor (default: 1.0)
    pub label_scale: f32,
    /// Tick label size scale factor (default: 0.9)
    pub tick_scale: f32,
    /// Legend text size scale factor (default: 0.9)
    pub legend_scale: f32,
    /// Font family (default: SansSerif)
    pub family: FontFamily,
    /// Title font weight (default: Normal)
    pub title_weight: FontWeight,
}

impl TypographyConfig {
    /// Create a new typography configuration with base size
    pub fn new(base_size: f32) -> Self {
        Self {
            base_size,
            ..Default::default()
        }
    }

    /// Get title font size in points
    pub fn title_size(&self) -> f32 {
        self.base_size * self.title_scale
    }

    /// Get axis label font size in points
    pub fn label_size(&self) -> f32 {
        self.base_size * self.label_scale
    }

    /// Get tick label font size in points
    pub fn tick_size(&self) -> f32 {
        self.base_size * self.tick_scale
    }

    /// Get legend font size in points
    pub fn legend_size(&self) -> f32 {
        self.base_size * self.legend_scale
    }

    /// Get title font size in pixels at the given DPI
    pub fn title_size_px(&self, dpi: f32) -> f32 {
        pt_to_px(self.title_size(), dpi)
    }

    /// Get axis label font size in pixels at the given DPI
    pub fn label_size_px(&self, dpi: f32) -> f32 {
        pt_to_px(self.label_size(), dpi)
    }

    /// Get tick label font size in pixels at the given DPI
    pub fn tick_size_px(&self, dpi: f32) -> f32 {
        pt_to_px(self.tick_size(), dpi)
    }

    /// Get legend font size in pixels at the given DPI
    pub fn legend_size_px(&self, dpi: f32) -> f32 {
        pt_to_px(self.legend_size(), dpi)
    }

    /// Scale all font sizes proportionally
    pub fn scale(mut self, factor: f32) -> Self {
        self.base_size *= factor;
        self
    }

    /// Set the base font size
    pub fn base_size(mut self, size: f32) -> Self {
        self.base_size = size;
        self
    }

    /// Set the title scale factor
    pub fn title_scale(mut self, scale: f32) -> Self {
        self.title_scale = scale;
        self
    }

    /// Set the font family
    pub fn family(mut self, family: FontFamily) -> Self {
        self.family = family;
        self
    }

    /// Set the title font weight
    pub fn title_weight(mut self, weight: FontWeight) -> Self {
        self.title_weight = weight;
        self
    }
}

impl Default for TypographyConfig {
    fn default() -> Self {
        Self {
            base_size: 10.0,   // matplotlib default
            title_scale: 1.4,  // 14pt title
            label_scale: 1.0,  // 10pt labels
            tick_scale: 0.9,   // 9pt tick labels
            legend_scale: 0.9, // 9pt legend
            family: FontFamily::SansSerif,
            title_weight: FontWeight::Normal,
        }
    }
}

// =============================================================================
// Line Configuration
// =============================================================================

/// Line width configuration in points
///
/// All line widths are specified in typographic points (1/72 inch).
#[derive(Debug, Clone, PartialEq)]
pub struct LineConfig {
    /// Data line width in points (default: 1.5)
    pub data_width: f32,
    /// Axis border width in points (default: 0.8)
    pub axis_width: f32,
    /// Grid line width in points (default: 0.8, matches `GridStyle::default()`)
    pub grid_width: f32,
    /// Tick mark width in points (default: 0.6)
    pub tick_width: f32,
    /// Tick mark length in points (default: 4.0)
    pub tick_length: f32,
}

impl LineConfig {
    /// Get data line width in pixels at the given DPI
    pub fn data_width_px(&self, dpi: f32) -> f32 {
        pt_to_px(self.data_width, dpi)
    }

    /// Get axis border width in pixels at the given DPI
    pub fn axis_width_px(&self, dpi: f32) -> f32 {
        pt_to_px(self.axis_width, dpi)
    }

    /// Get grid line width in pixels at the given DPI
    pub fn grid_width_px(&self, dpi: f32) -> f32 {
        pt_to_px(self.grid_width, dpi)
    }

    /// Get tick mark width in pixels at the given DPI
    pub fn tick_width_px(&self, dpi: f32) -> f32 {
        pt_to_px(self.tick_width, dpi)
    }

    /// Get tick mark length in pixels at the given DPI
    pub fn tick_length_px(&self, dpi: f32) -> f32 {
        pt_to_px(self.tick_length, dpi)
    }

    /// Set data line width
    pub fn data_width(mut self, width: f32) -> Self {
        self.data_width = width;
        self
    }

    /// Set axis border width
    pub fn axis_width(mut self, width: f32) -> Self {
        self.axis_width = width;
        self
    }

    /// Set grid line width
    pub fn grid_width(mut self, width: f32) -> Self {
        self.grid_width = width;
        self
    }
}

impl Default for LineConfig {
    fn default() -> Self {
        Self {
            data_width: 1.5, // matplotlib default
            axis_width: 0.8,
            grid_width: 0.8, // matches GridStyle::default().line_width
            tick_width: 0.6,
            tick_length: 4.0,
        }
    }
}

// =============================================================================
// Spacing Configuration
// =============================================================================

/// Spacing and padding configuration in points
///
/// All spacing values are in typographic points.
#[derive(Debug, Clone, PartialEq)]
pub struct SpacingConfig {
    /// Space below title in points (default: 6.0)
    pub title_pad: f32,
    /// Space between axis labels and tick labels in points (default: 4.0)
    pub label_pad: f32,
    /// Space between axes and tick labels in points (default: 3.5)
    pub tick_pad: f32,
    /// Padding inside legend box in points (default: 8.0)
    pub legend_pad: f32,
}

impl SpacingConfig {
    /// Get title padding in pixels at the given DPI
    pub fn title_pad_px(&self, dpi: f32) -> f32 {
        pt_to_px(self.title_pad, dpi)
    }

    /// Get label padding in pixels at the given DPI
    pub fn label_pad_px(&self, dpi: f32) -> f32 {
        pt_to_px(self.label_pad, dpi)
    }

    /// Get tick padding in pixels at the given DPI
    pub fn tick_pad_px(&self, dpi: f32) -> f32 {
        pt_to_px(self.tick_pad, dpi)
    }

    /// Get legend padding in pixels at the given DPI
    pub fn legend_pad_px(&self, dpi: f32) -> f32 {
        pt_to_px(self.legend_pad, dpi)
    }
}

impl Default for SpacingConfig {
    fn default() -> Self {
        Self {
            title_pad: 6.0, // Matplotlib-style title spacing
            label_pad: 4.0, // Matplotlib-style axis label spacing
            tick_pad: 3.5,  // Matplotlib-style tick label spacing
            legend_pad: 8.0,
        }
    }
}

// =============================================================================
// Margin Configuration
// =============================================================================

/// Margin configuration for plot area
///
/// Margins can be proportional (matplotlib-style), auto-calculated, or fixed.
///
/// # Margin Modes
///
/// - **Proportional** (default): Margins as fractions of figure size, matching matplotlib's
///   `subplotpars` behavior. This ensures consistent visual proportions across different
///   figure sizes.
///
/// - **Auto**: Dynamically calculated based on content (title, labels). Use when you need
///   margins to adapt to varying text content.
///
/// - **Fixed**: Explicit margins in inches. Use for precise control over layout.
///
/// # Example
///
/// ```rust,ignore
/// use ruviz::core::MarginConfig;
///
/// // Default: matplotlib-compatible proportional margins
/// let proportional = MarginConfig::default();
///
/// // Content-aware auto margins
/// let auto = MarginConfig::auto();
///
/// // Explicit fixed margins
/// let fixed = MarginConfig::fixed(1.0, 0.5, 0.8, 0.6);
/// ```
#[derive(Debug, Clone, PartialEq)]
pub enum MarginConfig {
    /// Proportional margins as fractions of figure dimensions (matplotlib-style)
    ///
    /// This is the default mode, matching matplotlib's `subplotpars`:
    /// - `left`: fraction of figure width for left margin (default: 0.125 = 12.5%)
    /// - `right`: fraction of figure width for right margin (default: 0.1 = 10%)
    /// - `top`: fraction of figure height for top margin (default: 0.12 = 12%)
    /// - `bottom`: fraction of figure height for bottom margin (default: 0.11 = 11%)
    Proportional {
        /// Left margin as fraction of figure width
        left: f32,
        /// Right margin as fraction of figure width
        right: f32,
        /// Top margin as fraction of figure height
        top: f32,
        /// Bottom margin as fraction of figure height
        bottom: f32,
    },
    /// Auto-calculate margins based on content
    Auto {
        /// Minimum margin in inches
        min: f32,
        /// Maximum margin in inches
        max: f32,
    },
    /// Fixed margins in inches
    Fixed {
        left: f32,
        right: f32,
        top: f32,
        bottom: f32,
    },
    /// Content-driven margins computed from text measurements
    ///
    /// This is the recommended mode for well-balanced layouts.
    /// Margins are calculated based on actual content (title, labels, ticks)
    /// rather than arbitrary percentages.
    ContentDriven {
        /// Small buffer from canvas edges (in points)
        edge_buffer: f32,
        /// Whether to center the plot by distributing extra space
        center_plot: bool,
    },
}

impl MarginConfig {
    /// Create proportional margins with matplotlib defaults
    ///
    /// This matches matplotlib's default `subplotpars`:
    /// - left: 0.125 (12.5% of width)
    /// - right: 0.1 (10% of width)
    /// - top: 0.12 (12% of height)
    /// - bottom: 0.11 (11% of height)
    pub fn proportional() -> Self {
        MarginConfig::Proportional {
            left: 0.125,
            right: 0.1,
            top: 0.12,
            bottom: 0.11,
        }
    }

    /// Alias for `proportional()` - creates matplotlib-compatible margins
    pub fn matplotlib() -> Self {
        Self::proportional()
    }

    /// Create proportional margins with custom fractions
    pub fn proportional_custom(left: f32, right: f32, top: f32, bottom: f32) -> Self {
        MarginConfig::Proportional {
            left,
            right,
            top,
            bottom,
        }
    }

    /// Create auto margins with default bounds (0.3 to 1.0 inches)
    ///
    /// Auto margins calculate space based on content (title, axis labels).
    /// Use this when you need margins to adapt to varying text content.
    pub fn auto() -> Self {
        MarginConfig::Auto { min: 0.3, max: 1.0 }
    }

    /// Create auto margins with custom bounds
    pub fn auto_with_bounds(min: f32, max: f32) -> Self {
        MarginConfig::Auto { min, max }
    }

    /// Create fixed margins (same on all sides)
    pub fn fixed_uniform(margin: f32) -> Self {
        MarginConfig::Fixed {
            left: margin,
            right: margin,
            top: margin,
            bottom: margin,
        }
    }

    /// Create fixed margins with different values per side (in inches)
    pub fn fixed(left: f32, right: f32, top: f32, bottom: f32) -> Self {
        MarginConfig::Fixed {
            left,
            right,
            top,
            bottom,
        }
    }

    /// Create content-driven margins with default settings
    ///
    /// This is the recommended mode for well-balanced layouts.
    /// Uses a 5pt edge buffer and centers the plot.
    pub fn content_driven() -> Self {
        MarginConfig::ContentDriven {
            edge_buffer: 5.0,
            center_plot: true,
        }
    }

    /// Create content-driven margins with custom settings
    pub fn content_driven_custom(edge_buffer: f32, center_plot: bool) -> Self {
        MarginConfig::ContentDriven {
            edge_buffer,
            center_plot,
        }
    }

    /// Validate margin values against the configured figure dimensions.
    pub(crate) fn validate_for_figure(&self, figure: &FigureConfig) -> Result<()> {
        fn invalid(message: impl Into<String>) -> PlottingError {
            PlottingError::InvalidInput(message.into())
        }

        fn validate_non_negative(values: &[(&str, f32)], mode: &str) -> Result<()> {
            for (name, value) in values {
                if !value.is_finite() || *value < 0.0 {
                    return Err(invalid(format!(
                        "{mode} margin {name} must be a finite, non-negative value ({name}={value})"
                    )));
                }
            }
            Ok(())
        }

        match self {
            MarginConfig::Proportional {
                left,
                right,
                top,
                bottom,
            } => {
                validate_non_negative(
                    &[
                        ("left", *left),
                        ("right", *right),
                        ("top", *top),
                        ("bottom", *bottom),
                    ],
                    "Proportional",
                )?;
                if left + right >= 1.0 || top + bottom >= 1.0 {
                    return Err(invalid(format!(
                        "Opposing proportional margins must sum to less than 1 (left+right={}, top+bottom={})",
                        left + right,
                        top + bottom
                    )));
                }
            }
            MarginConfig::Auto { min, max } => {
                validate_non_negative(&[("min", *min), ("max", *max)], "Auto")?;
                if min > max {
                    return Err(invalid(format!(
                        "Auto margin minimum must not exceed maximum (min={min}, max={max})"
                    )));
                }
                if 2.0 * min >= figure.width || 2.0 * min >= figure.height {
                    return Err(invalid(format!(
                        "Auto margin minimum must leave positive figure space (min={min}, width={}, height={})",
                        figure.width, figure.height
                    )));
                }
            }
            MarginConfig::Fixed {
                left,
                right,
                top,
                bottom,
            } => {
                validate_non_negative(
                    &[
                        ("left", *left),
                        ("right", *right),
                        ("top", *top),
                        ("bottom", *bottom),
                    ],
                    "Fixed",
                )?;
                if left + right >= figure.width || top + bottom >= figure.height {
                    return Err(invalid(format!(
                        "Opposing fixed margins must leave positive figure space (left+right={}, top+bottom={}, width={}, height={})",
                        left + right,
                        top + bottom,
                        figure.width,
                        figure.height
                    )));
                }
            }
            MarginConfig::ContentDriven { edge_buffer, .. } => {
                validate_non_negative(&[("edge_buffer", *edge_buffer)], "Content-driven")?;
                let edge_buffer_px = pt_to_px(*edge_buffer, figure.dpi);
                if !edge_buffer_px.is_finite() {
                    return Err(invalid(format!(
                        "Content-driven margin edge_buffer is out of pixel range (edge_buffer={edge_buffer}, dpi={})",
                        figure.dpi
                    )));
                }
                let edge_buffer_in = *edge_buffer / crate::core::POINTS_PER_INCH;
                if edge_buffer_in >= figure.width / 2.0 || edge_buffer_in >= figure.height / 2.0 {
                    return Err(invalid(format!(
                        "Content-driven margin edge_buffer must leave positive figure space (edge_buffer={edge_buffer}, width={}, height={})",
                        figure.width, figure.height
                    )));
                }
            }
        }

        Ok(())
    }
}

impl Default for MarginConfig {
    fn default() -> Self {
        // Default to content-driven margins - computes margins from actual content
        // This provides the best layout by measuring text elements first
        MarginConfig::ContentDriven {
            edge_buffer: 5.0,  // Tight default buffer near Matplotlib's spacing
            center_plot: true, // Center the chart area horizontally
        }
    }
}

/// Computed margin values in inches
#[derive(Debug, Clone, PartialEq)]
pub struct ComputedMargins {
    pub left: f32,
    pub right: f32,
    pub top: f32,
    pub bottom: f32,
}

impl ComputedMargins {
    /// Get left margin in pixels at the given DPI
    pub fn left_px(&self, dpi: f32) -> f32 {
        in_to_px(self.left, dpi)
    }

    /// Get right margin in pixels at the given DPI
    pub fn right_px(&self, dpi: f32) -> f32 {
        in_to_px(self.right, dpi)
    }

    /// Get top margin in pixels at the given DPI
    pub fn top_px(&self, dpi: f32) -> f32 {
        in_to_px(self.top, dpi)
    }

    /// Get bottom margin in pixels at the given DPI
    pub fn bottom_px(&self, dpi: f32) -> f32 {
        in_to_px(self.bottom, dpi)
    }
}

impl Default for ComputedMargins {
    fn default() -> Self {
        Self {
            left: 0.8,
            right: 0.3,
            top: 0.5,
            bottom: 0.6,
        }
    }
}

// =============================================================================
// Spine Configuration
// =============================================================================

/// Configuration for plot spines (axis borders)
///
/// Spines are the lines that form the plot's border. Seaborn's popular `despine()`
/// function removes some spines for a cleaner look. This configuration enables
/// similar control in ruviz.
///
/// # Default
///
/// By default, all spines are visible (matplotlib behavior).
///
/// # Example
///
/// ```rust,ignore
/// use ruviz::core::SpineConfig;
///
/// // Default: all spines visible
/// let all_visible = SpineConfig::default();
///
/// // Seaborn-style despine (hide top and right)
/// let despined = SpineConfig::despine();
///
/// // Minimal: only bottom and left
/// let minimal = SpineConfig::minimal();
///
/// // Custom configuration
/// let custom = SpineConfig {
///     left: true,
///     right: false,
///     top: false,
///     bottom: true,
///     ..Default::default()
/// };
/// ```
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct SpineConfig {
    /// Show left spine (y-axis border)
    pub left: bool,
    /// Show right spine
    pub right: bool,
    /// Show top spine
    pub top: bool,
    /// Show bottom spine (x-axis border)
    pub bottom: bool,
    /// Offset spines from data area (in points)
    /// When > 0, spines are moved outward from the data area
    pub offset: f32,
}

impl SpineConfig {
    /// Create a new spine configuration with all spines visible
    pub fn new() -> Self {
        Self::default()
    }

    /// Create a "despined" configuration (seaborn-style)
    ///
    /// Hides the top and right spines, keeping only bottom and left.
    /// This is the most common seaborn despine pattern.
    pub fn despine() -> Self {
        Self {
            left: true,
            right: false,
            top: false,
            bottom: true,
            offset: 0.0,
        }
    }

    /// Create a minimal configuration with only bottom and left spines
    ///
    /// Alias for `despine()`.
    pub fn minimal() -> Self {
        Self::despine()
    }

    /// Create a configuration with no spines
    pub fn none() -> Self {
        Self {
            left: false,
            right: false,
            top: false,
            bottom: false,
            offset: 0.0,
        }
    }

    /// Create a configuration with all spines visible
    pub fn all() -> Self {
        Self::default()
    }

    /// Set the spine offset in points
    ///
    /// When offset > 0, spines are moved outward from the data area,
    /// creating visual separation between data and axes.
    pub fn with_offset(mut self, offset: f32) -> Self {
        self.offset = offset;
        self
    }

    /// Hide the left spine
    pub fn hide_left(mut self) -> Self {
        self.left = false;
        self
    }

    /// Hide the right spine
    pub fn hide_right(mut self) -> Self {
        self.right = false;
        self
    }

    /// Hide the top spine
    pub fn hide_top(mut self) -> Self {
        self.top = false;
        self
    }

    /// Hide the bottom spine
    pub fn hide_bottom(mut self) -> Self {
        self.bottom = false;
        self
    }

    /// Show the left spine
    pub fn show_left(mut self) -> Self {
        self.left = true;
        self
    }

    /// Show the right spine
    pub fn show_right(mut self) -> Self {
        self.right = true;
        self
    }

    /// Show the top spine
    pub fn show_top(mut self) -> Self {
        self.top = true;
        self
    }

    /// Show the bottom spine
    pub fn show_bottom(mut self) -> Self {
        self.bottom = true;
        self
    }

    /// Check if any spine is visible
    pub fn any_visible(&self) -> bool {
        self.left || self.right || self.top || self.bottom
    }

    /// Get offset in pixels at the given DPI
    pub fn offset_px(&self, dpi: f32) -> f32 {
        pt_to_px(self.offset, dpi)
    }
}

impl Default for SpineConfig {
    fn default() -> Self {
        Self {
            left: true,
            right: true,
            top: true,
            bottom: true,
            offset: 0.0,
        }
    }
}

// =============================================================================
// Main Plot Configuration
// =============================================================================

/// Complete plot configuration
///
/// This struct aggregates all configuration options for a plot,
/// using physical units for DPI-independent layout.
#[derive(Debug, Clone)]
pub struct PlotConfig {
    /// Figure dimensions and DPI
    pub figure: FigureConfig,
    /// Typography settings
    pub typography: TypographyConfig,
    /// Line width settings
    pub lines: LineConfig,
    /// Spacing/padding settings
    pub spacing: SpacingConfig,
    /// Margin settings
    pub margins: MarginConfig,
    /// Spine (axis border) visibility
    pub spines: SpineConfig,
    /// Autoscale margin on the x axis, as a fraction of the data span applied to
    /// each side (default: 0.05, matching matplotlib's `axes.xmargin`).
    ///
    /// Set to `0.0` for edge-to-edge data. Ignored when explicit x limits are set.
    pub x_margin: f64,
    /// Autoscale margin on the y axis, as a fraction of the data span applied to
    /// each side (default: 0.05, matching matplotlib's `axes.ymargin`).
    ///
    /// Set to `0.0` for edge-to-edge data. Ignored when explicit y limits are set.
    pub y_margin: f64,
}

impl Default for PlotConfig {
    fn default() -> Self {
        Self {
            figure: FigureConfig::default(),
            typography: TypographyConfig::default(),
            lines: LineConfig::default(),
            spacing: SpacingConfig::default(),
            margins: MarginConfig::default(),
            spines: SpineConfig::default(),
            x_margin: DEFAULT_AUTOSCALE_MARGIN,
            y_margin: DEFAULT_AUTOSCALE_MARGIN,
        }
    }
}

impl PlotConfig {
    /// Create a new plot configuration builder
    pub fn builder() -> PlotConfigBuilder {
        PlotConfigBuilder::default()
    }

    /// Get canvas size in pixels
    pub fn canvas_size(&self) -> (u32, u32) {
        self.figure.canvas_size()
    }

    /// Get the DPI setting
    pub fn dpi(&self) -> f32 {
        self.figure.dpi
    }

    /// Compute margins based on configuration mode
    ///
    /// - **Proportional**: Returns margins as fractions of figure dimensions (in inches)
    /// - **Auto**: Estimates required space based on typography and content
    /// - **Fixed**: Returns the fixed values directly
    pub fn compute_margins(
        &self,
        has_title: bool,
        has_xlabel: bool,
        has_ylabel: bool,
    ) -> ComputedMargins {
        match &self.margins {
            MarginConfig::Proportional {
                left,
                right,
                top,
                bottom,
            } => {
                // Convert fractions to inches based on figure dimensions
                ComputedMargins {
                    left: self.figure.width * left,
                    right: self.figure.width * right,
                    top: self.figure.height * top,
                    bottom: self.figure.height * bottom,
                }
            }
            MarginConfig::Auto { min, max } => {
                let (min, max) =
                    if min.is_finite() && max.is_finite() && *min >= 0.0 && *min <= *max {
                        (*min, *max)
                    } else {
                        (0.3, 1.0)
                    };
                // Estimate top margin based on title
                let top = if has_title {
                    (crate::core::pt_to_in(self.typography.title_size())
                        + crate::core::pt_to_in(self.spacing.title_pad)
                        + 0.15)
                        .clamp(min, max)
                } else {
                    min
                };

                // Estimate bottom margin based on xlabel and tick labels
                let bottom = if has_xlabel {
                    (crate::core::pt_to_in(self.typography.label_size())
                        + crate::core::pt_to_in(self.typography.tick_size())
                        + crate::core::pt_to_in(self.spacing.label_pad)
                        + crate::core::pt_to_in(self.spacing.tick_pad)
                        + 0.1)
                        .clamp(min, max)
                } else {
                    (crate::core::pt_to_in(self.typography.tick_size())
                        + crate::core::pt_to_in(self.spacing.tick_pad)
                        + 0.1)
                        .clamp(min, max)
                };

                // Estimate left margin based on ylabel and y-tick labels
                let left = if has_ylabel {
                    // Rotated ylabel takes more horizontal space
                    (crate::core::pt_to_in(self.typography.label_size())
                        + crate::core::pt_to_in(self.typography.tick_size()) * 4.0
                        + crate::core::pt_to_in(self.spacing.label_pad)
                        + 0.2)
                        .clamp(min, max)
                } else {
                    (crate::core::pt_to_in(self.typography.tick_size()) * 4.0 + 0.15)
                        .clamp(min, max)
                };

                // Right margin is typically smaller
                let right = min.max(0.2);

                ComputedMargins {
                    left,
                    right,
                    top,
                    bottom,
                }
            }
            MarginConfig::Fixed {
                left,
                right,
                top,
                bottom,
            } => ComputedMargins {
                left: *left,
                right: *right,
                top: *top,
                bottom: *bottom,
            },
            MarginConfig::ContentDriven { .. } => {
                // ContentDriven mode doesn't use ComputedMargins directly.
                // The layout is computed by LayoutCalculator.
                // Return reasonable defaults for fallback.
                ComputedMargins {
                    left: 0.8,
                    right: 0.3,
                    top: 0.5,
                    bottom: 0.6,
                }
            }
        }
    }

    /// Create a config from pixel dimensions (convenience method)
    ///
    /// Converts pixel dimensions to inches using the reference DPI (100).
    pub fn from_pixels(width_px: u32, height_px: u32) -> Self {
        Self {
            figure: FigureConfig {
                width: px_to_in(width_px as f32, REFERENCE_DPI),
                height: px_to_in(height_px as f32, REFERENCE_DPI),
                dpi: REFERENCE_DPI,
            },
            ..Default::default()
        }
    }
}

// =============================================================================
// Builder Pattern
// =============================================================================

/// Builder for PlotConfig with fluent API
#[derive(Debug, Clone, Default)]
pub struct PlotConfigBuilder {
    config: PlotConfig,
}

impl PlotConfigBuilder {
    /// Set figure dimensions in inches
    pub fn figure(mut self, width: f32, height: f32) -> Self {
        self.config.figure.width = width;
        self.config.figure.height = height;
        self
    }

    /// Set figure dimensions from pixels (at reference DPI)
    pub fn figure_px(mut self, width_px: u32, height_px: u32) -> Self {
        self.config.figure.width = px_to_in(width_px as f32, REFERENCE_DPI);
        self.config.figure.height = px_to_in(height_px as f32, REFERENCE_DPI);
        self
    }

    /// Set output DPI
    pub fn dpi(mut self, dpi: f32) -> Self {
        self.config.figure.dpi = dpi;
        self
    }

    /// Configure typography with a closure
    pub fn typography<F>(mut self, f: F) -> Self
    where
        F: FnOnce(TypographyConfig) -> TypographyConfig,
    {
        self.config.typography = f(self.config.typography);
        self
    }

    /// Set base font size in points
    pub fn font_size(mut self, size: f32) -> Self {
        self.config.typography.base_size = size;
        self
    }

    /// Set the font family used for text.
    pub fn font_family<F>(mut self, family: F) -> Self
    where
        F: Into<FontFamily>,
    {
        self.config.typography.family = family.into();
        self
    }

    /// Configure line widths with a closure
    pub fn lines<F>(mut self, f: F) -> Self
    where
        F: FnOnce(LineConfig) -> LineConfig,
    {
        self.config.lines = f(self.config.lines);
        self
    }

    /// Set data line width in points
    pub fn line_width(mut self, width: f32) -> Self {
        self.config.lines.data_width = width;
        self
    }

    /// Configure spacing with a closure
    pub fn spacing<F>(mut self, f: F) -> Self
    where
        F: FnOnce(SpacingConfig) -> SpacingConfig,
    {
        self.config.spacing = f(self.config.spacing);
        self
    }

    /// Set margin configuration
    pub fn margins(mut self, margins: MarginConfig) -> Self {
        self.config.margins = margins;
        self
    }

    /// Set spine configuration
    pub fn spines(mut self, spines: SpineConfig) -> Self {
        self.config.spines = spines;
        self
    }

    /// Use despined style (hide top and right spines)
    ///
    /// Convenience method for seaborn-style despine.
    pub fn despine(mut self) -> Self {
        self.config.spines = SpineConfig::despine();
        self
    }

    /// Set the x-axis autoscale margin as a fraction of the data span per side
    ///
    /// Pass `0.0` for edge-to-edge data. Ignored when explicit x limits are set.
    pub fn x_margin(mut self, margin: f64) -> Self {
        self.config.x_margin = margin;
        self
    }

    /// Set the y-axis autoscale margin as a fraction of the data span per side
    ///
    /// Pass `0.0` for edge-to-edge data. Ignored when explicit y limits are set.
    pub fn y_margin(mut self, margin: f64) -> Self {
        self.config.y_margin = margin;
        self
    }

    /// Set both autoscale margins at once (matplotlib's `Axes.margins`)
    pub fn data_margins(mut self, x_margin: f64, y_margin: f64) -> Self {
        self.config.x_margin = x_margin;
        self.config.y_margin = y_margin;
        self
    }

    /// Build the final configuration
    pub fn build(self) -> PlotConfig {
        self.config
    }
}

// =============================================================================
// Tests
// =============================================================================

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_figure_config_default() {
        let config = FigureConfig::default();
        assert!((config.width - 6.4).abs() < 0.001);
        assert!((config.height - 4.8).abs() < 0.001);
        assert!((config.dpi - 100.0).abs() < 0.001);
    }

    #[test]
    fn test_figure_config_canvas_size() {
        let config = FigureConfig::default();
        let (w, h) = config.canvas_size();
        assert_eq!(w, 640);
        assert_eq!(h, 480);

        let config = FigureConfig::new(6.4, 4.8, 300.0);
        let (w, h) = config.canvas_size();
        assert_eq!(w, 1920);
        assert_eq!(h, 1440);
    }

    #[test]
    fn test_typography_config_default() {
        let config = TypographyConfig::default();
        assert!((config.base_size - 10.0).abs() < 0.001);
        assert!((config.title_scale - 1.4).abs() < 0.001);
    }

    #[test]
    fn test_typography_computed_sizes() {
        let config = TypographyConfig::default();
        assert!((config.title_size() - 14.0).abs() < 0.001);
        assert!((config.label_size() - 10.0).abs() < 0.001);
        assert!((config.tick_size() - 9.0).abs() < 0.001);
    }

    #[test]
    fn test_typography_scale() {
        let config = TypographyConfig::default().scale(1.5);
        assert!((config.base_size - 15.0).abs() < 0.001);
        assert!((config.title_size() - 21.0).abs() < 0.001); // 15 * 1.4
    }

    #[test]
    fn test_line_config_default() {
        let config = LineConfig::default();
        assert!((config.data_width - 1.5).abs() < 0.001);
        assert!((config.axis_width - 0.8).abs() < 0.001);
    }

    #[test]
    fn test_margin_config_auto() {
        let config = MarginConfig::auto();
        match config {
            MarginConfig::Auto { min, max } => {
                assert!((min - 0.3).abs() < 0.001);
                assert!((max - 1.0).abs() < 0.001);
            }
            _ => panic!("Expected Auto"),
        }
    }

    #[test]
    fn test_plot_config_builder() {
        let config = PlotConfig::builder()
            .figure(8.0, 6.0)
            .dpi(150.0)
            .font_family("New Computer Modern Sans")
            .font_size(12.0)
            .line_width(2.0)
            .build();

        assert!((config.figure.width - 8.0).abs() < 0.001);
        assert!((config.figure.height - 6.0).abs() < 0.001);
        assert!((config.figure.dpi - 150.0).abs() < 0.001);
        assert_eq!(
            config.typography.family,
            FontFamily::Name("New Computer Modern Sans".to_string())
        );
        assert!((config.typography.base_size - 12.0).abs() < 0.001);
        assert!((config.lines.data_width - 2.0).abs() < 0.001);
    }

    #[test]
    fn test_plot_config_canvas_size() {
        let config = PlotConfig::default();
        let (w, h) = config.canvas_size();
        assert_eq!(w, 640);
        assert_eq!(h, 480);
    }

    #[test]
    fn test_plot_config_default_autoscale_margins_match_matplotlib() {
        let config = PlotConfig::default();
        assert!((config.x_margin - 0.05).abs() < f64::EPSILON);
        assert!((config.y_margin - 0.05).abs() < f64::EPSILON);
        assert!((DEFAULT_AUTOSCALE_MARGIN - 0.05).abs() < f64::EPSILON);
    }

    #[test]
    fn test_plot_config_builder_autoscale_margins() {
        let config = PlotConfig::builder().x_margin(0.0).y_margin(0.2).build();
        assert!((config.x_margin - 0.0).abs() < f64::EPSILON);
        assert!((config.y_margin - 0.2).abs() < f64::EPSILON);

        let both = PlotConfig::builder().data_margins(0.1, 0.0).build();
        assert!((both.x_margin - 0.1).abs() < f64::EPSILON);
        assert!((both.y_margin - 0.0).abs() < f64::EPSILON);
    }

    #[test]
    fn test_computed_margins() {
        let config = PlotConfig::default();
        let margins = config.compute_margins(true, true, true);

        // With all labels, margins should be non-zero
        assert!(margins.left > 0.0);
        assert!(margins.right > 0.0);
        assert!(margins.top > 0.0);
        assert!(margins.bottom > 0.0);

        // Left should be larger than right (for y-axis labels)
        assert!(margins.left > margins.right);
    }

    #[test]
    fn test_compute_margins_invalid_auto_bounds_use_fallback() {
        for margins in [
            MarginConfig::Auto { min: 1.0, max: 0.5 },
            MarginConfig::Auto {
                min: f32::NAN,
                max: 1.0,
            },
        ] {
            let config = PlotConfig {
                margins,
                ..PlotConfig::default()
            };
            let computed = config.compute_margins(true, true, true);

            assert!(computed.left.is_finite());
            assert!(computed.right.is_finite());
            assert!(computed.top.is_finite());
            assert!(computed.bottom.is_finite());
        }
    }

    #[test]
    fn test_dpi_independence() {
        // At different DPIs, the ratio of elements should be the same
        let config = PlotConfig::default();

        let font_px_100 = config.typography.title_size_px(100.0);
        let canvas_100 = config.figure.canvas_size();
        let ratio_100 = font_px_100 / canvas_100.0 as f32;

        // Simulate 300 DPI
        let font_px_300 = config.typography.title_size_px(300.0);
        let canvas_300 = (
            in_to_px(config.figure.width, 300.0) as u32,
            in_to_px(config.figure.height, 300.0) as u32,
        );
        let ratio_300 = font_px_300 / canvas_300.0 as f32;

        // Ratios should be equal (DPI-independent)
        assert!((ratio_100 - ratio_300).abs() < 0.0001);
    }

    #[test]
    fn test_spine_config_default() {
        let spines = SpineConfig::default();
        assert!(spines.left);
        assert!(spines.right);
        assert!(spines.top);
        assert!(spines.bottom);
        assert!((spines.offset - 0.0).abs() < 0.001);
    }

    #[test]
    fn test_spine_config_despine() {
        let spines = SpineConfig::despine();
        assert!(spines.left);
        assert!(!spines.right);
        assert!(!spines.top);
        assert!(spines.bottom);
    }

    #[test]
    fn test_spine_config_none() {
        let spines = SpineConfig::none();
        assert!(!spines.left);
        assert!(!spines.right);
        assert!(!spines.top);
        assert!(!spines.bottom);
        assert!(!spines.any_visible());
    }

    #[test]
    fn test_spine_config_builder_chain() {
        let spines = SpineConfig::default()
            .hide_top()
            .hide_right()
            .with_offset(5.0);

        assert!(spines.left);
        assert!(!spines.right);
        assert!(!spines.top);
        assert!(spines.bottom);
        assert!((spines.offset - 5.0).abs() < 0.001);
    }

    #[test]
    fn test_spine_config_offset_px() {
        let spines = SpineConfig::default().with_offset(10.0);
        // At 72 DPI, 10 points = 10 pixels
        assert!((spines.offset_px(72.0) - 10.0).abs() < 0.001);
        // At 144 DPI, 10 points = 20 pixels
        assert!((spines.offset_px(144.0) - 20.0).abs() < 0.001);
    }

    #[test]
    fn test_plot_config_builder_despine() {
        let config = PlotConfig::builder().despine().build();

        assert!(config.spines.left);
        assert!(!config.spines.right);
        assert!(!config.spines.top);
        assert!(config.spines.bottom);
    }
}