use std::path::PathBuf;

use lombok::{Builder, Getter, Setter};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, serde::Deserialize, serde::Serialize)]
#[serde(rename_all = "lowercase")]
pub enum BackendType {
    #[default]
    Local,
    S3,
}

#[derive(
    Debug, Clone, PartialEq, Eq, serde::Deserialize, serde::Serialize, Getter, Setter, Builder,
)]
#[serde(default)]
pub struct StorageSettings {
    backend: BackendType,
    local: LocalStorageSettings,
    s3: S3StorageSettings,
}

impl Default for StorageSettings {
    fn default() -> Self {
        Self {
            backend: BackendType::Local,
            local: LocalStorageSettings::default(),
            s3: S3StorageSettings::default(),
        }
    }
}

#[derive(
    Debug, Clone, PartialEq, Eq, serde::Deserialize, serde::Serialize, Getter, Setter, Builder,
)]
#[serde(default)]
pub struct LocalStorageSettings {
    root_dir: PathBuf,
}

impl Default for LocalStorageSettings {
    fn default() -> Self {
        Self {
            root_dir: PathBuf::from("./storage"),
        }
    }
}

#[derive(
    Debug, Clone, PartialEq, Eq, serde::Deserialize, serde::Serialize, Getter, Setter, Builder,
)]
#[serde(default)]
pub struct S3StorageSettings {
    endpoint: Option<String>,
    region: String,
    bucket: String,
    access_key_id: Option<String>,
    secret_access_key: Option<String>,
    prefix: Option<String>,
    allow_http: bool,
}

impl Default for S3StorageSettings {
    fn default() -> Self {
        Self {
            endpoint: None,
            region: "us-east-1".to_string(),
            bucket: String::new(),
            access_key_id: None,
            secret_access_key: None,
            prefix: None,
            allow_http: false,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn storage_settings_defaults() {
        let settings = StorageSettings::default();
        assert_eq!(*settings.get_backend(), BackendType::Local);
        assert_eq!(
            settings.get_local().get_root_dir(),
            &PathBuf::from("./storage")
        );
        assert_eq!(settings.get_s3().get_region(), "us-east-1");
        assert_eq!(settings.get_s3().get_bucket(), "");
        assert!(!settings.get_s3().get_allow_http());
        assert!(settings.get_s3().get_endpoint().is_none());
        assert!(settings.get_s3().get_access_key_id().is_none());
        assert!(settings.get_s3().get_secret_access_key().is_none());
        assert!(settings.get_s3().get_prefix().is_none());
    }

    #[test]
    fn storage_settings_deserialize() {
        let json = r#"{"backend":"s3","s3":{"bucket":"my-bucket","region":"cn-north-1","endpoint":"http://127.0.0.1:9000","allow_http":true}}"#;
        let settings: StorageSettings = serde_json::from_str(json).unwrap();
        assert_eq!(*settings.get_backend(), BackendType::S3);
        assert_eq!(settings.get_s3().get_bucket(), "my-bucket");
        assert_eq!(settings.get_s3().get_region(), "cn-north-1");
        assert!(settings.get_s3().get_allow_http());
        assert_eq!(
            settings.get_local().get_root_dir(),
            &PathBuf::from("./storage")
        );
    }
}