// file: kb-app-demo-desktop/src/tauri.rs
// version: 8

//! Tauri runtime assembly and private command wrappers.

use tauri::Manager; // rust-rules: trait-import

/// Runs the desktop demo application.
#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() -> kb_core::Result<()> {
    let rustls_result = install_default_rustls_provider();
    if let std::result::Result::Err(error) = rustls_result {
        return std::result::Result::Err(error);
    }
    let app_state_result = crate::AppState::initialize();
    let app_state;
    if let std::result::Result::Ok(state) = app_state_result {
        app_state = state;
    } else if let std::result::Result::Err(error) = app_state_result {
        return std::result::Result::Err(error);
    } else {
        return std::result::Result::Err(kb_core::Error::invalid_state(
            "application state initialization produced no result",
        ));
    }
    tracing::info!(
        target: crate::TRACING_TARGET,
        config_path = app_state.config_path(),
        active_profile = app_state.active_profile().name.as_str(),
        logging_routes = app_state.logging_route_count(),
        configured_profiles = app_state.app_config().profiles.len(),
        "starting desktop demo application"
    );
    let tracing_builder = tauri_plugin_tracing::Builder::new();
    let mut builder = tauri::Builder::default();
    builder = builder.manage(app_state);
    builder = builder.invoke_handler(tauri::generate_handler![
        emit_frontend_log,
        load_project_readme,
        open_demo_backfill_window,
        demo_backfill_options,
        demo_backfill_execute,
        demo_backfill_cancel,
        open_demo_http_window,
        demo_http_list_pool_clients,
        demo_http_options,
        demo_http_execute_request,
        open_demo_ws_window,
        demo_ws_list_pool_clients,
        demo_ws_options,
        demo_ws_status,
        demo_ws_connect,
        demo_ws_unsubscribe,
        demo_ws_disconnect,
        open_demo_sql_diag_window,
        load_demo_sql_diag,
        open_demo_sql_pg_raw_window,
        load_demo_sql_pg_raw,
        open_demo_sql_pg_core_window,
        load_demo_sql_pg_core,
        open_demo_sql_replay_candidates_window,
        demo_sql_replay_options,
        load_demo_sql_replay_transactions,
        load_demo_sql_replay_programs,
        load_demo_sql_replay_entities,
        export_demo_sql_replay_csv,
        open_demo_config_window,
        load_demo_config,
    ]);
    builder = builder.plugin(tracing_builder.build::<tauri::Wry>());
    builder = builder.setup(|app| {
        let splash_window = match app.get_webview_window("splash") {
            std::option::Option::Some(window) => window,
            std::option::Option::None => {
                return std::result::Result::Err(std::boxed::Box::new(std::io::Error::new(
                    std::io::ErrorKind::NotFound,
                    "splash window is missing",
                )));
            },
        };
        let main_window = match app.get_webview_window("main") {
            std::option::Option::Some(window) => window,
            std::option::Option::None => {
                return std::result::Result::Err(std::boxed::Box::new(std::io::Error::new(
                    std::io::ErrorKind::NotFound,
                    "main window is missing",
                )));
            },
        };
        tauri::async_runtime::spawn(async move {
            let started_at = tokio::time::Instant::now();
            crate::emit_splash_order(
                &splash_window,
                "add_log",
                std::option::Option::Some("Configuration chargée"),
                std::option::Option::None,
                std::option::Option::None,
            );
            crate::emit_splash_order(
                &splash_window,
                "add_log",
                std::option::Option::Some("Sous-système de logs initialisé"),
                std::option::Option::None,
                std::option::Option::None,
            );
            crate::emit_splash_order(
                &splash_window,
                "add_log",
                std::option::Option::Some("Pool HTTP initialisé"),
                std::option::Option::None,
                std::option::Option::None,
            );
            crate::emit_splash_order(
                &splash_window,
                "fadein",
                std::option::Option::None,
                std::option::Option::None,
                std::option::Option::Some(crate::SPLASH_FADE_MS),
            );
            crate::emit_splash_order(
                &splash_window,
                "add_msg",
                std::option::Option::Some("Initialisation..."),
                std::option::Option::Some("info"),
                std::option::Option::None,
            );
            crate::emit_splash_order(
                &splash_window,
                "add_msg",
                std::option::Option::Some("Loading complete..."),
                std::option::Option::Some("success"),
                std::option::Option::None,
            );
            crate::wait_until_minimum(started_at, crate::SPLASH_MINIMUM_MS).await;
            if cfg!(debug_assertions) {
                crate::emit_splash_order(
                    &splash_window,
                    "add_log",
                    std::option::Option::Some("Start Fade-out"),
                    std::option::Option::None,
                    std::option::Option::None,
                );
            }
            crate::emit_splash_order(
                &splash_window,
                "fadeout",
                std::option::Option::None,
                std::option::Option::None,
                std::option::Option::Some(crate::SPLASH_FADE_MS),
            );
            tokio::time::sleep(std::time::Duration::from_millis(crate::SPLASH_CLOSE_WAIT_MS)).await;
            if let std::result::Result::Err(error) = splash_window.destroy() {
                tracing::error!(target: crate::TRACING_TARGET, "cannot destroy splash window: {error:?}");
            }
            if let std::result::Result::Err(error) = main_window.show() {
                tracing::error!(target: crate::TRACING_TARGET, "cannot show main window: {error:?}");
            }
            if let std::result::Result::Err(error) = main_window.set_focus() {
                tracing::error!(target: crate::TRACING_TARGET, "cannot focus main window: {error:?}");
            }
        });
        return std::result::Result::Ok(());
    });
    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(kb_core::Error::tauri(format!(
            "cannot run desktop demo application: {error:?}"
        ))),
    };
}

fn install_default_rustls_provider() -> kb_core::Result<()> {
    if rustls::crypto::CryptoProvider::get_default().is_some() {
        return std::result::Result::Ok(());
    }
    let provider_result = rustls::crypto::aws_lc_rs::default_provider().install_default();
    return match provider_result {
        std::result::Result::Ok(()) => std::result::Result::Ok(()),
        std::result::Result::Err(error) => std::result::Result::Err(kb_core::Error::invalid_state(
            format!("cannot install default rustls crypto provider: {error:?}"),
        )),
    };
}

#[tauri::command]
fn open_demo_config_window(
    app_handle: tauri::AppHandle,
) -> std::result::Result<(), std::string::String> {
    if let std::option::Option::Some(window) = app_handle.get_webview_window("demo_config") {
        if let std::result::Result::Err(error) = window.show() {
            return std::result::Result::Err(error.to_string());
        }
        if let std::result::Result::Err(error) = window.set_focus() {
            return std::result::Result::Err(error.to_string());
        }
        return std::result::Result::Ok(());
    }
    let builder = tauri::WebviewWindowBuilder::new(
        &app_handle,
        "demo_config",
        tauri::WebviewUrl::App("demo_config.html".into()),
    )
    .title("Khadhroony Bot3 - Configuration")
    .inner_size(1280.0, 820.0)
    .min_inner_size(960.0, 640.0);
    let window = match builder.build() {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => {
            return std::result::Result::Err(error.to_string());
        },
    };
    if let std::result::Result::Err(error) = window.set_focus() {
        return std::result::Result::Err(error.to_string());
    }
    return std::result::Result::Ok(());
}

#[tauri::command]
fn load_demo_config(
    state: tauri::State<'_, crate::AppState>,
) -> crate::DemoConfigPayload {
    return crate::demo_config_payload(state.inner());
}

fn into_ipc_result<T>(
    result: kb_core::Result<T>,
) -> std::result::Result<T, std::string::String> {
    return match result {
        std::result::Result::Ok(value) => std::result::Result::Ok(value),
        std::result::Result::Err(error) => std::result::Result::Err(error.to_string()),
    };
}

#[tauri::command]
fn emit_frontend_log(payload: crate::FrontendLogPayload) {
    crate::emit_frontend_log(payload);
}

#[tauri::command]
fn load_project_readme() -> std::result::Result<std::string::String, std::string::String> {
    return into_ipc_result(crate::load_project_readme());
}

#[tauri::command]
fn demo_backfill_cancel(state: tauri::State<'_, crate::AppState>) -> bool {
    let running = state
        .demo_backfill_running()
        .load(std::sync::atomic::Ordering::Acquire);
    state
        .demo_backfill_cancel_requested()
        .store(true, std::sync::atomic::Ordering::Release);
    return running;
}

#[tauri::command]
fn open_demo_backfill_window(
    app_handle: tauri::AppHandle,
) -> std::result::Result<(), std::string::String> {
    let existing_window = app_handle.get_webview_window("demo_backfill");
    if let std::option::Option::Some(window) = existing_window {
        if let std::result::Result::Err(error) = window.show() {
            return std::result::Result::Err(error.to_string());
        }
        if let std::result::Result::Err(error) = window.set_focus() {
            return std::result::Result::Err(error.to_string());
        }
        return std::result::Result::Ok(());
    }
    let build_result = tauri::WebviewWindowBuilder::new(
        &app_handle,
        "demo_backfill",
        tauri::WebviewUrl::App("demo_backfill.html".into()),
    )
    .title("Khadhroony Bot3 - Backfill HTTP")
    .inner_size(1280.0, 860.0)
    .min_inner_size(960.0, 620.0)
    .resizable(true)
    .visible(true)
    .build();
    return match build_result {
        std::result::Result::Ok(window) => match window.set_focus() {
            std::result::Result::Ok(()) => std::result::Result::Ok(()),
            std::result::Result::Err(error) => std::result::Result::Err(error.to_string()),
        },
        std::result::Result::Err(error) => std::result::Result::Err(error.to_string()),
    };
}

#[tauri::command]
fn demo_backfill_options(
    state: tauri::State<'_, crate::AppState>,
) -> crate::DemoBackfillOptionsPayload {
    let roles = crate::build_role_options(state.http_pool().snapshot());
    let default_role = if roles.iter().any(|item| return item.role == "history_backfill") {
        std::option::Option::Some("history_backfill".to_string())
    } else {
        roles.first().map(|item| return item.role.clone())
    };
    return crate::DemoBackfillOptionsPayload {
        roles,
        default_role,
        default_commitment: "confirmed".to_string(),
        default_page_size: 100,
        default_max_pages: 20,
        default_max_concurrent_requests: 4,
        default_max_retries: 2,
        running: state
            .demo_backfill_running()
            .load(std::sync::atomic::Ordering::Acquire),
    };
}

#[tauri::command]
#[allow(clippy::question_mark_used)]
async fn demo_backfill_execute(
    app_handle: tauri::AppHandle,
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoBackfillRequest,
) -> std::result::Result<crate::DemoBackfillSummaryPayload, std::string::String> {
    let acquire_result = state.demo_backfill_running().compare_exchange(
        false,
        true,
        std::sync::atomic::Ordering::AcqRel,
        std::sync::atomic::Ordering::Acquire,
    );
    if acquire_result.is_err() {
        return std::result::Result::Err("a backfill campaign is already running".to_string());
    }
    let _run_guard = crate::DemoBackfillRunGuard {
        running: state.demo_backfill_running(),
    };
    state
        .demo_backfill_cancel_requested()
        .store(false, std::sync::atomic::Ordering::Release);
    let pipeline_request = match crate::build_demo_backfill_pipeline_request(request) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let profile = state.active_profile();
    let store_options = match kb_store::PostgresStoreOptions::new(
        profile.database.postgres.url.clone(),
        profile.database.postgres.max_connections,
        profile.database.postgres.connect_timeout_ms,
        false,
    ) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
    };
    let store = match kb_store::PostgresStore::connect(store_options).await {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
    };
    if let std::result::Result::Err(error) = store.initialize_store_schema().await {
        return std::result::Result::Err(error.to_string());
    }
    let observer = crate::DemoBackfillObserver {
        app_handle,
        cancel_requested: state.demo_backfill_cancel_requested(),
    };
    let summary = match kb_pipeline::execute_http_backfill(
        state.http_pool(),
        &store,
        &pipeline_request,
        &observer,
    )
    .await
    {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
    };
    return std::result::Result::Ok(crate::demo_backfill_summary_payload(summary));
}

#[tauri::command]
fn open_demo_http_window(
    app_handle: tauri::AppHandle,
) -> std::result::Result<(), std::string::String> {
    let existing_window = app_handle.get_webview_window("demo_http");
    if let std::option::Option::Some(window) = existing_window {
        if let std::result::Result::Err(error) = window.show() {
            return std::result::Result::Err(error.to_string());
        }
        if let std::result::Result::Err(error) = window.set_focus() {
            return std::result::Result::Err(error.to_string());
        }
        return std::result::Result::Ok(());
    }
    let build_result = tauri::WebviewWindowBuilder::new(
        &app_handle,
        "demo_http",
        tauri::WebviewUrl::App("demo_http.html".into()),
    )
    .title("Khadhroony Bot3 - HTTP JSON-RPC")
    .inner_size(1280.0, 860.0)
    .min_inner_size(960.0, 620.0)
    .resizable(true)
    .visible(true)
    .build();
    return match build_result {
        std::result::Result::Ok(window) => match window.set_focus() {
            std::result::Result::Ok(()) => std::result::Result::Ok(()),
            std::result::Result::Err(error) => std::result::Result::Err(error.to_string()),
        },
        std::result::Result::Err(error) => std::result::Result::Err(error.to_string()),
    };
}

#[tauri::command]
fn demo_http_list_pool_clients(
    state: tauri::State<'_, crate::AppState>,
) -> std::vec::Vec<kb_onchain_transport::HttpPoolClientSnapshot> {
    return state.http_pool().snapshot();
}

#[tauri::command]
fn demo_http_options(
    state: tauri::State<'_, crate::AppState>,
) -> crate::DemoHttpOptionsPayload {
    return crate::DemoHttpOptionsPayload {
        roles: crate::build_http_role_options(state.http_pool().snapshot()),
        methods: crate::build_http_method_options(),
    };
}

#[tauri::command]
#[allow(clippy::question_mark_used)]
async fn demo_http_execute_request(
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoHttpRequest,
) -> std::result::Result<crate::DemoHttpExecutionPayload, std::string::String> {
    return crate::demo_http_execute_request_inner(state, request).await;
}

/// Opens or focuses the WebSocket demo window.
#[tauri::command]
fn open_demo_ws_window(
    app_handle: tauri::AppHandle,
) -> std::result::Result<(), std::string::String> {
    tracing::info!(target: crate::TRACING_TARGET, "open_demo_ws_window");
    if let std::option::Option::Some(window) = app_handle.get_webview_window("demo_ws") {
        if let std::result::Result::Err(error) = window.show() {
            return std::result::Result::Err(
                kb_core::Error::tauri(format!("cannot show demo_ws window: {error}")).to_string(),
            );
        }
        if let std::result::Result::Err(error) = window.set_focus() {
            return std::result::Result::Err(
                kb_core::Error::tauri(format!("cannot focus demo_ws window: {error}")).to_string(),
            );
        }
        return std::result::Result::Ok(());
    }
    let build_result = tauri::WebviewWindowBuilder::new(
        &app_handle,
        "demo_ws",
        tauri::WebviewUrl::App("demo_ws.html".into()),
    )
    .title("Khadhroony Bot3 - WebSocket standard")
    .inner_size(1200.0, 760.0)
    .min_inner_size(920.0, 560.0)
    .resizable(true)
    .visible(true)
    .build();
    return match build_result {
        std::result::Result::Ok(window) => match window.set_focus() {
            std::result::Result::Ok(()) => std::result::Result::Ok(()),
            std::result::Result::Err(error) => std::result::Result::Err(
                kb_core::Error::tauri(format!("cannot focus created demo_ws window: {error}"))
                    .to_string(),
            ),
        },
        std::result::Result::Err(error) => std::result::Result::Err(
            kb_core::Error::tauri(format!("cannot create demo_ws window: {error}")).to_string(),
        ),
    };
}

/// Lists WebSocket endpoints available through the configured pool.
#[tauri::command]
fn demo_ws_list_pool_clients(
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<std::vec::Vec<kb_onchain_transport::WsPoolClientSnapshot>, std::string::String> {
    let pool = match state.demo_ws_pool() {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
    };
    return std::result::Result::Ok(pool.snapshot());
}

/// Lists selectable WebSocket roles and methods for the demo UI.
#[tauri::command]
fn demo_ws_options(
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::DemoWsOptionsPayload, std::string::String> {
    return std::result::Result::Ok(crate::DemoWsOptionsPayload {
        roles: crate::build_ws_role_options(match state.demo_ws_pool() {
            std::result::Result::Ok(pool) => pool.snapshot(),
            std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
        }),
        methods: crate::build_ws_method_options(),
    });
}

/// Returns the current WebSocket demo session status.
#[tauri::command]
#[allow(clippy::question_mark_used)]
async fn demo_ws_status(
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::DemoWsStatusPayload, std::string::String> {
    return crate::demo_ws_status_inner(state.inner()).await;
}

/// Connects if needed, then subscribes through `kb_onchain_transport::WsSession`.
#[tauri::command]
#[allow(clippy::question_mark_used)]
async fn demo_ws_connect(
    app_handle: tauri::AppHandle,
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoWsRequest,
) -> std::result::Result<crate::DemoWsExecutionPayload, std::string::String> {
    return crate::demo_ws_connect_inner(app_handle, state.inner(), request).await;
}

/// Unsubscribes one subscription while keeping the WebSocket connection open.
#[tauri::command]
#[allow(clippy::question_mark_used)]
async fn demo_ws_unsubscribe(
    app_handle: tauri::AppHandle,
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoWsUnsubscribeRequest,
) -> std::result::Result<crate::DemoWsStatusPayload, std::string::String> {
    return crate::demo_ws_unsubscribe_inner(app_handle, state.inner(), request.subscription_id)
        .await;
}

/// Disconnects the current persistent WebSocket demo session.
#[tauri::command]
#[allow(clippy::question_mark_used)]
async fn demo_ws_disconnect(
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::DemoWsStatusPayload, std::string::String> {
    return crate::demo_ws_disconnect_inner(state.inner()).await;
}

/// Opens or focuses the SQL diagnostic demo window.
#[tauri::command]
fn open_demo_sql_diag_window(
    app_handle: tauri::AppHandle,
) -> std::result::Result<(), std::string::String> {
    return crate::open_sql_demo_window(
        app_handle,
        "demo_sql_diag",
        "demo_sql_diag.html",
        "Khadhroony Bot3 - SQL diagnostics",
    );
}

/// Loads read-only SQL diagnostics from the active profile.
#[tauri::command]
#[allow(clippy::question_mark_used)]
async fn load_demo_sql_diag(
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::DemoSqlDiagPayload, std::string::String> {
    let profile = state.active_profile().clone();
    let store_result = crate::connect_postgres_store(&profile).await;
    let store = match store_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let diagnostics_result = store.backend_diagnostics().await;
    let diagnostics = match diagnostics_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
    };
    let tables_result = store.known_table_diagnostics().await;
    let tables = match tables_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
    };
    return std::result::Result::Ok(crate::DemoSqlDiagPayload {
        config_path: state.config_path().to_string(),
        active_profile_name: profile.name.clone(),
        backend: profile.database.backend.clone(),
        masked_dsn: store.options().masked_dsn(),
        current_schema: diagnostics.descriptor.current_schema,
        health_status: crate::debug_status(diagnostics.health.status),
        health_message: diagnostics.health.message,
        migration_status: crate::debug_status(diagnostics.migrations.status),
        migration_message: diagnostics.migrations.message,
        server_version: diagnostics.server_version,
        tables: crate::table_snapshots_from_pg(tables.as_slice()),
    });
}

/// Opens or focuses the PostgreSQL canonical acquisition demo window.
#[tauri::command]
fn open_demo_sql_pg_raw_window(
    app_handle: tauri::AppHandle,
) -> std::result::Result<(), std::string::String> {
    return crate::open_sql_demo_window(
        app_handle,
        "demo_sql_pg_raw",
        "demo_sql_pg_raw.html",
        "Khadhroony Bot3 - PostgreSQL canonical acquisition",
    );
}

/// Loads read-only raw table diagnostics from PostgreSQL.
#[tauri::command]
#[allow(clippy::question_mark_used)]
async fn load_demo_sql_pg_raw(
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::DemoSqlPgRawPayload, std::string::String> {
    let profile = state.active_profile().clone();
    let store_result = crate::connect_postgres_store(&profile).await;
    let store = match store_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let tables_result = store.raw_table_diagnostics().await;
    let tables = match tables_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
    };
    return std::result::Result::Ok(crate::DemoSqlPgRawPayload {
        active_profile_name: profile.name.clone(),
        masked_dsn: store.options().masked_dsn(),
        tables: crate::table_snapshots_from_pg(tables.as_slice()),
    });
}

/// Opens or focuses the PostgreSQL core store demo window.
#[tauri::command]
fn open_demo_sql_pg_core_window(
    app_handle: tauri::AppHandle,
) -> std::result::Result<(), std::string::String> {
    return crate::open_sql_demo_window(
        app_handle,
        "demo_sql_pg_core",
        "demo_sql_pg_core.html",
        "Khadhroony Bot3 - PostgreSQL core store",
    );
}

/// Loads read-only core table diagnostics from PostgreSQL.
#[tauri::command]
#[allow(clippy::question_mark_used)]
async fn load_demo_sql_pg_core(
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::DemoSqlPgCorePayload, std::string::String> {
    let profile = state.active_profile().clone();
    let store_result = crate::connect_postgres_store(&profile).await;
    let store = match store_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let tables_result = store.core_table_diagnostics().await;
    let tables = match tables_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
    };
    return std::result::Result::Ok(crate::DemoSqlPgCorePayload {
        active_profile_name: profile.name.clone(),
        masked_dsn: store.options().masked_dsn(),
        tables: crate::table_snapshots_from_pg(tables.as_slice()),
    });
}

/// Opens or focuses the SQL replay candidate browser.
#[tauri::command]
fn open_demo_sql_replay_candidates_window(
    app_handle: tauri::AppHandle,
) -> std::result::Result<(), std::string::String> {
    return crate::open_sql_demo_window(
        app_handle,
        "demo_sql_replay_candidates",
        "demo_sql_replay_candidates.html",
        "Khadhroony Bot3 - SQL replay candidates",
    );
}

/// Writes a bounded replay-candidate CSV file into `./data/exports_csv/`.
#[tauri::command]
#[allow(clippy::question_mark_used)]
async fn export_demo_sql_replay_csv(
    file_name: std::string::String,
    content: std::string::String,
) -> std::result::Result<std::string::String, std::string::String> {
    if content.is_empty() {
        return std::result::Result::Err("CSV export content must not be empty".to_owned());
    }
    if content.len() > 16 * 1024 * 1024 {
        return std::result::Result::Err("CSV export content exceeds 16 MiB".to_owned());
    }
    let normalized_name_result = crate::validated_csv_file_name(&file_name);
    let normalized_name = match normalized_name_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let current_dir_result = std::env::current_dir();
    let current_dir = match current_dir_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => {
            return std::result::Result::Err(format!("cannot resolve current directory: {error}"));
        },
    };
    let export_dir = crate::csv_export_directory_from_current_dir(&current_dir);
    let create_result = tokio::fs::create_dir_all(&export_dir).await;
    if let std::result::Result::Err(error) = create_result {
        return std::result::Result::Err(format!("cannot create CSV export directory: {error}"));
    }
    let export_path_result = crate::available_csv_export_path(&export_dir, normalized_name).await;
    let export_path = match export_path_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let mut bytes = std::vec::Vec::with_capacity(content.len() + 3);
    bytes.extend_from_slice(&[0xEF, 0xBB, 0xBF]);
    bytes.extend_from_slice(content.as_bytes());
    let write_result = tokio::fs::write(&export_path, bytes).await;
    if let std::result::Result::Err(error) = write_result {
        return std::result::Result::Err(format!("cannot write CSV export: {error}"));
    }
    let display_path = export_path.to_string_lossy().into_owned();
    tracing::info!(target: crate::TRACING_TARGET, path = %display_path, "CSV replay candidate export written");
    return std::result::Result::Ok(display_path);
}

/// Loads static browser options from the active PostgreSQL profile.
#[tauri::command]
#[allow(clippy::question_mark_used)]
async fn demo_sql_replay_options(
    state: tauri::State<'_, crate::AppState>,
) -> std::result::Result<crate::DemoSqlReplayOptionsPayload, std::string::String> {
    let profile = state.active_profile().clone();
    let options_result = crate::postgres_store_options_from_profile(&profile, false);
    let options = match options_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
    };
    let mut known_programs =
        std::vec::Vec::with_capacity(kb_program_ids::registered_program_ids().len());
    for entry in kb_program_ids::registered_program_ids() {
        known_programs.push(crate::DemoSqlReplayKnownProgramOption {
            code: entry.code().to_owned(),
            program_id: entry.program_id().to_owned(),
        });
    }
    return std::result::Result::Ok(crate::DemoSqlReplayOptionsPayload {
        active_profile_name: profile.name,
        masked_dsn: options.masked_dsn(),
        maximum_limit: kb_store::MAX_REPLAY_CANDIDATE_ROWS,
        known_programs,
    });
}

/// Loads bounded transaction replay candidates from PostgreSQL.
#[tauri::command]
#[allow(clippy::question_mark_used)]
async fn load_demo_sql_replay_transactions(
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoSqlReplayTransactionRequest,
) -> std::result::Result<std::vec::Vec<crate::DemoSqlReplayTransactionRow>, std::string::String> {
    let program_scope_result = crate::program_scope_from_code(request.program_scope.as_str());
    let program_scope = match program_scope_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let entity_kind_result = crate::optional_entity_kind_from_code(request.entity_kind.as_deref());
    let entity_kind = match entity_kind_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let filter_result = kb_store::PostgresReplayTransactionFilter::new(
        request.signature_contains,
        request.min_slot,
        request.max_slot,
        request.raw_processing_state,
        request.ledger_status,
        request.program_id,
        program_scope,
        entity_kind,
        request.entity_value,
        request.limit,
        request.newest_first,
    );
    let filter = match filter_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
    };
    let store_result = crate::connect_postgres_store(state.active_profile()).await;
    let store = match store_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let rows_result = store.replay_transaction_candidates(&filter).await;
    let rows = match rows_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
    };
    tracing::debug!(target: crate::TRACING_TARGET, rows = rows.len(), "loaded replay transaction candidates");
    let mut output = std::vec::Vec::with_capacity(rows.len());
    for row in rows {
        output.push(crate::transaction_row_from_pg(row));
    }
    return std::result::Result::Ok(output);
}

/// Loads bounded program summaries from PostgreSQL.
#[tauri::command]
#[allow(clippy::question_mark_used)]
async fn load_demo_sql_replay_programs(
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoSqlReplayProgramRequest,
) -> std::result::Result<std::vec::Vec<crate::DemoSqlReplayProgramRow>, std::string::String> {
    let filter_result =
        kb_store::PostgresReplayProgramFilter::new(request.program_id_contains, request.limit);
    let filter = match filter_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
    };
    let store_result = crate::connect_postgres_store(state.active_profile()).await;
    let store = match store_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let rows_result = store.replay_program_summaries(&filter).await;
    let rows = match rows_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
    };
    tracing::debug!(target: crate::TRACING_TARGET, rows = rows.len(), "loaded replay program summaries");
    let mut output = std::vec::Vec::with_capacity(rows.len());
    for row in rows {
        output.push(crate::program_row_from_pg(row));
    }
    return std::result::Result::Ok(output);
}

/// Loads bounded mint, owner or account-key summaries from PostgreSQL core tables.
#[tauri::command]
#[allow(clippy::question_mark_used)]
async fn load_demo_sql_replay_entities(
    state: tauri::State<'_, crate::AppState>,
    request: crate::DemoSqlReplayEntityRequest,
) -> std::result::Result<std::vec::Vec<crate::DemoSqlReplayEntityRow>, std::string::String> {
    let entity_kind_result = crate::entity_kind_from_code(request.entity_kind.as_str());
    let entity_kind = match entity_kind_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let filter_result = kb_store::PostgresReplayEntityFilter::new(
        entity_kind,
        request.entity_value_contains,
        request.limit,
    );
    let filter = match filter_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
    };
    let store_result = crate::connect_postgres_store(state.active_profile()).await;
    let store = match store_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let rows_result = store.replay_entity_summaries(&filter).await;
    let rows = match rows_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
    };
    tracing::debug!(target: crate::TRACING_TARGET, rows = rows.len(), "loaded replay entity summaries");
    let mut output = std::vec::Vec::with_capacity(rows.len());
    for row in rows {
        output.push(crate::entity_row_from_pg(row));
    }
    return std::result::Result::Ok(output);
}