use serde::Serialize;
use serde_json::Value;
use tauri::{AppHandle, State};

use crate::{application::AppState, domain::ssh::OperationResponse};

#[derive(Serialize)]
pub struct SessionsResponse {
    success: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    sessions: Option<Vec<Value>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    error: Option<String>,
}

#[derive(Serialize)]
pub struct SessionResponse {
    success: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    session: Option<Value>,
    #[serde(skip_serializing_if = "Option::is_none")]
    error: Option<String>,
}

#[derive(Serialize)]
pub struct SettingResponse {
    success: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    value: Option<Value>,
    #[serde(skip_serializing_if = "Option::is_none")]
    error: Option<String>,
}

#[tauri::command]
pub fn session_get_all(app: AppHandle, state: State<'_, AppState>) -> SessionsResponse {
    match state.storage.sessions(&app) {
        Ok(sessions) => SessionsResponse {
            success: true,
            sessions: Some(sessions),
            error: None,
        },
        Err(error) => SessionsResponse {
            success: false,
            sessions: None,
            error: Some(error),
        },
    }
}

#[tauri::command]
pub fn session_get_by_id(
    app: AppHandle,
    state: State<'_, AppState>,
    id: String,
) -> SessionResponse {
    match state.storage.session(&app, &id) {
        Ok(session) => SessionResponse {
            success: session.is_some(),
            session,
            error: None,
        },
        Err(error) => SessionResponse {
            success: false,
            session: None,
            error: Some(error),
        },
    }
}

#[tauri::command]
pub fn session_create(
    app: AppHandle,
    state: State<'_, AppState>,
    session: Value,
) -> SessionResponse {
    match state.storage.create_session(&app, session) {
        Ok(session) => SessionResponse {
            success: true,
            session: Some(session),
            error: None,
        },
        Err(error) => SessionResponse {
            success: false,
            session: None,
            error: Some(error),
        },
    }
}

#[tauri::command]
pub fn session_update(
    app: AppHandle,
    state: State<'_, AppState>,
    id: String,
    updates: Value,
) -> SessionResponse {
    match state.storage.update_session(&app, &id, updates) {
        Ok(session) => SessionResponse {
            success: true,
            session: Some(session),
            error: None,
        },
        Err(error) => SessionResponse {
            success: false,
            session: None,
            error: Some(error),
        },
    }
}

#[tauri::command]
pub fn session_delete(app: AppHandle, state: State<'_, AppState>, id: String) -> OperationResponse {
    match state.storage.delete_session(&app, &id) {
        Ok(()) => OperationResponse::ok(),
        Err(error) => OperationResponse::error(error),
    }
}

#[tauri::command]
pub fn settings_get(app: AppHandle, state: State<'_, AppState>, key: String) -> SettingResponse {
    match state.storage.get_setting(&app, &key) {
        Ok(value) => SettingResponse {
            success: true,
            value,
            error: None,
        },
        Err(error) => SettingResponse {
            success: false,
            value: None,
            error: Some(error),
        },
    }
}

#[tauri::command]
pub fn settings_set(
    app: AppHandle,
    state: State<'_, AppState>,
    key: String,
    value: Value,
) -> OperationResponse {
    match state.storage.set_setting(&app, key, value) {
        Ok(()) => OperationResponse::ok(),
        Err(error) => OperationResponse::error(error),
    }
}