// file: crates/ksp-app-config-desk/src/tauri.rs
// version: 15

//! Tauri runtime assembly for the KSP configuration desktop application.

/// Runs the configuration desktop application.
#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run(arguments: &[std::ffi::OsString]) -> ksp_core_lib::Result<()> {
    let app_state = crate::AppState::initialize(arguments);
    let app_state = match app_state {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let mut builder = tauri::Builder::default();
    builder = configure_state(builder, app_state);
    builder = configure_plugins(builder);
    builder = configure_commands(builder);
    builder = configure_setup(builder);
    let run_result = builder.run(tauri::generate_context!());
    return match run_result {
        std::result::Result::Ok(()) => std::result::Result::Ok(()),
        std::result::Result::Err(error) => std::result::Result::Err(
            ksp_core_lib::Error::new(crate::ERROR_CODE_TAURI_RUNTIME_FAILED, "Cannot run KSP Config Desk Tauri runtime")
                .with_context("tauri_error", error.to_string()),
        ),
    };
}

fn configure_state(builder: tauri::Builder<tauri::Wry>, app_state: crate::AppState) -> tauri::Builder<tauri::Wry> {
    return builder.manage(app_state);
}

fn configure_plugins(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<tauri::Wry> {
    let tracing_plugin = tauri_plugin_tracing::Builder::new().build::<tauri::Wry>();
    return builder.plugin(tracing_plugin);
}

#[allow(clippy::question_mark_used)] // Tauri generates the question-mark operator internally for async command dispatch.
fn configure_commands(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<tauri::Wry> {
    return builder.invoke_handler(tauri::generate_handler![
        get_app_snapshot,
        get_config_documents,
        get_config_document_detail,
        save_config_document_source,
        get_config_profile_documents,
        get_config_profile_detail,
        get_environment_report,
        set_environment_value,
        remove_environment_value,
        reveal_environment_value,
        get_logging_document,
        get_logging_runtime_status,
        apply_logging_profile,
        save_logging_document,
        emit_logging_test,
        emit_frontend_log,
        splash_frontend_ready
    ]);
}

fn configure_setup(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<tauri::Wry> {
    return builder.setup(|app| {
        let splash = crate::tw_splash::require_window(app);
        if let std::result::Result::Err(error) = splash {
            return std::result::Result::Err(std::boxed::Box::new(error));
        }
        let main = crate::tw_main::require_window(app);
        if let std::result::Result::Err(error) = main {
            return std::result::Result::Err(std::boxed::Box::new(error));
        }
        return std::result::Result::Ok(());
    });
}

#[tauri::command]
fn get_app_snapshot(state: tauri::State<'_, crate::AppState>) -> std::result::Result<crate::AppSnapshotDto, crate::CommandErrorDto> {
    let snapshot = state.snapshot();
    return match snapshot {
        std::result::Result::Ok(value) => std::result::Result::Ok(value),
        std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)),
    };
}

#[tauri::command]
fn get_config_documents(state: tauri::State<'_, crate::AppState>) -> std::vec::Vec<crate::ConfigDocumentSummaryDto> {
    return crate::documents::inventory(&state);
}

#[tauri::command]
fn get_config_document_detail(
    file_id: String,
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::ConfigDocumentDetailDto, crate::ConfigDocumentErrorDto> {
    return crate::documents::detail(&state, file_id.as_str());
}

#[tauri::command]
fn save_config_document_source(
    file_id: String,
    source: String,
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::ConfigDocumentSaveResultDto, crate::ConfigDocumentErrorDto> {
    return crate::documents::save_source(&state, file_id.as_str(), source.as_str());
}

#[tauri::command]
fn get_config_profile_documents(
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<std::vec::Vec<crate::ConfigProfileDocumentDto>, crate::CommandErrorDto> {
    let result = crate::profiles::inventory(&state);
    return match result {
        std::result::Result::Ok(value) => std::result::Result::Ok(value),
        std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)),
    };
}

#[tauri::command]
fn get_config_profile_detail(
    file_id: String,
    profile_id: std::option::Option<String>,
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::ConfigProfileDetailDto, crate::CommandErrorDto> {
    let result = crate::profiles::detail(&state, file_id.as_str(), profile_id.as_deref());
    return match result {
        std::result::Result::Ok(value) => std::result::Result::Ok(value),
        std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)),
    };
}

#[tauri::command]
fn get_environment_report(
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<std::vec::Vec<crate::ConfigEnvironmentReportDto>, crate::CommandErrorDto> {
    let result = crate::environment::report(&state);
    return match result {
        std::result::Result::Ok(value) => std::result::Result::Ok(value),
        std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)),
    };
}

#[tauri::command]
fn set_environment_value(
    variable_name: String,
    value: String,
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::ConfigEnvironmentChangeDto, crate::CommandErrorDto> {
    let result = crate::environment::set_value(&state, variable_name.as_str(), value.as_str());
    return match result {
        std::result::Result::Ok(value) => std::result::Result::Ok(value),
        std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)),
    };
}

#[tauri::command]
fn remove_environment_value(
    variable_name: String,
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::ConfigEnvironmentChangeDto, crate::CommandErrorDto> {
    let result = crate::environment::remove_value(&state, variable_name.as_str());
    return match result {
        std::result::Result::Ok(value) => std::result::Result::Ok(value),
        std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)),
    };
}

#[tauri::command]
fn reveal_environment_value(
    request: crate::SecretRevealRequestDto,
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::SecretRevealResponseDto, crate::CommandErrorDto> {
    let result = crate::secrets::reveal(&state, request);
    return match result {
        std::result::Result::Ok(value) => std::result::Result::Ok(value),
        std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)),
    };
}

#[tauri::command]
fn get_logging_document(state: tauri::State<'_, crate::AppState>) -> std::result::Result<crate::LoggingDocumentDto, crate::CommandErrorDto> {
    let result = crate::logging_editor::document(&state);
    return match result {
        std::result::Result::Ok(value) => std::result::Result::Ok(value),
        std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)),
    };
}

#[tauri::command]
fn get_logging_runtime_status(state: tauri::State<'_, crate::AppState>) -> std::result::Result<crate::LoggingRuntimeStatusDto, crate::CommandErrorDto> {
    let result = crate::logging_runtime::status(&state);
    return match result {
        std::result::Result::Ok(value) => std::result::Result::Ok(value),
        std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)),
    };
}

#[tauri::command]
fn apply_logging_profile(
    profile_id: String,
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::LoggingRuntimeStatusDto, crate::CommandErrorDto> {
    let result = crate::logging_runtime::apply_profile(&state, profile_id.as_str());
    return match result {
        std::result::Result::Ok(value) => std::result::Result::Ok(value),
        std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)),
    };
}

#[tauri::command]
fn save_logging_document(
    candidate: crate::LoggingDocumentCandidateDto,
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::LoggingDocumentSaveResultDto, crate::CommandErrorDto> {
    let result = crate::logging_editor::save(&state, candidate);
    return match result {
        std::result::Result::Ok(value) => std::result::Result::Ok(value),
        std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)),
    };
}

#[tauri::command]
fn emit_logging_test(
    request: crate::LoggingTestRequestDto,
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::LoggingTestResultDto, crate::CommandErrorDto> {
    let result = crate::logging_test::emit(&state, request);
    return match result {
        std::result::Result::Ok(value) => std::result::Result::Ok(value),
        std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)),
    };
}

#[tauri::command]
fn emit_frontend_log(payload: crate::FrontendLogPayloadDto) -> std::result::Result<(), crate::CommandErrorDto> {
    let result = crate::emit_frontend_log_event(payload);
    return match result {
        std::result::Result::Ok(()) => std::result::Result::Ok(()),
        std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)),
    };
}

#[tauri::command]
async fn splash_frontend_ready(
    app: tauri::AppHandle,
    webview_window: tauri::WebviewWindow,
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<(), crate::CommandErrorDto> {
    let result = crate::splash_frontend_ready_service(app, webview_window, &state).await;
    return match result {
        std::result::Result::Ok(()) => std::result::Result::Ok(()),
        std::result::Result::Err(error) => std::result::Result::Err(crate::CommandErrorDto::from_error(&error)),
    };
}