glitcher_core/

ui_dsl.rs

//! UI DSL - Declarative UI System for Glitcher
//!
//! "UI as Data, Not Code"
//!
//! MODs define UI structure (What), Host renders it (How).
//! This provides:
//! - Unified look & feel across all MODs
//! - Automatic LFO/MIDI assignment for any parameter
//! - Theme switching affects all MODs at once
//! - Lightweight WASM (no UI code in modules)

use serde::{Deserialize, Serialize};
use serde_json;

/// UI Component - the AST of the UI DSL
///
/// MODs return this structure to define their UI.
/// Host interprets and renders using egui.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum UiComponent {
    // ==========================================================================
    // Layout Containers
    // ==========================================================================
    /// Grouped section with label
    Group {
        label: String,
        children: Vec<UiComponent>,
    },

    /// Horizontal row of components
    Row { children: Vec<UiComponent> },

    /// Vertical column of components
    Column { children: Vec<UiComponent> },

    /// Tabbed sections
    Tabs { tabs: Vec<UiTab> },

    // ==========================================================================
    // Basic Controls
    // ==========================================================================
    /// Rotary knob (best for VJ performance)
    Knob {
        label: String,
        param_id: u32,
        min: f32,
        max: f32,
        #[serde(default)]
        logarithmic: bool,
    },

    /// Horizontal slider
    Slider {
        label: String,
        param_id: u32,
        min: f32,
        max: f32,
    },

    /// On/off toggle
    Toggle { label: String, param_id: u32 },

    /// Dropdown selection
    Dropdown {
        label: String,
        param_id: u32,
        options: Vec<String>,
    },

    /// Button group (radio button style for VJ)
    ButtonGroup {
        label: String,
        param_id: u32,
        options: Vec<String>,
    },

    /// Color picker (RGB) - for 3-param use cases
    ColorPicker {
        label: String,
        r_param_id: u32,
        g_param_id: u32,
        b_param_id: u32,
    },

    /// Hue slider (single param) - for WIT ColorPicker (0.0 = red, 1.0 = red wrap)
    HueSlider { label: String, param_id: u32 },

    // ==========================================================================
    // VJ Special Widgets
    // ==========================================================================
    /// 2D XY pad controller
    XYPad {
        label: String,
        x_param_id: u32,
        y_param_id: u32,
    },

    /// Bezier curve editor
    Curves { label: String, param_id: u32 },

    /// Audio waveform/spectrum visualizer
    AudioScope { label: String, source: AudioSource },

    /// Beat-synced trigger button
    BeatButton {
        label: String,
        trigger_id: u32,
        division: NoteDivision,
    },

    /// Action button (one-shot trigger via Action System)
    ActionButton { label: String, action_id: String },

    /// Trigger button - param-based one-shot (sends 1.0 for one frame, auto-resets to 0.0)
    TriggerButton { label: String, param_id: u32 },

    /// Modulation source slot (for patching)
    ModulationSlot { label: String, target_param_id: u32 },

    /// Control signal preview (waveform display for LFO, envelope, etc.)
    ControlPreview {
        label: String,
        port_name: String,
        /// History buffer for waveform display (values 0.0-1.0)
        #[serde(default)]
        history_length: u32,
    },

    /// Control target selector for ControlOutput nodes (LFO, etc.)
    ///
    /// Displays a dropdown to select which node/parameter this control output
    /// should modulate. The actual connection is managed by the host.
    ControlTargetSelector {
        label: String,
        /// The control output port name (e.g., "output")
        port_name: String,
    },

    // ==========================================================================
    // Display Only
    // ==========================================================================
    /// Static label text
    Label { text: String },

    /// Separator line
    Separator,

    /// Spacer
    Spacer { height: f32 },

    // ==========================================================================
    // Custom / Extension
    // ==========================================================================
    /// Custom widget rendered by host
    ///
    /// For complex widgets that can't be expressed in DSL.
    /// Host looks up a custom renderer by widget_id.
    Custom {
        widget_id: String,
        #[serde(default)]
        props: std::collections::HashMap<String, String>,
    },
}

/// Tab definition for Tabs component
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UiTab {
    pub label: String,
    pub children: Vec<UiComponent>,
}

/// Audio source for AudioScope widget
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum AudioSource {
    /// Full spectrum
    Master,
    /// Low frequencies (bass)
    Low,
    /// Mid frequencies
    Mid,
    /// High frequencies (treble)
    High,
}

/// Note division for BeatButton (musical note values)
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
pub enum NoteDivision {
    /// Whole note (1 bar)
    Whole,
    /// Half note
    Half,
    /// Quarter note
    #[default]
    Quarter,
    /// Eighth note
    Eighth,
    /// Sixteenth note
    Sixteenth,
}

// =============================================================================
// Builder helpers for cleaner MOD code
// =============================================================================

impl UiComponent {
    /// Create a group
    pub fn group(label: impl Into<String>, children: Vec<UiComponent>) -> Self {
        Self::Group {
            label: label.into(),
            children,
        }
    }

    /// Create a row
    pub fn row(children: Vec<UiComponent>) -> Self {
        Self::Row { children }
    }

    /// Create a column
    pub fn column(children: Vec<UiComponent>) -> Self {
        Self::Column { children }
    }

    /// Create a knob
    pub fn knob(label: impl Into<String>, param_id: u32, min: f32, max: f32) -> Self {
        Self::Knob {
            label: label.into(),
            param_id,
            min,
            max,
            logarithmic: false,
        }
    }

    /// Create a logarithmic knob
    pub fn knob_log(label: impl Into<String>, param_id: u32, min: f32, max: f32) -> Self {
        Self::Knob {
            label: label.into(),
            param_id,
            min,
            max,
            logarithmic: true,
        }
    }

    /// Create a slider
    pub fn slider(label: impl Into<String>, param_id: u32, min: f32, max: f32) -> Self {
        Self::Slider {
            label: label.into(),
            param_id,
            min,
            max,
        }
    }

    /// Create a toggle
    pub fn toggle(label: impl Into<String>, param_id: u32) -> Self {
        Self::Toggle {
            label: label.into(),
            param_id,
        }
    }

    /// Create a dropdown
    pub fn dropdown(label: impl Into<String>, param_id: u32, options: Vec<String>) -> Self {
        Self::Dropdown {
            label: label.into(),
            param_id,
            options,
        }
    }

    /// Create a button group
    pub fn button_group(label: impl Into<String>, param_id: u32, options: Vec<String>) -> Self {
        Self::ButtonGroup {
            label: label.into(),
            param_id,
            options,
        }
    }

    /// Create an XY pad
    pub fn xy_pad(label: impl Into<String>, x_param_id: u32, y_param_id: u32) -> Self {
        Self::XYPad {
            label: label.into(),
            x_param_id,
            y_param_id,
        }
    }

    /// Create an audio scope
    pub fn audio_scope(label: impl Into<String>, source: AudioSource) -> Self {
        Self::AudioScope {
            label: label.into(),
            source,
        }
    }

    /// Create a beat button
    pub fn beat_button(label: impl Into<String>, trigger_id: u32, division: NoteDivision) -> Self {
        Self::BeatButton {
            label: label.into(),
            trigger_id,
            division,
        }
    }

    /// Create an action button (one-shot trigger via Action System)
    pub fn action_button(label: impl Into<String>, action_id: impl Into<String>) -> Self {
        Self::ActionButton {
            label: label.into(),
            action_id: action_id.into(),
        }
    }

    /// Create a trigger button (param-based one-shot, auto-resets to 0.0)
    pub fn trigger_button(label: impl Into<String>, param_id: u32) -> Self {
        Self::TriggerButton {
            label: label.into(),
            param_id,
        }
    }

    /// Create a modulation slot
    pub fn mod_slot(label: impl Into<String>, target_param_id: u32) -> Self {
        Self::ModulationSlot {
            label: label.into(),
            target_param_id,
        }
    }

    /// Create a control preview (waveform display for control signals)
    pub fn control_preview(
        label: impl Into<String>,
        port_name: impl Into<String>,
        history_length: u32,
    ) -> Self {
        Self::ControlPreview {
            label: label.into(),
            port_name: port_name.into(),
            history_length,
        }
    }

    /// Create a control target selector (for ControlOutput nodes like LFO)
    pub fn control_target_selector(label: impl Into<String>, port_name: impl Into<String>) -> Self {
        Self::ControlTargetSelector {
            label: label.into(),
            port_name: port_name.into(),
        }
    }

    /// Create a label
    pub fn label(text: impl Into<String>) -> Self {
        Self::Label { text: text.into() }
    }

    /// Create a separator
    pub fn separator() -> Self {
        Self::Separator
    }

    /// Create a spacer
    pub fn spacer(height: f32) -> Self {
        Self::Spacer { height }
    }

    /// Create a custom widget
    pub fn custom(widget_id: impl Into<String>) -> Self {
        Self::Custom {
            widget_id: widget_id.into(),
            props: std::collections::HashMap::new(),
        }
    }

    /// Create a custom widget with properties
    pub fn custom_with_props(
        widget_id: impl Into<String>,
        props: std::collections::HashMap<String, String>,
    ) -> Self {
        Self::Custom {
            widget_id: widget_id.into(),
            props,
        }
    }
}

// =============================================================================
// Layout Configuration (saveable/loadable)
// =============================================================================

/// Layout configuration for control panel
///
/// Supports saving/loading layouts and future 2D positioning.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LayoutConfig {
    /// Layout format version
    pub version: u32,

    /// Layout name for display
    pub name: String,

    /// Panel sections with optional 2D positioning
    pub sections: Vec<SectionConfig>,

    /// MOD UI slots (where MOD UIs are inserted)
    #[serde(default)]
    pub mod_slots: Vec<ModSlotConfig>,
}

/// Section configuration with optional 2D positioning
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SectionConfig {
    /// Widget ID (e.g., "header", "effects", "midi")
    pub widget_id: String,

    /// Whether this section is visible
    #[serde(default = "default_true")]
    pub visible: bool,

    /// Optional 2D position (for future grid/absolute layout)
    #[serde(default)]
    pub position: Option<LayoutPosition>,

    /// Optional size hints
    #[serde(default)]
    pub size: Option<LayoutSize>,

    /// Section-specific properties
    #[serde(default)]
    pub props: std::collections::HashMap<String, String>,
}

/// MOD UI slot configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModSlotConfig {
    /// Slot identifier
    pub slot_id: String,

    /// Position in the layout (after which section)
    pub after_section: Option<String>,

    /// MOD ID to display in this slot (None = empty slot)
    pub mod_id: Option<String>,

    /// 2D position (for future)
    #[serde(default)]
    pub position: Option<LayoutPosition>,

    /// Size hints
    #[serde(default)]
    pub size: Option<LayoutSize>,
}

/// 2D position for grid/absolute layout
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub struct LayoutPosition {
    /// X position (grid column or pixels)
    pub x: f32,
    /// Y position (grid row or pixels)
    pub y: f32,
}

/// Size hints for layout
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub struct LayoutSize {
    /// Width (grid units or pixels, 0 = auto)
    pub width: f32,
    /// Height (grid units or pixels, 0 = auto)
    pub height: f32,
}

fn default_true() -> bool {
    true
}

impl Default for LayoutConfig {
    fn default() -> Self {
        Self {
            version: 1,
            name: "Default".to_string(),
            sections: vec![
                SectionConfig::new("header"),
                SectionConfig::new("audio_status"),
                SectionConfig::new("frequency_bars"),
                SectionConfig::new("effects"),
                SectionConfig::new("textures"),
                SectionConfig::new("recording"),
                SectionConfig::new("modulation"),
                SectionConfig::new("blend_mode"),
                SectionConfig::new("color_scheme"),
                SectionConfig::new("simulation"),
                SectionConfig::new("midi"),
                SectionConfig::new("footer"),
            ],
            mod_slots: vec![ModSlotConfig {
                slot_id: "mod_slot_1".to_string(),
                after_section: Some("simulation".to_string()),
                mod_id: None,
                position: None,
                size: None,
            }],
        }
    }
}

impl SectionConfig {
    pub fn new(widget_id: impl Into<String>) -> Self {
        Self {
            widget_id: widget_id.into(),
            visible: true,
            position: None,
            size: None,
            props: std::collections::HashMap::new(),
        }
    }

    pub fn with_visibility(mut self, visible: bool) -> Self {
        self.visible = visible;
        self
    }

    pub fn with_position(mut self, x: f32, y: f32) -> Self {
        self.position = Some(LayoutPosition { x, y });
        self
    }

    pub fn with_size(mut self, width: f32, height: f32) -> Self {
        self.size = Some(LayoutSize { width, height });
        self
    }
}

impl LayoutConfig {
    /// Build UiComponent tree from this config
    pub fn to_ui_component(&self) -> UiComponent {
        let mut children: Vec<UiComponent> = Vec::new();

        for (i, section) in self.sections.iter().enumerate() {
            if !section.visible {
                continue;
            }

            // Add spacer between sections (except first)
            if i > 0 {
                children.push(UiComponent::spacer(10.0));
            }

            // Check if any MOD slot should be inserted after this section
            for mod_slot in &self.mod_slots {
                if mod_slot.after_section.as_deref() == Some(&section.widget_id) {
                    if let Some(mod_id) = &mod_slot.mod_id {
                        // Insert MOD UI placeholder
                        children.push(UiComponent::spacer(10.0));
                        children.push(UiComponent::custom_with_props(
                            "mod_ui",
                            [("mod_id".to_string(), mod_id.clone())]
                                .into_iter()
                                .collect(),
                        ));
                    }
                }
            }

            // Add section
            children.push(UiComponent::custom_with_props(
                section.widget_id.clone(),
                section.props.clone(),
            ));
        }

        UiComponent::column(children)
    }

    /// Save layout to JSON string
    pub fn to_json(&self) -> Result<String, serde_json::Error> {
        serde_json::to_string_pretty(self)
    }

    /// Load layout from JSON string
    pub fn from_json(json: &str) -> Result<Self, serde_json::Error> {
        serde_json::from_str(json)
    }
}

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

    #[test]
    fn test_ui_component_serialization() {
        let ui = UiComponent::group(
            "Test",
            vec![
                UiComponent::knob("Intensity", 0, 0.0, 1.0),
                UiComponent::toggle("Enable", 1),
            ],
        );

        let json = serde_json::to_string_pretty(&ui).unwrap();
        println!("{}", json);

        let parsed: UiComponent = serde_json::from_str(&json).unwrap();
        match parsed {
            UiComponent::Group { label, children } => {
                assert_eq!(label, "Test");
                assert_eq!(children.len(), 2);
            }
            _ => panic!("Expected Group"),
        }
    }

    #[test]
    fn test_layout_config_serialization() {
        let config = LayoutConfig::default();
        let json = config.to_json().unwrap();
        println!("Default layout:\n{}", json);

        let parsed = LayoutConfig::from_json(&json).unwrap();
        assert_eq!(parsed.version, 1);
        assert_eq!(parsed.name, "Default");
        assert_eq!(parsed.sections.len(), 12);
        assert_eq!(parsed.mod_slots.len(), 1);
    }

    #[test]
    fn test_layout_config_to_ui_component() {
        let mut config = LayoutConfig::default();
        // Hide some sections
        config.sections[2].visible = false; // frequency_bars
        config.sections[5].visible = false; // recording

        let ui = config.to_ui_component();
        match ui {
            UiComponent::Column { children } => {
                // Should have fewer children due to hidden sections
                assert!(children.len() < 24); // Less than 12 sections * 2 (section + spacer)
            }
            _ => panic!("Expected Column"),
        }
    }

    #[test]
    fn test_layout_config_with_mod_slot() {
        let mut config = LayoutConfig::default();
        config.mod_slots[0].mod_id = Some("chromatic_aberration".to_string());

        let ui = config.to_ui_component();
        let json = serde_json::to_string_pretty(&ui).unwrap();
        println!("Layout with MOD:\n{}", json);

        // Should contain mod_ui custom widget
        assert!(json.contains("mod_ui"));
        assert!(json.contains("chromatic_aberration"));
    }
}