use leptos::prelude::*;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use chrono::{DateTime, Utc};
use uuid::Uuid;
use gloo_storage::{LocalStorage, Storage};

use crate::components::grid::{GridLayout, GridPosition, GridSize};
use crate::components::charts::ChartConfig;
use crate::components::widgets::{ActivityFeedConfig, SystemHealthConfig, MetricConfig};
use crate::types::UserRole;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DashboardConfig {
    pub id: String,
    pub name: String,
    pub description: Option<String>,
    pub user_id: Option<String>,
    pub user_role: UserRole,
    pub layout: GridLayout,
    pub widgets: HashMap<String, WidgetConfig>,
    pub theme_config: ThemeSettings,
    pub filter_presets: Vec<FilterPreset>,
    pub export_settings: ExportSettings,
    pub auto_refresh_settings: AutoRefreshSettings,
    pub notification_settings: NotificationSettings,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub is_default: bool,
    pub is_template: bool,
    pub template_category: Option<String>,
    pub version: u32,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WidgetConfig {
    pub id: String,
    pub widget_type: WidgetType,
    pub position: GridPosition,
    pub size: GridSize,
    pub title: String,
    pub data_source: String,
    pub refresh_interval: u32,
    pub visible: bool,
    pub config_data: WidgetConfigData,
    pub permissions: WidgetPermissions,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum WidgetType {
    Chart,
    Metric,
    SystemHealth,
    ActivityFeed,
    Table,
    Map,
    Custom { component_name: String },
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "widget_type")]
pub enum WidgetConfigData {
    Chart(ChartConfig),
    Metric(MetricConfig),
    SystemHealth(SystemHealthConfig),
    ActivityFeed(ActivityFeedConfig),
    Table(TableConfig),
    Map(MapConfig),
    Custom(serde_json::Value),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WidgetPermissions {
    pub can_edit: bool,
    pub can_move: bool,
    pub can_resize: bool,
    pub can_remove: bool,
    pub required_roles: Vec<UserRole>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ThemeSettings {
    pub theme_name: String,
    pub custom_colors: HashMap<String, String>,
    pub font_size: FontSize,
    pub density: UiDensity,
    pub animation_enabled: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FilterPreset {
    pub id: String,
    pub name: String,
    pub filters: HashMap<String, serde_json::Value>,
    pub date_range: Option<DateRangePreset>,
    pub is_default: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DateRangePreset {
    pub name: String,
    pub range_type: DateRangeType,
    pub custom_start: Option<DateTime<Utc>>,
    pub custom_end: Option<DateTime<Utc>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum DateRangeType {
    Last15Minutes,
    LastHour,
    Last6Hours,
    Last24Hours,
    Last7Days,
    Last30Days,
    ThisMonth,
    LastMonth,
    Custom,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExportSettings {
    pub default_format: ExportFormat,
    pub include_metadata: bool,
    pub compress_data: bool,
    pub auto_timestamp: bool,
    pub custom_filename_template: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AutoRefreshSettings {
    pub enabled: bool,
    pub global_interval: u32, // seconds
    pub widget_overrides: HashMap<String, u32>,
    pub pause_when_hidden: bool,
    pub pause_on_error: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NotificationSettings {
    pub enabled: bool,
    pub position: NotificationPosition,
    pub auto_dismiss: bool,
    pub dismiss_timeout: u32,
    pub max_visible: u32,
    pub sound_enabled: bool,
    pub level_filters: Vec<NotificationLevel>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum FontSize {
    Small,
    Medium,
    Large,
    ExtraLarge,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum UiDensity {
    Compact,
    Normal,
    Comfortable,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ExportFormat {
    Png,
    Pdf,
    Csv,
    Excel,
    Json,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum NotificationPosition {
    TopRight,
    TopLeft,
    BottomRight,
    BottomLeft,
    TopCenter,
    BottomCenter,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum NotificationLevel {
    Info,
    Success,
    Warning,
    Error,
    Critical,
}

// Additional widget config types
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TableConfig {
    pub columns: Vec<TableColumn>,
    pub row_height: u32,
    pub pagination: PaginationConfig,
    pub sorting: SortingConfig,
    pub filtering: TableFilterConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TableColumn {
    pub id: String,
    pub label: String,
    pub field: String,
    pub width: Option<u32>,
    pub sortable: bool,
    pub filterable: bool,
    pub formatter: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PaginationConfig {
    pub enabled: bool,
    pub page_size: u32,
    pub show_size_selector: bool,
    pub available_sizes: Vec<u32>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SortingConfig {
    pub enabled: bool,
    pub multi_column: bool,
    pub default_sort: Option<(String, SortDirection)>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TableFilterConfig {
    pub enabled: bool,
    pub show_search: bool,
    pub column_filters: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum SortDirection {
    Asc,
    Desc,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MapConfig {
    pub center: (f64, f64), // lat, lng
    pub zoom: u32,
    pub map_style: String,
    pub show_controls: bool,
    pub markers: Vec<MapMarker>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MapMarker {
    pub id: String,
    pub position: (f64, f64),
    pub label: String,
    pub color: String,
    pub icon: Option<String>,
}

// Dashboard configuration service
#[derive(Debug, Clone)]
pub struct DashboardConfigService {
    current_config: RwSignal<DashboardConfig>,
    saved_configs: RwSignal<Vec<DashboardConfig>>,
    templates: RwSignal<Vec<DashboardTemplate>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DashboardTemplate {
    pub id: String,
    pub name: String,
    pub description: String,
    pub category: String,
    pub icon: String,
    pub config: DashboardConfig,
    pub preview_image: Option<String>,
    pub tags: Vec<String>,
    pub required_roles: Vec<UserRole>,
    pub created_by: String,
    pub is_official: bool,
}

impl DashboardConfigService {
    pub fn new() -> Self {
        // Load saved configurations from localStorage
        let saved_configs = LocalStorage::get::<Vec<DashboardConfig>>("dashboard_configs")
            .unwrap_or_default();

        // Load current configuration
        let current_config = if let Some(config) = saved_configs.first() {
            config.clone()
        } else {
            DashboardConfig::default_for_role(UserRole::Admin)
        };

        // Load templates
        let templates = Self::load_default_templates();

        Self {
            current_config: RwSignal::new(current_config),
            saved_configs: RwSignal::new(saved_configs),
            templates: RwSignal::new(templates),
        }
    }

    pub fn get_current_config(&self) -> ReadSignal<DashboardConfig> {
        self.current_config.into()
    }

    pub fn update_config<F>(&self, f: F)
    where
        F: FnOnce(&mut DashboardConfig) + 'static,
    {
        self.current_config.update(|config| {
            f(config);
            config.updated_at = Utc::now();
            config.version += 1;
        });

        // Auto-save to localStorage
        self.save_current_config();
    }

    pub fn save_current_config(&self) {
        let config = self.current_config.get();
        self.save_config(config);
    }

    pub fn save_config(&self, mut config: DashboardConfig) {
        config.updated_at = Utc::now();

        self.saved_configs.update(|configs| {
            // Update existing or add new
            if let Some(existing) = configs.iter_mut().find(|c| c.id == config.id) {
                *existing = config.clone();
            } else {
                configs.push(config.clone());
            }

            // Limit number of saved configs
            configs.sort_by(|a, b| b.updated_at.cmp(&a.updated_at));
            configs.truncate(10);

            // Save to localStorage
            let _ = LocalStorage::set("dashboard_configs", configs);
        });
    }

    pub fn load_config(&self, config_id: &str) -> Option<DashboardConfig> {
        self.saved_configs.get().into_iter().find(|c| c.id == config_id)
    }

    pub fn set_current_config(&self, config: DashboardConfig) {
        self.current_config.set(config);
        self.save_current_config();
    }

    pub fn delete_config(&self, config_id: &str) {
        self.saved_configs.update(|configs| {
            configs.retain(|c| c.id != config_id);
            let _ = LocalStorage::set("dashboard_configs", configs);
        });
    }

    pub fn get_saved_configs(&self) -> ReadSignal<Vec<DashboardConfig>> {
        self.saved_configs.into()
    }

    pub fn create_config_from_template(&self, template: &DashboardTemplate) -> DashboardConfig {
        let mut config = template.config.clone();
        config.id = Uuid::new_v4().to_string();
        config.name = format!("{} - Copy", template.name);
        config.created_at = Utc::now();
        config.updated_at = Utc::now();
        config.version = 1;
        config.is_template = false;
        config.is_default = false;
        config
    }

    pub fn get_templates(&self) -> ReadSignal<Vec<DashboardTemplate>> {
        self.templates.into()
    }

    pub fn get_templates_for_role(&self, role: UserRole) -> Vec<DashboardTemplate> {
        self.templates.get()
            .into_iter()
            .filter(|template| {
                template.required_roles.is_empty() ||
                template.required_roles.contains(&role)
            })
            .collect()
    }

    // Widget management
    pub fn add_widget(&self, widget: WidgetConfig) {
        self.update_config(|config| {
            config.widgets.insert(widget.id.clone(), widget);
        });
    }

    pub fn remove_widget(&self, widget_id: &str) {
        self.update_config(|config| {
            config.widgets.remove(widget_id);
        });
    }

    pub fn update_widget<F>(&self, widget_id: &str, f: F)
    where
        F: FnOnce(&mut WidgetConfig) + 'static,
    {
        self.update_config(|config| {
            if let Some(widget) = config.widgets.get_mut(widget_id) {
                f(widget);
            }
        });
    }

    pub fn move_widget(&self, widget_id: &str, position: GridPosition) {
        self.update_widget(widget_id, |widget| {
            widget.position = position;
        });
    }

    pub fn resize_widget(&self, widget_id: &str, size: GridSize) {
        self.update_widget(widget_id, |widget| {
            widget.size = size;
        });
    }

    // Layout management
    pub fn update_layout(&self, layout: GridLayout) {
        self.update_config(|config| {
            config.layout = layout;
        });
    }

    // Theme management
    pub fn update_theme(&self, theme_settings: ThemeSettings) {
        self.update_config(|config| {
            config.theme_config = theme_settings;
        });
    }

    // Filter presets
    pub fn add_filter_preset(&self, preset: FilterPreset) {
        self.update_config(|config| {
            config.filter_presets.push(preset);
        });
    }

    pub fn remove_filter_preset(&self, preset_id: &str) {
        self.update_config(|config| {
            config.filter_presets.retain(|p| p.id != preset_id);
        });
    }

    pub fn apply_filter_preset(&self, preset_id: &str) -> Option<FilterPreset> {
        let config = self.current_config.get();
        config.filter_presets.into_iter().find(|p| p.id == preset_id)
    }

    // Export functionality
    pub fn export_config(&self) -> String {
        let config = self.current_config.get();
        serde_json::to_string_pretty(&config).unwrap_or_default()
    }

    pub fn import_config(&self, config_json: &str) -> Result<(), String> {
        let config: DashboardConfig = serde_json::from_str(config_json)
            .map_err(|e| format!("Invalid configuration format: {}", e))?;

        self.set_current_config(config);
        Ok(())
    }

    // Reset functionality
    pub fn reset_to_default(&self, role: UserRole) {
        let default_config = DashboardConfig::default_for_role(role);
        self.set_current_config(default_config);
    }

    fn load_default_templates() -> Vec<DashboardTemplate> {
        vec![
            DashboardTemplate {
                id: "admin_dashboard".to_string(),
                name: "Administrator Dashboard".to_string(),
                description: "Complete overview with system metrics, security monitoring, and activity feeds".to_string(),
                category: "Admin".to_string(),
                icon: "bi-shield-check".to_string(),
                config: DashboardConfig::admin_template(),
                preview_image: Some("admin_dashboard_preview.png".to_string()),
                tags: vec!["admin".to_string(), "complete".to_string(), "monitoring".to_string()],
                required_roles: vec![UserRole::Admin],
                created_by: "System".to_string(),
                is_official: true,
            },
            DashboardTemplate {
                id: "security_dashboard".to_string(),
                name: "Security Dashboard".to_string(),
                description: "Focus on security metrics, threat detection, and compliance monitoring".to_string(),
                category: "Security".to_string(),
                icon: "bi-shield-exclamation".to_string(),
                config: DashboardConfig::security_template(),
                preview_image: Some("security_dashboard_preview.png".to_string()),
                tags: vec!["security".to_string(), "compliance".to_string(), "threats".to_string()],
                required_roles: vec![UserRole::Admin, UserRole::User],
                created_by: "System".to_string(),
                is_official: true,
            },
            DashboardTemplate {
                id: "operational_dashboard".to_string(),
                name: "Operations Dashboard".to_string(),
                description: "System health, performance metrics, and operational insights".to_string(),
                category: "Operations".to_string(),
                icon: "bi-gear".to_string(),
                config: DashboardConfig::operations_template(),
                preview_image: Some("operations_dashboard_preview.png".to_string()),
                tags: vec!["operations".to_string(), "performance".to_string(), "health".to_string()],
                required_roles: vec![UserRole::Admin, UserRole::User],
                created_by: "System".to_string(),
                is_official: true,
            },
            DashboardTemplate {
                id: "minimal_dashboard".to_string(),
                name: "Minimal Dashboard".to_string(),
                description: "Simple layout with essential metrics only".to_string(),
                category: "Basic".to_string(),
                icon: "bi-layout-text-sidebar".to_string(),
                config: DashboardConfig::minimal_template(),
                preview_image: Some("minimal_dashboard_preview.png".to_string()),
                tags: vec!["minimal".to_string(), "simple".to_string(), "basic".to_string()],
                required_roles: vec![], // Available to all roles
                created_by: "System".to_string(),
                is_official: true,
            },
        ]
    }
}

// Implementation of default configurations for different contexts
impl DashboardConfig {
    pub fn default_for_role(role: UserRole) -> Self {
        match role {
            UserRole::Admin => Self::admin_template(),
            UserRole::User => Self::user_template(),
            UserRole::ReadOnly => Self::readonly_template(),
        }
    }

    pub fn admin_template() -> Self {
        let mut config = Self::base_config("Admin Dashboard");

        // Add comprehensive widget set for admin
        config.widgets.insert("system_health".to_string(), WidgetConfig {
            id: "system_health".to_string(),
            widget_type: WidgetType::SystemHealth,
            position: GridPosition { x: 0, y: 0 },
            size: GridSize { width: 6, height: 3 },
            title: "System Health".to_string(),
            data_source: "system_metrics".to_string(),
            refresh_interval: 15,
            visible: true,
            config_data: WidgetConfigData::SystemHealth(SystemHealthConfig::default()),
            permissions: WidgetPermissions::admin(),
        });

        config.widgets.insert("workflow_metrics".to_string(), WidgetConfig {
            id: "workflow_metrics".to_string(),
            widget_type: WidgetType::Chart,
            position: GridPosition { x: 6, y: 0 },
            size: GridSize { width: 6, height: 3 },
            title: "Workflow Metrics".to_string(),
            data_source: "workflow_data".to_string(),
            refresh_interval: 30,
            visible: true,
            config_data: WidgetConfigData::Chart(ChartConfig::default()),
            permissions: WidgetPermissions::admin(),
        });

        config.widgets.insert("activity_feed".to_string(), WidgetConfig {
            id: "activity_feed".to_string(),
            widget_type: WidgetType::ActivityFeed,
            position: GridPosition { x: 0, y: 3 },
            size: GridSize { width: 8, height: 4 },
            title: "Activity Feed".to_string(),
            data_source: "activity_events".to_string(),
            refresh_interval: 30,
            visible: true,
            config_data: WidgetConfigData::ActivityFeed(ActivityFeedConfig::default()),
            permissions: WidgetPermissions::admin(),
        });

        config.widgets.insert("security_metrics".to_string(), WidgetConfig {
            id: "security_metrics".to_string(),
            widget_type: WidgetType::Chart,
            position: GridPosition { x: 8, y: 3 },
            size: GridSize { width: 4, height: 4 },
            title: "Security Events".to_string(),
            data_source: "security_data".to_string(),
            refresh_interval: 60,
            visible: true,
            config_data: WidgetConfigData::Chart(ChartConfig::default()),
            permissions: WidgetPermissions::admin(),
        });

        config
    }

    pub fn security_template() -> Self {
        let mut config = Self::base_config("Security Dashboard");

        // Security-focused widgets
        config.widgets.insert("security_overview".to_string(), WidgetConfig {
            id: "security_overview".to_string(),
            widget_type: WidgetType::Chart,
            position: GridPosition { x: 0, y: 0 },
            size: GridSize { width: 6, height: 3 },
            title: "Security Overview".to_string(),
            data_source: "security_metrics".to_string(),
            refresh_interval: 30,
            visible: true,
            config_data: WidgetConfigData::Chart(ChartConfig::default()),
            permissions: WidgetPermissions::user(),
        });

        config.widgets.insert("threat_feed".to_string(), WidgetConfig {
            id: "threat_feed".to_string(),
            widget_type: WidgetType::ActivityFeed,
            position: GridPosition { x: 6, y: 0 },
            size: GridSize { width: 6, height: 5 },
            title: "Security Events".to_string(),
            data_source: "security_events".to_string(),
            refresh_interval: 15,
            visible: true,
            config_data: WidgetConfigData::ActivityFeed(ActivityFeedConfig::default()),
            permissions: WidgetPermissions::user(),
        });

        config
    }

    pub fn operations_template() -> Self {
        let mut config = Self::base_config("Operations Dashboard");

        // Operations-focused widgets
        config.widgets.insert("system_resources".to_string(), WidgetConfig {
            id: "system_resources".to_string(),
            widget_type: WidgetType::Chart,
            position: GridPosition { x: 0, y: 0 },
            size: GridSize { width: 8, height: 3 },
            title: "System Resources".to_string(),
            data_source: "system_metrics".to_string(),
            refresh_interval: 15,
            visible: true,
            config_data: WidgetConfigData::Chart(ChartConfig::default()),
            permissions: WidgetPermissions::user(),
        });

        config.widgets.insert("system_health".to_string(), WidgetConfig {
            id: "system_health".to_string(),
            widget_type: WidgetType::SystemHealth,
            position: GridPosition { x: 8, y: 0 },
            size: GridSize { width: 4, height: 3 },
            title: "Health Status".to_string(),
            data_source: "health_data".to_string(),
            refresh_interval: 15,
            visible: true,
            config_data: WidgetConfigData::SystemHealth(SystemHealthConfig::default()),
            permissions: WidgetPermissions::user(),
        });

        config
    }

    pub fn user_template() -> Self {
        let mut config = Self::base_config("User Dashboard");

        // User-focused widgets
        config.widgets.insert("my_activities".to_string(), WidgetConfig {
            id: "my_activities".to_string(),
            widget_type: WidgetType::ActivityFeed,
            position: GridPosition { x: 0, y: 0 },
            size: GridSize { width: 8, height: 4 },
            title: "My Activities".to_string(),
            data_source: "user_activities".to_string(),
            refresh_interval: 60,
            visible: true,
            config_data: WidgetConfigData::ActivityFeed(ActivityFeedConfig::default()),
            permissions: WidgetPermissions::user(),
        });

        config.widgets.insert("quick_metrics".to_string(), WidgetConfig {
            id: "quick_metrics".to_string(),
            widget_type: WidgetType::Metric,
            position: GridPosition { x: 8, y: 0 },
            size: GridSize { width: 4, height: 2 },
            title: "Quick Stats".to_string(),
            data_source: "user_metrics".to_string(),
            refresh_interval: 120,
            visible: true,
            config_data: WidgetConfigData::Metric(MetricConfig::default()),
            permissions: WidgetPermissions::user(),
        });

        config
    }

    pub fn readonly_template() -> Self {
        let mut config = Self::base_config("Readonly Dashboard");

        // Readonly widgets with view-only permissions
        config.widgets.insert("status_overview".to_string(), WidgetConfig {
            id: "status_overview".to_string(),
            widget_type: WidgetType::SystemHealth,
            position: GridPosition { x: 0, y: 0 },
            size: GridSize { width: 6, height: 3 },
            title: "System Status".to_string(),
            data_source: "system_status".to_string(),
            refresh_interval: 60,
            visible: true,
            config_data: WidgetConfigData::SystemHealth(SystemHealthConfig::default()),
            permissions: WidgetPermissions::readonly(),
        });

        config.widgets.insert("basic_metrics".to_string(), WidgetConfig {
            id: "basic_metrics".to_string(),
            widget_type: WidgetType::Metric,
            position: GridPosition { x: 6, y: 0 },
            size: GridSize { width: 6, height: 3 },
            title: "Key Metrics".to_string(),
            data_source: "basic_metrics".to_string(),
            refresh_interval: 120,
            visible: true,
            config_data: WidgetConfigData::Metric(MetricConfig::default()),
            permissions: WidgetPermissions::readonly(),
        });

        config
    }

    pub fn minimal_template() -> Self {
        let mut config = Self::base_config("Minimal Dashboard");

        // Single widget for minimal interface
        config.widgets.insert("essential_metrics".to_string(), WidgetConfig {
            id: "essential_metrics".to_string(),
            widget_type: WidgetType::Metric,
            position: GridPosition { x: 0, y: 0 },
            size: GridSize { width: 12, height: 2 },
            title: "Essential Metrics".to_string(),
            data_source: "essential_data".to_string(),
            refresh_interval: 60,
            visible: true,
            config_data: WidgetConfigData::Metric(MetricConfig::default()),
            permissions: WidgetPermissions::user(),
        });

        config
    }

    fn base_config(name: &str) -> Self {
        Self {
            id: Uuid::new_v4().to_string(),
            name: name.to_string(),
            description: None,
            user_id: None,
            user_role: UserRole::User,
            layout: GridLayout::default(),
            widgets: HashMap::new(),
            theme_config: ThemeSettings::default(),
            filter_presets: vec![],
            export_settings: ExportSettings::default(),
            auto_refresh_settings: AutoRefreshSettings::default(),
            notification_settings: NotificationSettings::default(),
            created_at: Utc::now(),
            updated_at: Utc::now(),
            is_default: true,
            is_template: false,
            template_category: None,
            version: 1,
        }
    }
}

// Default implementations
impl Default for ThemeSettings {
    fn default() -> Self {
        Self {
            theme_name: "auto".to_string(),
            custom_colors: HashMap::new(),
            font_size: FontSize::Medium,
            density: UiDensity::Normal,
            animation_enabled: true,
        }
    }
}

impl Default for ExportSettings {
    fn default() -> Self {
        Self {
            default_format: ExportFormat::Png,
            include_metadata: true,
            compress_data: false,
            auto_timestamp: true,
            custom_filename_template: None,
        }
    }
}

impl Default for AutoRefreshSettings {
    fn default() -> Self {
        Self {
            enabled: true,
            global_interval: 30,
            widget_overrides: HashMap::new(),
            pause_when_hidden: true,
            pause_on_error: true,
        }
    }
}

impl Default for NotificationSettings {
    fn default() -> Self {
        Self {
            enabled: true,
            position: NotificationPosition::TopRight,
            auto_dismiss: true,
            dismiss_timeout: 5,
            max_visible: 5,
            sound_enabled: false,
            level_filters: vec![], // Empty = show all levels
        }
    }
}

impl WidgetPermissions {
    pub fn admin() -> Self {
        Self {
            can_edit: true,
            can_move: true,
            can_resize: true,
            can_remove: true,
            required_roles: vec![UserRole::Admin],
        }
    }

    pub fn user() -> Self {
        Self {
            can_edit: true,
            can_move: true,
            can_resize: true,
            can_remove: true,
            required_roles: vec![UserRole::Admin, UserRole::User],
        }
    }

    pub fn readonly() -> Self {
        Self {
            can_edit: false,
            can_move: false,
            can_resize: false,
            can_remove: false,
            required_roles: vec![], // All roles can view
        }
    }
}