use crate::*;
use std::collections::HashMap;
use std::sync::Arc;

#[derive(Default)]
pub struct ConfigurationProviderBuilder {
  values: HashMap<ConfigKey, String>,
}

impl ConfigurationProviderBuilder {
  pub fn new() -> Self {
    Self::default()
  }

  pub fn add<K, V>(&mut self, key: K, value: V)
  where
    K: Into<ConfigKey>,
    V: Into<String>,
  {
    self.values.insert(key.into(), value.into());
  }

  pub fn build(self) -> DefaultConfigurationProvider {
    DefaultConfigurationProvider::new(self.values)
  }
}

#[derive(Clone)]
pub struct DefaultConfigurationProvider {
  values: Arc<HashMap<ConfigKey, String>>,
}

impl DefaultConfigurationProvider {
  fn new(map: HashMap<ConfigKey, String>) -> Self {
    Self {
      values: Arc::new(map),
    }
  }

  pub fn get<K: Into<ConfigKey>>(&self, key: K) -> Option<&str> {
    self.try_get(&key.into())
  }

  pub fn len(&self) -> usize {
    self.values.len()
  }
}

impl ConfigurationSource for DefaultConfigurationProvider {
  fn build<B: ConfigurationBuilder>(self, builder: B) -> std::io::Result<B> {
    Ok(builder.push_provider(self))
  }
}

impl ConfigurationProvider for DefaultConfigurationProvider {
  fn try_get(&self, key: &ConfigKey) -> Option<&str> {
    match self.values.get(key) {
      None => None,
      Some(s) => Some(s.as_ref()),
    }
  }

  fn get_child_keys(&self, key: &ConfigKey, keys: &mut HashSet<ConfigKey>) {
    for config_key in self.values.keys() {
      if keys.contains(config_key) {
        continue;
      }

      // TODO: how to get rid of clone?
      let mut config_key = config_key.clone();
      while !config_key.is_empty() {
        let parent = config_key.parent();
        if parent == *key {
          keys.insert(config_key.section_key());
        }

        config_key = parent;
      }
    }
  }
}