use serde::{Serialize, Deserialize};
use tauri::State;

use crate::state::{AppState, Session, Credentials};


#[derive(Clone, Serialize, Deserialize)]
pub struct Client {
    pub pid: u32,
    pub exe: String,
}


#[derive(Clone, Serialize, Deserialize)]
pub struct Request {
    pub id: u64,
    pub clients: Vec<Client>,
}


#[derive(Serialize, Deserialize)]
pub struct RequestResponse {
    pub id: u64,
    pub approval: Approval,
}


#[derive(Serialize, Deserialize)]
pub enum Approval {
    Approved,
    Denied,
}


#[tauri::command]
pub fn respond(response: RequestResponse, app_state: State<'_, AppState>) -> Result<(), String> {
    app_state.send_response(response)
        .map_err(|e| format!("Error responding to request: {e}"))
}


#[tauri::command]
pub async fn unlock(passphrase: String, app_state: State<'_, AppState>) -> Result<(), String> {
    app_state.decrypt(&passphrase)
        .await
        .map_err(|e| e.to_string())
}


#[tauri::command]
pub fn get_session_status(app_state: State<'_, AppState>) -> String {
    let session = app_state.session.read().unwrap();
    match *session {
        Session::Locked(_) => "locked".into(),
        Session::Unlocked(_) => "unlocked".into(),
        Session::Empty => "empty".into()
    }
}


#[tauri::command]
pub async fn save_credentials(
    credentials: Credentials,
    passphrase: String,
    app_state: State<'_, AppState>
) -> Result<(), String> {
    app_state.save_creds(credentials, &passphrase)
        .await
        .map_err(|e| e.to_string())
}