mod agent;
#[cfg(target_os = "windows")]
mod rustdesk;

use agent::{collect_inventory_plain, collect_profile, AgentRuntime, MachineProfile};
use tauri::Emitter;
use tauri_plugin_store::Builder as StorePluginBuilder;

#[derive(Debug, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RustdeskProvisioningResult {
    pub id: String,
    pub password: String,
    pub installed_version: Option<String>,
    pub updated: bool,
    pub last_provisioned_at: i64,
}

#[tauri::command]
fn collect_machine_profile() -> Result<MachineProfile, String> {
    collect_profile().map_err(|error| error.to_string())
}

#[tauri::command]
fn collect_machine_inventory() -> Result<serde_json::Value, String> {
    Ok(collect_inventory_plain())
}

#[tauri::command]
fn start_machine_agent(
    state: tauri::State<AgentRuntime>,
    base_url: String,
    token: String,
    status: Option<String>,
    interval_seconds: Option<u64>,
) -> Result<(), String> {
    state
        .start_heartbeat(base_url, token, status, interval_seconds)
        .map_err(|error| error.to_string())
}

#[tauri::command]
fn stop_machine_agent(state: tauri::State<AgentRuntime>) -> Result<(), String> {
    state.stop();
    Ok(())
}

#[tauri::command]
fn open_devtools(window: tauri::WebviewWindow) -> Result<(), String> {
    window.open_devtools();
    Ok(())
}

#[tauri::command]
async fn ensure_rustdesk_and_emit(
    app: tauri::AppHandle,
    config_string: Option<String>,
    password: Option<String>,
    machine_id: Option<String>,
) -> Result<RustdeskProvisioningResult, String> {
    let result = tauri::async_runtime::spawn_blocking(move || {
        run_rustdesk_ensure(config_string, password, machine_id)
    })
    .await
    .map_err(|error| error.to_string())??;

    if let Err(error) = app.emit("raven://remote-access/provisioned", &result) {
        eprintln!("[rustdesk] falha ao emitir evento raven://remote-access/provisioned: {error}");
    }

    Ok(result)
}

#[cfg(target_os = "windows")]
fn run_rustdesk_ensure(
    config_string: Option<String>,
    password: Option<String>,
    machine_id: Option<String>,
) -> Result<RustdeskProvisioningResult, String> {
    rustdesk::ensure_rustdesk(
        config_string.as_deref(),
        password.as_deref(),
        machine_id.as_deref(),
    )
    .map_err(|error| error.to_string())
}

#[cfg(not(target_os = "windows"))]
fn run_rustdesk_ensure(
    _config_string: Option<String>,
    _password: Option<String>,
    _machine_id: Option<String>,
) -> Result<RustdeskProvisioningResult, String> {
    Err("Provisionamento automático do RustDesk está disponível apenas no Windows.".to_string())
}

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .manage(AgentRuntime::new())
        .plugin(tauri_plugin_opener::init())
        .plugin(StorePluginBuilder::default().build())
        .plugin(tauri_plugin_updater::Builder::new().build())
        .plugin(tauri_plugin_process::init())
        .invoke_handler(tauri::generate_handler![
            collect_machine_profile,
            collect_machine_inventory,
            start_machine_agent,
            stop_machine_agent,
            open_devtools,
            ensure_rustdesk_and_emit
        ])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}