use crate::data::entity_manager::EntityManager;
use crate::utils::string_utils::apply_env_vars;

#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Eq, PartialEq)]
pub struct ClientID(pub String);

#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct Client {
    /// The ID of the client
    pub id: ClientID,

    /// The human-readable name of the client
    pub name: String,

    /// A short description of the service provided by the client
    pub description: String,

    /// The secret used by the client to retrieve authenticated users information
    pub secret: String,

    /// The URI where the users should be redirected once authenticated
    pub redirect_uri: String,

    /// Specify if the client must be allowed by default for new account
    #[serde(default = "bool::default")]
    pub default: bool,

    /// Specify whether a client is granted to all users
    #[serde(default = "bool::default")]
    pub granted_to_all_users: bool,
}

impl PartialEq for Client {
    fn eq(&self, other: &Self) -> bool {
        self.id.eq(&other.id)
    }
}

impl Eq for Client {}

pub type ClientManager = EntityManager<Client>;

impl EntityManager<Client> {
    pub fn find_by_id(&self, u: &ClientID) -> Option<Client> {
        for entry in self.iter() {
            if entry.id.eq(u) {
                return Some(entry.clone());
            }
        }
        None
    }

    /// Get the list of default clients.
    ///
    /// i.e. the clients that are granted to new accounts by default
    pub fn get_default_clients(&self) -> Vec<&Client> {
        self.iter().filter(|u| u.default).collect()
    }

    pub fn apply_environment_variables(&mut self) {
        for c in self.iter_mut() {
            c.id = ClientID(apply_env_vars(&c.id.0));
            c.name = apply_env_vars(&c.name);
            c.description = apply_env_vars(&c.description);
            c.secret = apply_env_vars(&c.secret);
            c.redirect_uri = apply_env_vars(&c.redirect_uri);
        }
    }
}