scirs2_metrics/visualization/advanced_interactive/

layout.rs

//! Layout management for interactive visualization
//!
//! This module provides layout algorithms and management for positioning
//! and sizing dashboard widgets.

#![allow(clippy::too_many_arguments)]
#![allow(dead_code)]

use super::core::{LayoutConfig, Position, Size};
use super::widgets::WidgetConfig;
use crate::error::{MetricsError, Result};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Layout manager for dashboard widgets
#[derive(Debug)]
pub struct LayoutManager {
    /// Layout configuration
    config: LayoutConfig,
    /// Widget layouts
    widget_layouts: HashMap<String, WidgetLayout>,
    /// Container constraints
    container_constraints: ContainerConstraints,
}

/// Widget layout information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WidgetLayout {
    /// Widget ID
    pub widget_id: String,
    /// Current position
    pub position: Position,
    /// Current size
    pub size: Size,
    /// Layout constraints
    pub constraints: LayoutConstraints,
    /// Grid position (if using grid layout)
    pub grid_position: Option<GridPosition>,
    /// Z-index for layering
    pub z_index: i32,
}

/// Layout constraints
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LayoutConstraints {
    /// Minimum size
    pub min_size: Size,
    /// Maximum size
    pub max_size: Size,
    /// Aspect ratio constraints
    pub aspect_ratio: Option<f64>,
    /// Fixed width
    pub fixed_width: Option<f64>,
    /// Fixed height
    pub fixed_height: Option<f64>,
    /// Margin constraints
    pub margin: Margin,
}

/// Grid position for grid-based layouts
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GridPosition {
    /// Column start
    pub col_start: u32,
    /// Column span
    pub col_span: u32,
    /// Row start
    pub row_start: u32,
    /// Row span
    pub row_span: u32,
}

/// Margin specification
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Margin {
    /// Top margin
    pub top: f64,
    /// Right margin
    pub right: f64,
    /// Bottom margin
    pub bottom: f64,
    /// Left margin
    pub left: f64,
}

/// Container constraints
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ContainerConstraints {
    /// Container width
    pub width: f64,
    /// Container height
    pub height: f64,
    /// Padding
    pub padding: Margin,
    /// Minimum widget size
    pub min_widget_size: Size,
    /// Maximum widget size
    pub max_widget_size: Size,
}

impl LayoutManager {
    /// Create new layout manager
    pub fn new(config: LayoutConfig, container_constraints: ContainerConstraints) -> Self {
        Self {
            config,
            widget_layouts: HashMap::new(),
            container_constraints,
        }
    }

    /// Add widget to layout
    pub fn add_widget(&mut self, widget_config: &WidgetConfig) -> Result<()> {
        let layout = WidgetLayout {
            widget_id: widget_config.id.clone(),
            position: widget_config.position.clone(),
            size: widget_config.size.clone(),
            constraints: LayoutConstraints::from_widget_config(widget_config),
            grid_position: None,
            z_index: widget_config.z_index,
        };

        self.widget_layouts.insert(widget_config.id.clone(), layout);
        self.update_layout()?;
        Ok(())
    }

    /// Remove widget from layout
    pub fn remove_widget(&mut self, widget_id: &str) -> Result<()> {
        self.widget_layouts.remove(widget_id);
        self.update_layout()?;
        Ok(())
    }

    /// Update layout calculations
    pub fn update_layout(&mut self) -> Result<()> {
        match &self.config.layout_type {
            super::core::LayoutType::Grid => self.update_grid_layout(),
            super::core::LayoutType::Fixed => Ok(()), // Fixed layout doesn't need updates
            super::core::LayoutType::Flexbox => self.update_flexbox_layout(),
            super::core::LayoutType::Masonry => self.update_masonry_layout(),
            super::core::LayoutType::Custom(_) => self.update_custom_layout(),
        }
    }

    /// Update grid layout
    fn update_grid_layout(&mut self) -> Result<()> {
        if let Some(grid_config) = &self.config.grid_config {
            let cell_width = (self.container_constraints.width
                - (grid_config.column_gap * (grid_config.columns - 1)) as f64)
                / grid_config.columns as f64;
            let cell_height = (self.container_constraints.height
                - (grid_config.row_gap * (grid_config.rows - 1)) as f64)
                / grid_config.rows as f64;

            // Auto-arrange widgets in grid
            let mut col = 0;
            let mut row = 0;

            for layout in self.widget_layouts.values_mut() {
                layout.grid_position = Some(GridPosition {
                    col_start: col,
                    col_span: 1,
                    row_start: row,
                    row_span: 1,
                });

                layout.position = Position {
                    x: col as f64 * (cell_width + grid_config.column_gap as f64),
                    y: row as f64 * (cell_height + grid_config.row_gap as f64),
                };

                layout.size = Size {
                    width: cell_width,
                    height: cell_height,
                };

                col += 1;
                if col >= grid_config.columns {
                    col = 0;
                    row += 1;
                }
            }
        }
        Ok(())
    }

    /// Update flexbox layout
    fn update_flexbox_layout(&mut self) -> Result<()> {
        // Simplified flexbox implementation
        let widget_count = self.widget_layouts.len() as f64;
        if widget_count == 0.0 {
            return Ok(());
        }

        let available_width = self.container_constraints.width;
        let widget_width = available_width / widget_count;

        let mut x = 0.0;
        for layout in self.widget_layouts.values_mut() {
            layout.position.x = x;
            layout.position.y = 0.0;
            layout.size.width = widget_width;
            layout.size.height = self.container_constraints.height;
            x += widget_width;
        }

        Ok(())
    }

    /// Update masonry layout
    fn update_masonry_layout(&mut self) -> Result<()> {
        // Simplified masonry implementation
        let columns = 3; // Fixed for simplicity
        let column_width = self.container_constraints.width / columns as f64;
        let mut column_heights = vec![0.0; columns];

        for layout in self.widget_layouts.values_mut() {
            // Find shortest column
            let shortest_col = column_heights
                .iter()
                .enumerate()
                .min_by(|a, b| a.1.partial_cmp(b.1).unwrap())
                .map(|(i, _)| i)
                .unwrap_or(0);

            layout.position.x = shortest_col as f64 * column_width;
            layout.position.y = column_heights[shortest_col];
            layout.size.width = column_width;

            column_heights[shortest_col] += layout.size.height;
        }

        Ok(())
    }

    /// Update custom layout
    fn update_custom_layout(&mut self) -> Result<()> {
        // Placeholder for custom layout implementation
        Ok(())
    }

    /// Get widget layout
    pub fn get_widget_layout(&self, widget_id: &str) -> Option<&WidgetLayout> {
        self.widget_layouts.get(widget_id)
    }

    /// Update container constraints
    pub fn update_container_constraints(
        &mut self,
        constraints: ContainerConstraints,
    ) -> Result<()> {
        self.container_constraints = constraints;
        self.update_layout()
    }
}

impl LayoutConstraints {
    /// Create layout constraints from widget config
    pub fn from_widget_config(config: &WidgetConfig) -> Self {
        Self {
            min_size: Size {
                width: 50.0,
                height: 50.0,
            },
            max_size: Size {
                width: f64::INFINITY,
                height: f64::INFINITY,
            },
            aspect_ratio: None,
            fixed_width: None,
            fixed_height: None,
            margin: Margin::default(),
        }
    }
}

impl Default for LayoutConstraints {
    fn default() -> Self {
        Self {
            min_size: Size {
                width: 50.0,
                height: 50.0,
            },
            max_size: Size {
                width: f64::INFINITY,
                height: f64::INFINITY,
            },
            aspect_ratio: None,
            fixed_width: None,
            fixed_height: None,
            margin: Margin::default(),
        }
    }
}

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

impl Default for ContainerConstraints {
    fn default() -> Self {
        Self {
            width: 1200.0,
            height: 800.0,
            padding: Margin::default(),
            min_widget_size: Size {
                width: 50.0,
                height: 50.0,
            },
            max_widget_size: Size {
                width: 500.0,
                height: 500.0,
            },
        }
    }
}