extern crate clap;
extern crate preftool;
extern crate preftool_clap;
extern crate preftool_dirs;
extern crate preftool_env;
extern crate preftool_file;
extern crate preftool_toml;
#[macro_use]
extern crate slog;

use preftool::*;
use preftool_clap::*;
use preftool_dirs::*;
use preftool_env::*;
use preftool_file::*;
use slog::Drain;
use std::io::{Read, Result};
use std::marker::PhantomData;
use std::sync::Arc;

trait ConfigSource {
  fn build(&self, builder: ConfigBuilder) -> Result<ConfigBuilder>;
}

struct ConfigSourceWrapper<S: ConfigurationSource> {
  source: S,
}

impl<S: ConfigurationSource + Clone> ConfigSource for ConfigSourceWrapper<S> {
  fn build(&self, builder: ConfigBuilder) -> Result<ConfigBuilder> {
    self.source.clone().build(builder)
  }
}

impl<S: ConfigurationSource> From<S> for ConfigSourceWrapper<S> {
  fn from(source: S) -> Self {
    Self { source }
  }
}

trait ConfigFileFormat {
  fn get_config(&self, reader: Box<dyn Read>) -> Result<Box<dyn ConfigurationProvider>>;
  fn default_suffixes(&self) -> &'static [&'static str];
  fn default_config(
    &self,
    search_paths: SearchPathOwner,
    app_name: String,
  ) -> Box<dyn ConfigSource>;
}

struct ConfigFileFormatWrapper<F: ConfigurationFileFormat> {
  format: PhantomData<*const F>,
}

impl<F: ConfigurationFileFormat> ConfigFileFormatWrapper<F> {
  fn new(_format: F) -> Self {
    Self {
      format: PhantomData,
    }
  }
}

impl<F: ConfigurationFileFormat + 'static> ConfigFileFormat for ConfigFileFormatWrapper<F> {
  fn get_config(&self, reader: Box<dyn Read>) -> Result<Box<dyn ConfigurationProvider>> {
    let provider = F::get_config(reader)?;
    Ok(Box::new(provider))
  }

  fn default_suffixes(&self) -> &'static [&'static str] {
    F::default_suffixes()
  }

  fn default_config(
    &self,
    search_paths: SearchPathOwner,
    app_name: String,
  ) -> Box<dyn ConfigSource> {
    Box::new(ConfigSourceWrapper::from(F::default_config_files(
      search_paths,
      app_name,
    )))
  }
}

trait ConfigArgsFormat<'a: 'b, 'b> {
  fn get_config(&self, app: clap::App<'a, 'b>) -> Result<Box<dyn ConfigurationProvider>>;
}

struct ConfigArgsFormatWrapper<T: ClapConfig> {
  args_type: PhantomData<*const T>,
}

impl<T: ClapConfig + Sized> ConfigArgsFormatWrapper<T> {
  fn new() -> Self {
    Self {
      args_type: PhantomData,
    }
  }
}

impl<'a: 'b, 'b, T: ClapConfig + Sized> ConfigArgsFormat<'a, 'b> for ConfigArgsFormatWrapper<T> {
  fn get_config(&self, app: clap::App<'a, 'b>) -> Result<Box<dyn ConfigurationProvider>> {
    let config = T::from_cli(app);
    Ok(Box::new(config))
  }
}

trait DynSearchPaths {
  fn iter(&self) -> Box<dyn Iterator<Item = ConfigPath>>;
  fn logger(&self) -> &slog::Logger;
}

struct SearchPathsWrapper<S: SearchPaths> {
  inner: S,
}

impl<S: SearchPaths> DynSearchPaths for SearchPathsWrapper<S> {
  fn iter(&self) -> Box<dyn Iterator<Item = ConfigPath>> {
    Box::new(self.inner.iter())
  }

  fn logger(&self) -> &slog::Logger {
    self.inner.logger()
  }
}

impl<S: SearchPaths> From<S> for SearchPathsWrapper<S> {
  fn from(inner: S) -> SearchPathsWrapper<S> {
    SearchPathsWrapper { inner }
  }
}

#[derive(Clone)]
struct SearchPathOwner {
  inner: Arc<dyn DynSearchPaths>,
}

impl From<Arc<dyn DynSearchPaths>> for SearchPathOwner {
  fn from(inner: Arc<dyn DynSearchPaths>) -> Self {
    Self { inner }
  }
}

impl LogOwner for SearchPathOwner {
  fn logger(&self) -> &slog::Logger {
    self.inner.logger()
  }
}

impl SearchPaths for SearchPathOwner {
  type Iter = Box<Iterator<Item = ConfigPath> + 'static>;

  fn iter(&self) -> Self::Iter {
    self.inner.iter()
  }
}

pub struct AppConfigBuilder {
  logger: slog::Logger,
  name: String,
  builder: ConfigBuilder,
  formats: Vec<Box<dyn ConfigFileFormat>>,
  args_format: Option<Box<dyn for<'a> ConfigArgsFormat<'a, 'a>>>,
  app_config: Box<dyn for<'a, 'b> Fn(clap::App<'a, 'b>) -> clap::App<'a, 'b>>,
  search_paths: Arc<dyn DynSearchPaths>,
}

impl AppConfigBuilder {
  pub fn new<S: AsRef<str>>(name: S, logger: Option<slog::Logger>) -> std::io::Result<Self> {
    let logger = logger.unwrap_or_else(|| slog::Logger::root(slog_stdlog::StdLog.fuse(), o!()));
    let config_dirs = ConfigDirs::new(&name, Some(logger.clone()))?;
    let search_paths = Arc::new(SearchPathsWrapper::from(config_dirs));
    Ok(Self {
      logger,
      name: name.as_ref().to_owned(),
      builder: ConfigBuilder::new(),
      formats: Vec::new(),
      args_format: None,
      app_config: Box::new(|app| app),
      search_paths,
    })
  }

  pub fn add_format<F: ConfigurationFileFormat + 'static>(mut self, format: F) -> Self {
    self
      .formats
      .push(Box::new(ConfigFileFormatWrapper::new(format)));
    self
  }

  pub fn with_args<T: ClapConfig + 'static>(mut self) -> Self {
    match &self.args_format {
      Some(_) => panic!("Only one args format can be provided."),
      None => {
        self.args_format = Some(Box::new(ConfigArgsFormatWrapper::<T>::new()));
      }
    }

    self
  }

  pub fn configure<F>(mut self, f: F) -> Self
  where
    for<'a, 'b> F: 'static + Fn(clap::App<'a, 'b>) -> clap::App<'a, 'b>,
  {
    let f_old = self.app_config;
    let configure: Box<dyn for<'a, 'b> Fn(clap::App<'a, 'b>) -> clap::App<'a, 'b>> =
      Box::new(move |app| {
        let app = f_old(app);
        f(app)
      });

    self.app_config = configure;
    self
  }
}

impl ConfigurationBuilder for AppConfigBuilder {
  type Config = <ConfigBuilder as ConfigurationBuilder>::Config;

  // TODO: IntoConfigurationProvider trait?
  fn push_provider<P: ConfigurationProvider + 'static>(mut self, source: P) -> Self {
    self.builder = self.builder.push_provider(source);
    self
  }

  fn build(self) -> Result<Self::Config> {
    fn trim_and_lowercase_then_replace_spaces(name: &str, replacement: &str) -> String {
      let mut buf = String::with_capacity(name.len());
      let mut parts = name.split_whitespace();
      let mut current_part = parts.next();
      let replace = !replacement.is_empty();
      while current_part.is_some() {
        let value = current_part.unwrap().to_lowercase();
        buf.push_str(&value);
        current_part = parts.next();
        if replace && current_part.is_some() {
          buf.push_str(replacement);
        }
      }

      buf
    }

    let mut builder = self.builder;
    let search_paths = self.search_paths;
    for format in self.formats {
      let sources = format.default_config(
        search_paths.clone().into(),
        trim_and_lowercase_then_replace_spaces(&self.name, "-"),
      );
      builder = sources.build(builder)?;
    }

    builder = EnvironmentVariablesConfigurationSource::with_prefix(format!("{}_", &self.name))
      .build(builder)?;

    let app = clap::App::new(self.name);
    let app = (self.app_config)(app);

    // TODO: provide different args...
    trace!(self.logger, "Parse application args");
    match self.args_format {
      None => {
        app.get_matches();
      }
      Some(args_fmt) => {
        let provider = args_fmt.get_config(app)?;
        builder = builder.push_provider(provider);
      }
    }

    builder.build()
  }
}