tibba-util 0.2.5

// Copyright 2026 Tree xie.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use lz4_flex::block::DecompressError;
use snafu::Snafu;
use std::env;
use std::sync::LazyLock;
use tibba_error::Error as BaseError;

#[derive(Snafu, Debug)]
pub enum Error {
    #[snafu(display("{source}"))]
    Zstd { source: std::io::Error },
    #[snafu(display("{source}"))]
    Lz4Decompress { source: DecompressError },
    #[snafu(display("{source}"))]
    InvalidHeaderName {
        source: axum::http::header::InvalidHeaderName,
    },
    #[snafu(display("{source}"))]
    InvalidHeaderValue {
        source: axum::http::header::InvalidHeaderValue,
    },
    #[snafu(display("{source}"))]
    Axum { source: axum::Error },
    #[snafu(display("{message}"))]
    Invalid { message: String },
    #[snafu(display("{source}"))]
    Deserialize { source: serde_urlencoded::de::Error },
}

impl From<Error> for BaseError {
    fn from(val: Error) -> Self {
        // 单次 match：从 source 构造 BaseError 并打 sub_category，
        // 与项目其他 snafu 模块（tibba-config / tibba-sql 等）保持一致
        let err = match val {
            Error::Zstd { source } => BaseError::new(source).with_sub_category("zstd"),
            Error::Lz4Decompress { source } => {
                BaseError::new(source).with_sub_category("lz4_decompress")
            }
            Error::InvalidHeaderName { source } => {
                BaseError::new(source).with_sub_category("invalid_header_name")
            }
            Error::InvalidHeaderValue { source } => {
                BaseError::new(source).with_sub_category("invalid_header_value")
            }
            Error::Axum { source } => BaseError::new(source).with_sub_category("axum"),
            Error::Invalid { message } => BaseError::new(message).with_sub_category("invalid"),
            Error::Deserialize { source } => {
                BaseError::new(source).with_sub_category("deserialize")
            }
        };
        err.with_category("util")
    }
}

static RUST_ENV: LazyLock<String> =
    LazyLock::new(|| env::var("RUST_ENV").unwrap_or_else(|_| "dev".to_string()));

pub fn get_env() -> &'static str {
    &RUST_ENV
}

/// Whether it is a development environment
/// Used to determine whether it is a local development environment
pub fn is_development() -> bool {
    get_env() == "dev"
}

/// Whether it is a test environment
pub fn is_test() -> bool {
    get_env() == "test"
}

/// Whether it is a production environment
pub fn is_production() -> bool {
    get_env() == "production"
}

mod compression;
mod datetime;
mod http;
mod request;
mod response;
mod string;
mod uri;
mod value;

pub use compression::*;
pub use datetime::*;
pub use http::*;
pub use request::*;
pub use response::*;
pub use string::*;
pub use uri::*;
pub use value::*;