use dotenv::dotenv;
use std::env;
use rosc::{encoder, OscMessage, OscPacket, OscType};
use std::{net::SocketAddrV4, str::FromStr};
use tokio::net::UdpSocket;


#[tauri::command]
fn get_env(name: &str) -> String {
    println!("Getting environment variable: {}", name);
    
    match env::var(name) {
        Ok(value) => {
            // println!("Found environment variable {}: {}", name, value);
            value
        },
        Err(e) => {
            println!("Error getting environment variable {}: {}", name, e);
            String::new()
        }
    }
}

#[tauri::command]
async fn send_osc_message(
    key: &str, 
    message: &str,
    host: &str,
    target: &str
) -> Result<(), String> {
    
    // print
    println!("Sending OSC message: {}", message);

    let sock = UdpSocket::bind(host).await.unwrap();
    let remote = SocketAddrV4::from_str(target).unwrap();

    let msg_buf = encoder::encode(&OscPacket::Message(OscMessage {
        addr: key.to_string(),
        args: vec![OscType::String(message.parse().unwrap())],
    }))
    .unwrap();

    sock.send_to(&msg_buf, remote).await.unwrap();

    Ok(())
}


#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {

    dotenv().ok();

    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![get_env, send_osc_message])                        
        .plugin(tauri_plugin_http::init())
        .setup(|app| {
            if cfg!(debug_assertions) {
                app.handle().plugin(
                    tauri_plugin_log::Builder::default()
                        .level(log::LevelFilter::Info)
                        .build(),
                )?;
            }
            Ok(())
        })
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}