// file: crates/ksp-app-store-desk/src/app_state.rs
// version: 5

//! Shared backend state owned by the Store Desk Tauri application.

/// Shared Store Desk application state managed by Tauri.
pub(crate) struct AppState {
    config_management: ksp_config_lib::ConfigManagement,
    logging_runtime: std::sync::Mutex<LoggingRuntimeState>,
    shutdown_started: std::sync::atomic::AtomicBool,
    splash_settings: crate::SplashSettings,
    splash_sequence_started: std::sync::atomic::AtomicBool,
    store_startup: crate::StoreStartup,
}

impl crate::AppState {
    /// Initializes Config ownership, composite-managed Logging, Store readiness and common splash settings.
    pub(crate) fn initialize(arguments: &[std::ffi::OsString]) -> ksp_core_lib::Result<Self> {
        let config_management = crate::config_management(arguments);
        let config_management = match config_management {
            std::result::Result::Ok(value) => value,
            std::result::Result::Err(error) => return std::result::Result::Err(error),
        };
        let runtime_identity = crate::launch_identity();
        let runtime_identity = match runtime_identity {
            std::result::Result::Ok(value) => value,
            std::result::Result::Err(error) => return std::result::Result::Err(error),
        };
        let logging_startup = crate::initialize_logging(&config_management, &runtime_identity);
        let logging_startup = match logging_startup {
            std::result::Result::Ok(value) => value,
            std::result::Result::Err(error) => return std::result::Result::Err(error),
        };
        let store_startup = tauri::async_runtime::block_on(crate::initialize_store(&config_management));
        let splash_settings = crate::SplashSettings::load();
        let splash_settings = match splash_settings {
            std::result::Result::Ok(value) => value,
            std::result::Result::Err(error) => {
                ksp_logging_lib::warn!(
                    target: crate::TRACING_TARGET,
                    domain = crate::TRACING_DOMAIN_WINDOWS,
                    error_domain = error.code().domain(),
                    error_code = error.code().code(),
                    "managed splash timings are invalid; using transient in-memory defaults"
                );
                crate::SplashSettings::fallback()
            },
        };
        ksp_logging_lib::debug!(
            target: crate::TRACING_TARGET,
            domain = crate::TRACING_DOMAIN_WINDOWS,
            minimum_ms = splash_settings.minimum_ms(),
            minimum_source = splash_settings.minimum_source(),
            fade_in_ms = splash_settings.fade_in_ms(),
            fade_in_source = splash_settings.fade_in_source(),
            fade_out_ms = splash_settings.fade_out_ms(),
            fade_out_source = splash_settings.fade_out_source(),
            expected_backend_lifecycle_ms = splash_settings.expected_backend_lifecycle_ms(),
            "resolved Store Desk splash timings"
        );
        return std::result::Result::Ok(Self {
            config_management,
            logging_runtime: std::sync::Mutex::new(LoggingRuntimeState {
                guard: logging_startup.guard,
                active_profile_id: logging_startup.active_profile_id,
                fallback_active: logging_startup.fallback_active,
                startup_diagnostic: logging_startup.startup_diagnostic,
            }),
            shutdown_started: std::sync::atomic::AtomicBool::new(false),
            splash_settings,
            splash_sequence_started: std::sync::atomic::AtomicBool::new(false),
            store_startup,
        });
    }

    /// Builds the safe shell/Config/Logging status exposed by Store Desk diagnostics.
    pub(crate) fn shell_status(&self) -> ksp_core_lib::Result<crate::ShellStatusDto> {
        let document_count = self.config_management.engine().registry().descriptors().count();
        let document_count = u32::try_from(document_count);
        let document_count = match document_count {
            std::result::Result::Ok(value) => value,
            std::result::Result::Err(error) => {
                return std::result::Result::Err(
                    ksp_core_lib::Error::new(
                        crate::ERROR_CODE_APP_STATE_INVALID,
                        "Config registry contains too many descriptors for the Store Desk runtime DTO",
                    )
                    .with_source(error),
                );
            },
        };
        let runtime = self.logging_runtime.lock();
        let runtime = match runtime {
            std::result::Result::Ok(value) => value,
            std::result::Result::Err(_) => {
                return std::result::Result::Err(ksp_core_lib::Error::new(
                    crate::ERROR_CODE_APP_STATE_LOCK_FAILED,
                    "Store Desk Logging runtime state lock is poisoned",
                ));
            },
        };
        let _keep_guard_alive = &runtime.guard;
        return std::result::Result::Ok(crate::ShellStatusDto {
            active_logging_profile: runtime.active_profile_id.clone(),
            application_version: env!("CARGO_PKG_VERSION").to_owned(),
            config_document_count: document_count,
            fallback_logging_active: runtime.fallback_active,
            shell_phase: "pre.010-observations-ui".to_owned(),
            startup_diagnostic: runtime.startup_diagnostic.clone(),
        });
    }

    /// Builds one fresh safe Store runtime/health projection for the Overview and Diagnostics screens.
    pub(crate) async fn store_runtime_status(&self) -> crate::StoreRuntimeStatusDto {
        return self.store_startup.status().await;
    }

    /// Executes one bounded RAW account-state inspection query through the retained Store facade.
    pub(crate) async fn query_accounts(&self, request: crate::StoreAccountQueryRequestDto) -> ksp_core_lib::Result<crate::StoreAccountQueryResponseDto> {
        return self.store_startup.query_accounts(request).await;
    }

    /// Loads one explicit RAW account-state detail through the retained Store facade.
    pub(crate) async fn account_detail(&self, request: crate::StoreAccountDetailRequestDto) -> ksp_core_lib::Result<crate::StoreAccountDetailDto> {
        return self.store_startup.account_detail(request).await;
    }

    /// Executes one bounded metadata-only observation inspection for one explicit RAW account state.
    pub(crate) async fn query_account_observations(
        &self,
        request: crate::StoreAccountObservationQueryRequestDto,
    ) -> ksp_core_lib::Result<crate::StoreAccountObservationQueryResponseDto> {
        return self.store_startup.query_account_observations(request).await;
    }

    /// Executes one bounded RAW transaction inspection query through the retained Store facade.
    pub(crate) async fn query_transactions(
        &self,
        request: crate::StoreTransactionQueryRequestDto,
    ) -> ksp_core_lib::Result<crate::StoreTransactionQueryResponseDto> {
        return self.store_startup.query_transactions(request).await;
    }

    /// Loads one explicit RAW transaction detail through the retained Store facade.
    pub(crate) async fn transaction_detail(&self, request: crate::StoreTransactionDetailRequestDto) -> ksp_core_lib::Result<crate::StoreTransactionDetailDto> {
        return self.store_startup.transaction_detail(request).await;
    }

    /// Executes one bounded metadata-only observation inspection for one explicit RAW transaction.
    pub(crate) async fn query_transaction_observations(
        &self,
        request: crate::StoreTransactionObservationQueryRequestDto,
    ) -> ksp_core_lib::Result<crate::StoreTransactionObservationQueryResponseDto> {
        return self.store_startup.query_transaction_observations(request).await;
    }

    /// Returns the resolved splash timings captured during application bootstrap.
    #[must_use]
    pub(crate) const fn splash_settings(&self) -> crate::SplashSettings {
        return self.splash_settings;
    }

    /// Marks the one-shot splash lifecycle as started and reports whether this caller won the transition.
    pub(crate) fn begin_splash_sequence(&self) -> bool {
        return self
            .splash_sequence_started
            .compare_exchange(false, true, std::sync::atomic::Ordering::AcqRel, std::sync::atomic::Ordering::Acquire)
            .is_ok();
    }

    /// Marks graceful application shutdown as started and reports whether this caller won the one-shot transition.
    pub(crate) fn begin_shutdown(&self) -> bool {
        return self.shutdown_started.compare_exchange(false, true, std::sync::atomic::Ordering::AcqRel, std::sync::atomic::Ordering::Acquire).is_ok();
    }

    /// Explicitly closes the retained Store runtime when application shutdown begins.
    pub(crate) async fn close_store(&self) -> ksp_core_lib::Result<()> {
        return self.store_startup.close().await;
    }
}

struct LoggingRuntimeState {
    guard: ksp_logging_lib::LoggingGuard,
    active_profile_id: std::option::Option<String>,
    fallback_active: bool,
    startup_diagnostic: std::option::Option<crate::CommandErrorDto>,
}