use crate::db::get_connection;

use derive_more::From;

use rust_i18n::t;

use sqlx::Error::RowNotFound;

use std::env::var;

use std::fmt;

use std::sync::LazyLock;

use thiserror::Error;

/// Represents an error that can occur while accessing the configuration.

///

/// # Variants

///

/// - `NoConfig(String)`: Returned when a specific configuration field is not found.

/// - `DB`: Indicates a database access error.

/// - `Sqlx`: An error propagated from the `SQLx` crate.

///

/// # Example

///

/// ```rust

/// use thiserror::Error;

///

/// #[derive(Debug, Error)]

/// pub enum ConfigError {

///     #[error("No such config field: {0}")]

///     NoConfig(String),

///     #[error("Can't access db")]

///     DB,

///     #[error("Sqlx")]

///     Sqlx(#[from] sqlx::Error),

/// }

/// ```

#[derive(Debug, Error)]

pub enum ConfigError {

    #[error("No such config field: {0}")]

    NoConfig(String),

    #[error("Can't access db")]

    DB,

    // The underlying error is carried through: swallowing it turned a unique

    // violation into the word "Sqlx" in the log, which names no cause at all.

    #[error("{0}")]

    Sqlx(#[from] sqlx::Error),

}

/// Represents a configuration value stored in the system.

///

/// # Variants

///

/// - `String`: Stores the configuration as a string.

/// - `Blob`: Stores the configuration as a binary blob.

///

/// # Example

///

/// ```rust

/// use server::config::ConfigOption;

/// let config_str = ConfigOption::String("example".to_string());

/// let config_blob = ConfigOption::Blob(vec![1, 2, 3, 4]);

/// ```

///

/// You can also convert `String` and `Vec<u8>` directly into `ConfigOption`

/// using the `From` trait:

///

/// ```rust

/// use server::config::ConfigOption;

/// let config: ConfigOption = "example".to_string().into();

/// let blob: ConfigOption = vec![1, 2, 3, 4].into();

/// ```

#[derive(Debug, From, PartialEq, Clone)]

pub enum ConfigOption {

    String(#[from] String),

    Blob(#[from] Vec<u8>),

}

impl fmt::Display for ConfigOption {

        }

}

/// Allows for the conversion from a `&str` to `ConfigOption`.

///

/// This is useful for passing string literals or string slices directly as `ConfigOption`.

/// The conversion will wrap the `&str` in the `ConfigOption::String` variant.

///

/// # Example

///

/// ```rust

/// use server::config::ConfigOption;

/// let config_option: ConfigOption = "example text".into();

/// assert_eq!(config_option, ConfigOption::String("example text".to_string()));

/// ```

impl From<&str> for ConfigOption {

}

/// Convert `ConfigOption` into a `&[u8]` reference when the variant is a `Blob`.

///

/// # Example

///

/// ```rust

/// use server::config::ConfigOption;

/// let config = ConfigOption::Blob(vec![1, 2, 3]);

/// let byte_ref: &[u8] = config.as_ref(); // Works

/// ```

impl AsRef<[u8]> for ConfigOption {

        }

}

// The config read/write logic is identical for the system (admin DB) and

// per-user surfaces — only the connection differs. The `*_on` helpers take an

// explicit connection so both surfaces share one implementation; `User::config`

// / `User::set_config` (see `user.rs`) pass a per-user connection, while the

// `system_*` wrappers below pass the global admin connection.

/// Fetches the `contents` of a field from the configdata.

///

/// This function attempts to retrieve the configuration stored in the

/// `configdata` table.  If the field is not found, it returns a

/// `ConfigError::NoConfig`.

///

/// # Arguments

///

/// - `field`: The name of the field to retrieve.

///

/// # Returns

///

/// - `Ok(Some(ConfigOption))` if the field exists.

/// - `Err(ConfigError::NoConfig)` if the field is absent from both the

///   `config` and `configdata` tables (callers that treat "absent" as

///   "not set" — e.g. the `GetConfig` command — normalise this to `Ok(None)`).

/// - `Err(ConfigError)` on any other retrieval error.

///

/// # Example

///

/// ```rust,ignore

/// let config = system_configdata("example_field").await?;

/// if let Some(option) = config {

///     println!("Config value: {}", option);

/// }

/// ```

///

/// # Errors

///

/// Returns a `ConfigError::DB` if there is an issue with the database connection.

            } else {

            }

/// Reads a config field on the given connection: the `config` (string) table

/// first, falling back to `configdata` (blob).

///

/// # Errors

/// `ConfigError::DB` on a database error.

        }

    }

/// Upserts a config field on the given connection (string → `config`, blob →

/// `configdata`). The upsert keys on `lower(field)` (see the SQL), so it is

/// idempotent and case-insensitive.

///

/// # Errors

/// `ConfigError::DB` on a database error, `ConfigError::NoConfig` if the row is

/// missing for an update.

        }

        }

    }

        } else {

        }

/// Reads a SYSTEM (server-wide) config field from the global admin database.

/// For server-wide keys (infra URLs, locale) and the bootstrap reads that run

/// before any user is resolved. Per-user config goes through `User::config`.

///

/// # Errors

/// `ConfigError::DB` on a database error.

/// Reads a SYSTEM config blob field from the global admin database.

///

/// # Errors

/// `ConfigError::DB` on a database error.

/// Writes a SYSTEM config field to the global admin database.

///

/// # Errors

/// `ConfigError::DB` on a database error.

    // Matched rather than deref'd: only the String variant names a locale, and

    // a Blob in that row should fall back rather than panic the boot.

            "{}",

            )

        );

#[cfg(test)]

mod config_tests {

    use super::*;

    use crate::db::DB_POOL;

    use sqlx::PgPool;

    use supp_macro::local_db_sqlx_test;

    use tokio::sync::OnceCell;

    /// Context for keeping environment intact

    static CONTEXT: OnceCell<()> = OnceCell::const_new();

                #[cfg(feature = "testlog")]

    #[local_db_sqlx_test]

    async fn test_config_string(pool: PgPool) {

        let opt = ConfigOption::String("testval".to_string());

        set_system_config("testfield", opt.clone()).await.unwrap();

        let val = system_config("testfield").await.unwrap().unwrap();

        assert_eq!(val, opt);

    }

    #[local_db_sqlx_test]

    async fn test_config_configdata(pool: PgPool) {

        let opt = ConfigOption::Blob(vec![0, 1, 2, 3]);

        set_system_config("testblob", opt.clone()).await.unwrap();

        let val = system_config("testblob").await.unwrap().unwrap();

        assert_eq!(val, opt);

    }

}