oxidize_pdf/dashboard/

pivot_table.rs

//! PivotTable Component
//!
//! This module implements pivot tables for data aggregation and analysis,
//! with support for grouping, aggregation functions, and formatting.

use super::{
    component::ComponentConfig, ComponentPosition, ComponentSpan, DashboardComponent,
    DashboardTheme,
};
use crate::error::PdfError;
use crate::page::Page;
use std::collections::HashMap;

/// PivotTable component for data aggregation
#[derive(Debug, Clone)]
pub struct PivotTable {
    /// Component configuration
    config: ComponentConfig,
    /// Raw data for the pivot table
    data: Vec<HashMap<String, String>>,
    /// Pivot configuration
    pivot_config: PivotConfig,
    /// Computed pivot data
    computed_data: Option<ComputedPivotData>,
}

impl PivotTable {
    /// Create a new pivot table
    pub fn new(data: Vec<HashMap<String, String>>) -> Self {
        Self {
            config: ComponentConfig::new(ComponentSpan::new(12)), // Full width by default
            data,
            pivot_config: PivotConfig::default(),
            computed_data: None,
        }
    }

    /// Set pivot configuration
    pub fn with_config(mut self, config: PivotConfig) -> Self {
        self.pivot_config = config;
        self.computed_data = None; // Reset computed data
        self
    }

    /// Add aggregation
    pub fn aggregate_by(mut self, functions: &[&str]) -> Self {
        for func_str in functions {
            if let Ok(func) = func_str.parse::<AggregateFunction>() {
                if !self.pivot_config.aggregations.contains(&func) {
                    self.pivot_config.aggregations.push(func);
                }
            }
        }
        self.computed_data = None; // Reset computed data
        self
    }

    /// Compute pivot data if not already computed
    fn ensure_computed(&mut self) -> Result<(), PdfError> {
        if self.computed_data.is_none() {
            self.computed_data = Some(self.compute_pivot_data()?);
        }
        Ok(())
    }

    /// Compute pivot table data
    fn compute_pivot_data(&self) -> Result<ComputedPivotData, PdfError> {
        // Implementation placeholder - real implementation would be complex
        Ok(ComputedPivotData {
            headers: vec!["Group".to_string(), "Count".to_string()],
            rows: vec![
                vec!["Group A".to_string(), "10".to_string()],
                vec!["Group B".to_string(), "15".to_string()],
                vec!["Total".to_string(), "25".to_string()],
            ],
            totals_row: Some(2),
        })
    }
}

impl DashboardComponent for PivotTable {
    fn render(
        &self,
        _page: &mut Page,
        position: ComponentPosition,
        _theme: &DashboardTheme,
    ) -> Result<(), PdfError> {
        let mut table = self.clone();
        table.ensure_computed()?;

        let computed = table.computed_data.as_ref().unwrap();

        // Render title if present
        if let Some(ref _title) = table.pivot_config.title {
            // Placeholder: page.add_text replaced
        }

        // Simple table rendering (placeholder)
        let mut current_y = position.y + position.height - 40.0;
        let row_height = 20.0;

        // Render headers
        for (i, _header) in computed.headers.iter().enumerate() {
            let _x = position.x + i as f64 * (position.width / computed.headers.len() as f64);
            // Placeholder: page.add_text replaced
        }

        current_y -= row_height;

        // Render data rows
        for (row_idx, row) in computed.rows.iter().enumerate() {
            let is_totals = computed.totals_row == Some(row_idx);

            for (col_idx, _cell) in row.iter().enumerate() {
                let _x =
                    position.x + col_idx as f64 * (position.width / computed.headers.len() as f64);
                let _is_totals = is_totals; // Suppress warning
                                            // Placeholder: page.add_text replaced
            }
            current_y -= row_height;
        }

        Ok(())
    }

    fn get_span(&self) -> ComponentSpan {
        self.config.span
    }
    fn set_span(&mut self, span: ComponentSpan) {
        self.config.span = span;
    }
    fn preferred_height(&self, _available_width: f64) -> f64 {
        200.0
    }
    fn component_type(&self) -> &'static str {
        "PivotTable"
    }
    fn complexity_score(&self) -> u8 {
        85
    }
}

/// Pivot table configuration
#[derive(Debug, Clone)]
pub struct PivotConfig {
    /// Table title
    pub title: Option<String>,
    /// Columns to group by (rows)
    pub row_groups: Vec<String>,
    /// Columns to group by (columns)
    pub column_groups: Vec<String>,
    /// Aggregation functions to apply
    pub aggregations: Vec<AggregateFunction>,
    /// Columns to aggregate
    pub value_columns: Vec<String>,
    /// Whether to show totals
    pub show_totals: bool,
    /// Whether to show subtotals
    pub show_subtotals: bool,
}

impl Default for PivotConfig {
    fn default() -> Self {
        Self {
            title: None,
            row_groups: vec![],
            column_groups: vec![],
            aggregations: vec![AggregateFunction::Count],
            value_columns: vec![],
            show_totals: true,
            show_subtotals: false,
        }
    }
}

/// Computed pivot table data
#[derive(Debug, Clone)]
pub struct ComputedPivotData {
    /// Column headers
    pub headers: Vec<String>,
    /// Data rows
    pub rows: Vec<Vec<String>>,
    /// Index of totals row (if any)
    pub totals_row: Option<usize>,
}

/// Aggregation functions for pivot tables
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AggregateFunction {
    Count,
    Sum,
    Average,
    Min,
    Max,
}

impl std::str::FromStr for AggregateFunction {
    type Err = PdfError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "count" => Ok(AggregateFunction::Count),
            "sum" => Ok(AggregateFunction::Sum),
            "avg" | "average" => Ok(AggregateFunction::Average),
            "min" => Ok(AggregateFunction::Min),
            "max" => Ok(AggregateFunction::Max),
            _ => Err(PdfError::InvalidOperation(format!(
                "Unknown aggregate function: {}",
                s
            ))),
        }
    }
}

/// Builder for PivotTable
pub struct PivotTableBuilder;

impl PivotTableBuilder {
    pub fn new() -> Self {
        Self
    }
    pub fn build(self) -> PivotTable {
        PivotTable::new(vec![])
    }
}