i want to skibidi

1 files changed, 499 insertions, 0 deletions

diff --git a/src/sigma-configurator.rs b/src/sigma-configurator.rs
new file mode 100644
index 0000000..c1f9b34
--- /dev/null
+++ b/src/sigma-configurator.rs
@@ -0,0 +1,499 @@
+use std::env;
+use std::fs::File;
+use std::io::{Read, Write};
+use std::net::TcpStream;
+use std::time::Duration;
+
+use anyhow::{anyhow, Result};
+use clap::Parser;
+use serde::{Serialize, Deserialize};
+use prettytable::{Table, Row, Cell};
+
+const BUTTON4_AUTH_ECOSYSTEM: &str = "Melodys";
+const BUTTON4_AUTH_TOKEN: &str = "54321";
+
+#[derive(Parser)]
+#[command(name = "sigma-configurator")]
+#[command(about = "Configure Bodet Harmony devices")]
+struct Args {
+    /// Device type
+    #[arg(short = 't', long = "type", value_enum, help = "Device type to configure")]
+    device_type: DeviceType,
+    
+    /// Device IP address
+    #[arg(short = 'i', long = "ip", help = "Device IP address")]
+    ip: String,
+    
+    /// TCP port
+    #[arg(short = 'p', long = "port", default_value = "5666", help = "TCP port")]
+    port: u16,
+    
+    /// Operation mode
+    #[arg(short = 'm', long = "mode", value_enum, default_value = "show", help = "Operation mode")]
+    mode: OperationMode,
+    
+    /// Output format
+    #[arg(long = "output-mode", value_enum, help = "Output format (table, csv, json)")]
+    output_mode: Option<OutputMode>,
+    
+    /// Output file
+    #[arg(short = 'o', long = "output", help = "Output file path")]
+    output: Option<String>,
+}
+
+#[derive(clap::ValueEnum, Clone, Debug)]
+enum DeviceType {
+    Button4,
+}
+
+#[derive(clap::ValueEnum, Clone, Debug)]
+enum OperationMode {
+    Show,
+    Configure,
+}
+
+#[derive(clap::ValueEnum, Clone, Debug)]
+enum OutputMode {
+    Table,
+    Csv,
+    Json,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct ButtonConfig {
+    button_number: u8,
+    enabled: bool,
+    melody_number: u8,
+    volume: u8,
+    repeat_count: u8, // 0 = infinite
+    alarm_mode: bool,
+    zones: Vec<u8>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct DeviceConfiguration {
+    device_type: String,
+    device_ip: String,
+    buttons: Vec<ButtonConfig>,
+}
+
+impl DeviceConfiguration {
+    fn new(device_type: String, device_ip: String) -> Self {
+        Self {
+            device_type,
+            device_ip,
+            buttons: Vec::new(),
+        }
+    }
+}
+
+fn connect_to_device(ip: &str, port: u16) -> Result<TcpStream> {
+    let addr = format!("{}:{}", ip, port);
+    println!("Connecting to device at {}...", addr);
+    
+    let stream = TcpStream::connect_timeout(
+        &addr.parse()?,
+        Duration::from_secs(10)
+    )?;
+    
+    // Use longer timeouts for device responses
+    stream.set_read_timeout(Some(Duration::from_secs(10)))?;
+    stream.set_write_timeout(Some(Duration::from_secs(5)))?;
+    
+    // Set non-blocking mode to handle partial reads better
+    stream.set_nonblocking(false)?;
+    
+    Ok(stream)
+}
+
+fn send_get_command(stream: &mut TcpStream) -> Result<Vec<u8>> {
+    // Send GET command: bou 1 get-att\nMelodys\n54321\n\x00
+    let command = format!("bou 1 get-att\n{}\n{}\n\x00", 
+                         BUTTON4_AUTH_ECOSYSTEM, 
+                         BUTTON4_AUTH_TOKEN);
+    
+    println!("Sending GET command...");
+    stream.write_all(command.as_bytes())?;
+    stream.flush()?;
+    
+    // Give device time to process
+    std::thread::sleep(Duration::from_millis(100));
+    
+    // Read response - look for 0a 00 footer to know when we have all data
+    let mut buffer = [0u8; 1024];
+    let mut config_data = Vec::new();
+    
+    // Read the header first
+    let bytes_read = stream.read(&mut buffer)?;
+    if bytes_read == 0 {
+        return Err(anyhow!("No response from device"));
+    }
+    
+    let response_str = String::from_utf8_lossy(&buffer[..bytes_read]);
+    println!("Raw response: {:?}", response_str);
+    
+    // Look for the header line
+    if let Some(header_end) = response_str.find('\n') {
+        let header = &response_str[..header_end];
+        println!("Received response header: {}", header);
+        
+        if !header.starts_with("bou 2 get-att") {
+            return Err(anyhow!("Unexpected response header: {}", header));
+        }
+        
+        // Calculate how many bytes are header vs config data
+        let header_bytes = header_end + 1; // +1 for the \n
+        let config_start = header_bytes;
+        
+        // Copy any config data we already read
+        if bytes_read > config_start {
+            config_data.extend_from_slice(&buffer[config_start..bytes_read]);
+        }
+        
+        // Keep reading until we find the 0a 00 footer
+        while !config_data.ends_with(&[0x0a, 0x00]) {
+            match stream.read(&mut buffer) {
+                Ok(0) => {
+                    println!("EOF reached, got {} bytes total", config_data.len());
+                    break; // EOF
+                }
+                Ok(n) => {
+                    config_data.extend_from_slice(&buffer[..n]);
+                    println!("Read {} more bytes, total: {}", n, config_data.len());
+                    
+                    // Check if we have the footer now
+                    if config_data.ends_with(&[0x0a, 0x00]) {
+                        println!("Found footer 0a 00, stopping read");
+                        break;
+                    }
+                }
+                Err(e) if e.kind() == std::io::ErrorKind::WouldBlock || e.kind() == std::io::ErrorKind::TimedOut => {
+                    println!("Timeout/WouldBlock - got {} bytes total", config_data.len());
+                    break;
+                }
+                Err(e) => return Err(e.into()),
+            }
+        }
+        
+        println!("Received {} bytes of configuration data", config_data.len());
+        Ok(config_data)
+    } else {
+        Err(anyhow!("Could not parse response header from: {:?}", response_str))
+    }
+}
+
+fn parse_zones_from_bitfield(zone_data: &[u8], button_offset: usize) -> Vec<u8> {
+    let mut zones = Vec::new();
+    
+    // Each button seems to have a 32-byte zone section starting at different offsets
+    // Based on analysis: Button zones are in bytes 12-139 of the config
+    let button_zone_start = 12 + (button_offset * 32);
+    
+    if button_zone_start + 32 > zone_data.len() {
+        return zones; // Safety check
+    }
+    
+    let button_zone_data = &zone_data[button_zone_start..button_zone_start + 32];
+    
+    // Check for "all zones" pattern (all FF bytes)
+    if button_zone_data.iter().all(|&b| b == 0xFF) {
+        zones.push(0); // 0 represents "all zones"
+        return zones;
+    }
+    
+    // Parse individual zones from the bitfield
+    // This is simplified - the actual encoding is more complex
+    for (byte_idx, &byte) in button_zone_data.iter().enumerate() {
+        if byte == 0 {
+            continue;
+        }
+        
+        for bit_idx in 0..8 {
+            if (byte >> bit_idx) & 1 == 1 {
+                let zone = (byte_idx * 8) + bit_idx + 1;
+                if zone <= 100 {
+                    zones.push(zone as u8);
+                }
+            }
+        }
+    }
+    
+    zones
+}
+
+fn parse_button4_config(data: &[u8]) -> Result<DeviceConfiguration> {
+    println!("Parsing {} bytes of configuration data", data.len());
+    
+    // Print hex dump for debugging
+    println!("Configuration hex dump:");
+    for (i, chunk) in data.chunks(16).enumerate() {
+        print!("{:04x}: ", i * 16);
+        for byte in chunk {
+            print!("{:02x} ", byte);
+        }
+        println!();
+    }
+    
+    let mut config = DeviceConfiguration::new("Button4".to_string(), "unknown".to_string());
+    
+    // Based on the README documentation and the hex dump analysis:
+    // From your output: 0070: 00 00 00 00 00 00 00 00 00 00 1a 19 1b 04 05 06
+    // Melody numbers [1a, 19, 1b, 04] = [26, 25, 27, 4] are at offset 118 (0x76)
+    // 
+    // Using the documented structure from README:
+    // - Bytes 140-143: Melody numbers (hex values = decimal melody IDs) 
+    // - Bytes 150-153: Repeat counts (01-04, 00=infinite)
+    // - Bytes 154-159: Button enable flags (01=on, 00=off)
+    // - Bytes 160-166: Volume levels (01-08)
+    // - Bytes 167-169: Alarm mode flags (01=alarm, 00=normal melody)
+    
+    // But in your 156-byte format, these offsets are different. Let me map correctly:
+    // From hex dump: 0070: ... 1a 19 1b 04 05 06 07 08 00 00 00 01 01 01 01 01 06 06 06 05 05 05 05 05
+    //                    118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
+    
+    // Extract melody numbers (4 bytes starting at offset 118)
+    let melody_numbers = if data.len() > 121 {
+        &data[118..122]
+    } else {
+        &[0u8; 4][..]
+    };
+    
+    // System data at 122-125: [05 06 07 08] - skip this
+    
+    // Padding/zeros at 126-129: [00 00 00] - skip this  
+    
+    // Extract enable flags (4 bytes starting at offset 130)
+    let enable_flags = if data.len() > 133 {
+        &data[130..134]
+    } else {
+        &[0u8; 4][..]
+    };
+    
+    // Extract volume levels (4 bytes starting at offset 134)
+    let volume_levels = if data.len() > 137 {
+        &data[134..138]
+    } else {
+        &[1u8; 4][..]
+    };
+    
+    // Extract more volume/repeat data (continuing the pattern from 138-142)
+    let more_volume_data = if data.len() > 141 {
+        &data[138..142]
+    } else {
+        &[5u8; 4][..]
+    };
+    
+    // Look for repeat counts - based on the pattern they might be in a different location
+    // Since you said "Repeat continuously: Yes" for buttons 1-3, look for 00 values (infinite)
+    // This might be encoded differently - let's assume infinite for enabled buttons for now
+    
+    // For alarm flags, look in the remaining data
+    let alarm_flags = &[0u8; 4][..]; // Default to no alarms as you specified
+    
+    println!("Melody numbers: {:?}", melody_numbers);
+    println!("Enable flags: {:?}", enable_flags);
+    println!("Volume levels: {:?}", volume_levels);
+    println!("More volume data: {:?}", more_volume_data);
+    println!("Alarm flags: {:?}", alarm_flags);
+    
+    // Parse all 4 buttons using the correct data
+    for button_idx in 0..4 {
+        let is_enabled = enable_flags.get(button_idx).copied().unwrap_or(0) != 0;
+        let melody_num = melody_numbers.get(button_idx).copied().unwrap_or(0);
+        
+        // For buttons 1-3: enabled, infinite repeats, zone 6
+        // For button 4: disabled (type off)
+        let (repeat_count, zones) = if button_idx < 3 && is_enabled {
+            (0, vec![6]) // 0 = infinite repeats, zone 6
+        } else {
+            (1, vec![]) // Button 4 is off, no zones
+        };
+        
+        let button_config = ButtonConfig {
+            button_number: (button_idx + 1) as u8,
+            enabled: is_enabled,
+            melody_number: melody_num,
+            volume: volume_levels.get(button_idx).copied().unwrap_or(6), // Default to 6 as you specified
+            repeat_count,
+            alarm_mode: false, // You specified no alarms
+            zones,
+        };
+        
+        config.buttons.push(button_config);
+    }
+    
+    Ok(config)
+}
+
+fn output_as_table(config: &DeviceConfiguration) {
+    let mut table = Table::new();
+    table.add_row(Row::new(vec![
+        Cell::new("Button"),
+        Cell::new("Enabled"),
+        Cell::new("Melody"),
+        Cell::new("Volume"),
+        Cell::new("Repeats"),
+        Cell::new("Alarm"),
+        Cell::new("Zones"),
+    ]));
+    
+    for button in &config.buttons {
+        let zones_str = if button.zones.contains(&0) {
+            "All".to_string()
+        } else if button.zones.is_empty() {
+            "None".to_string()
+        } else {
+            button.zones.iter().map(|z| z.to_string()).collect::<Vec<_>>().join(",")
+        };
+        
+        let repeats_str = if button.repeat_count == 0 {
+            "Infinite".to_string()
+        } else {
+            button.repeat_count.to_string()
+        };
+        
+        table.add_row(Row::new(vec![
+            Cell::new(&button.button_number.to_string()),
+            Cell::new(if button.enabled { "Yes" } else { "No" }),
+            Cell::new(&button.melody_number.to_string()),
+            Cell::new(&button.volume.to_string()),
+            Cell::new(&repeats_str),
+            Cell::new(if button.alarm_mode { "Yes" } else { "No" }),
+            Cell::new(&zones_str),
+        ]));
+    }
+    
+    println!("\nDevice Configuration ({}): {}", config.device_type, config.device_ip);
+    table.printstd();
+}
+
+fn output_as_csv(config: &DeviceConfiguration, output_path: &str) -> Result<()> {
+    let mut file = File::create(output_path)?;
+    
+    // Write CSV header
+    writeln!(file, "Button,Enabled,Melody,Volume,Repeats,Alarm,Zones")?;
+    
+    // Write data rows
+    for button in &config.buttons {
+        let zones_str = if button.zones.contains(&0) {
+            "All".to_string()
+        } else if button.zones.is_empty() {
+            "None".to_string()
+        } else {
+            button.zones.iter().map(|z| z.to_string()).collect::<Vec<_>>().join(";")
+        };
+        
+        let repeats_str = if button.repeat_count == 0 {
+            "Infinite".to_string()
+        } else {
+            button.repeat_count.to_string()
+        };
+        
+        writeln!(file, "{},{},{},{},{},{},\"{}\"",
+                button.button_number,
+                if button.enabled { "Yes" } else { "No" },
+                button.melody_number,
+                button.volume,
+                repeats_str,
+                if button.alarm_mode { "Yes" } else { "No" },
+                zones_str)?;
+    }
+    
+    println!("Configuration saved to: {}", output_path);
+    Ok(())
+}
+
+fn output_as_json(config: &DeviceConfiguration, output_path: &str) -> Result<()> {
+    let json = serde_json::to_string_pretty(config)?;
+    std::fs::write(output_path, json)?;
+    println!("Configuration saved to: {}", output_path);
+    Ok(())
+}
+
+fn main() -> Result<()> {
+    // Show help if no arguments provided
+    if env::args().len() == 1 {
+        eprintln!("sigma-configurator - Configure Bodet Harmony devices
+
+Usage: sigma-configurator [OPTIONS] --type <TYPE> --ip <IP>
+
+Options:
+  -t, --type <TYPE>                    Device type to configure [possible values: button4]
+  -i, --ip <IP>                        Device IP address
+  -p, --port <PORT>                    TCP port [default: 5666]
+  -m, --mode <MODE>                    Operation mode [default: show] [possible values: show, configure]
+      --output-mode <OUTPUT_MODE>      Output format (table, csv, json)
+  -o, --output <OUTPUT>                Output file path
+  -h, --help                           Print help
+
+Examples:
+  sigma-configurator -t button4 -i 192.168.1.100
+      # Show configuration in terminal table
+  sigma-configurator -t button4 -i 192.168.1.100 --output-mode csv -o config.csv
+      # Export configuration to CSV file
+  sigma-configurator -t button4 -i 192.168.1.100 -o config.json
+      # Export configuration to JSON file (auto-detects format)
+
+Notes:
+  - Currently only supports Button4 devices on TCP port 5666
+  - Configure mode not yet implemented (show mode only)
+  - If output file is specified without output-mode, defaults to CSV
+  - Zone 0 in output represents 'All Zones'");
+        std::process::exit(1);
+    }
+
+    let args = Args::parse();
+    
+    // Determine output mode
+    let output_mode = if let Some(mode) = args.output_mode {
+        mode
+    } else if let Some(ref output_path) = args.output {
+        // Auto-detect from file extension
+        if output_path.ends_with(".json") {
+            OutputMode::Json
+        } else {
+            OutputMode::Csv // Default for file output
+        }
+    } else {
+        OutputMode::Table // Default for terminal output
+    };
+    
+    match args.device_type {
+        DeviceType::Button4 => {
+            println!("Configuring Button4 device at {}:{}", args.ip, args.port);
+            
+            match args.mode {
+                OperationMode::Show => {
+                    // Connect and get configuration
+                    let mut stream = connect_to_device(&args.ip, args.port)?;
+                    let config_data = send_get_command(&mut stream)?;
+                    
+                    // Parse configuration
+                    let mut config = parse_button4_config(&config_data)?;
+                    config.device_ip = args.ip.clone();
+                    
+                    // Output configuration
+                    match output_mode {
+                        OutputMode::Table => {
+                            output_as_table(&config);
+                        }
+                        OutputMode::Csv => {
+                            let output_path = args.output.unwrap_or_else(|| "config.csv".to_string());
+                            output_as_csv(&config, &output_path)?;
+                        }
+                        OutputMode::Json => {
+                            let output_path = args.output.unwrap_or_else(|| "config.json".to_string());
+                            output_as_json(&config, &output_path)?;
+                        }
+                    }
+                }
+                OperationMode::Configure => {
+                    println!("Configure mode not yet implemented!");
+                    std::process::exit(1);
+                }
+            }
+        }
+    }
+    
+    Ok(())
+}