use std::path::PathBuf;

use clap::{IntoApp, Parser};
use serde::{de::DeserializeOwned, Serialize};
use thiserror::Error;
use tracing::metadata::LevelFilter;
use tracing_log::{LogTracer, log_tracer::SetLoggerError};
use tracing_subscriber::EnvFilter;

use crate::config::{self, ConfigFileFormat};

// Exit codes as defined in sysexits.h.
pub const INTERNAL_ERROR_EXIT_CODE: i32 = 70;
pub const CONFIGURATION_ERROR_EXIT_CODE: i32 = 78;

#[derive(Error, Debug)]
pub enum CliError {
    #[error(transparent)]
    ArgParse(#[from] clap::Error),
    #[error(transparent)]
    Config(#[from] config::ConfigError),
    #[error(transparent)]
    SetLogger(#[from] SetLoggerError),
    #[error(transparent)]
    InitLogger(#[from] Box<dyn std::error::Error + Send + Sync + 'static>),
}

pub trait AppOpts: Parser {
    fn try_init() -> Result<Self, CliError> {
        let result = Self::try_parse().map_err(CliError::ArgParse);

        match &result {
            Ok(result) => {
                //LogTracer::init()?;

                try_init_pretty_logger(
                    result.get_log_environment_variable_name(),
                    result.get_log_level_filter(),
                )?;
            }
            Err(_) => {
                // Initialize the logger with defaults.
                //LogTracer::init()?;
    
                tracing_subscriber::fmt::init();
            }
        }

        result
    }

    fn init() -> Self {
        match Self::try_init() {
            Ok(args) => args,
            Err(CliError::ArgParse(err)) => err.exit(),
            Err(CliError::Config(err)) => {
                tracing::error!("{}", err);

                safe_exit(CONFIGURATION_ERROR_EXIT_CODE);
            },
            Err(CliError::SetLogger(err)) => {
                eprintln!("{}", err);

                safe_exit(INTERNAL_ERROR_EXIT_CODE);
            },
            Err(CliError::InitLogger(err)) => {
                eprintln!("{}", err);

                safe_exit(INTERNAL_ERROR_EXIT_CODE);
            },
        }
    }

    fn get_log_level_filter(&self) -> Option<LevelFilter> {
        None
    }

    fn get_log_environment_variable_name(&self) -> Option<&str> {
        None
    }
}

pub trait ConfigurableAppOpts<C: DeserializeOwned + Default + Serialize>: AppOpts {
    fn try_init_with_config() -> Result<(Self, C), CliError> {
        let opts = Self::try_init()?;

        let app = <Self as IntoApp>::command();

        let conf = config::from_defaults(
            app.get_name(),
            &opts.get_additional_config_paths(),
            opts.get_config_file_format(),
        )
        .map_err(CliError::Config)?;

        Ok((opts, conf))
    }

    fn init_with_config() -> (Self, C) {
        match Self::try_init_with_config() {
            Ok(args_and_config) => args_and_config,
            Err(CliError::ArgParse(err)) => err.exit(),
            Err(CliError::Config(err)) => {
                tracing::error!("{}", err);

                safe_exit(CONFIGURATION_ERROR_EXIT_CODE);
            },
            Err(CliError::SetLogger(err)) => {
                eprintln!("{}", err);

                safe_exit(INTERNAL_ERROR_EXIT_CODE);
            },
            Err(CliError::InitLogger(err)) => {
                eprintln!("{}", err);

                safe_exit(INTERNAL_ERROR_EXIT_CODE);
            },
        }
    }

    fn get_config_file_format(&self) -> ConfigFileFormat {
        ConfigFileFormat::Toml
    }

    fn get_additional_config_paths(&self) -> Vec<(PathBuf, Option<ConfigFileFormat>)>;
}

fn try_init_pretty_logger(
    environment_variable_name: Option<&str>,
    level_filter_override: Option<LevelFilter>,
) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
    let mut builder = tracing_subscriber::fmt();

    if let Some(level_filter_override) = level_filter_override {
        builder = builder.with_max_level(level_filter_override);
    }

    let filter = if let Some(environment_variable_name) = environment_variable_name {
        EnvFilter::from_env(environment_variable_name)
    } else {
        EnvFilter::from_default_env()
    };

    builder.with_env_filter(filter).try_init()
}

/// Converts a integer verbosity value into a `LevelFilter`.
///
/// Examples:
///
/// ```
/// use collective::cli::get_log_level_filter_from_verbosity;
///
/// assert_eq!(
///     get_log_level_filter_from_verbosity(1),
///     Some(log::LevelFilter::Info)
/// );
///
/// assert_eq!(get_log_level_filter_from_verbosity(15), None);
/// ```
pub fn get_log_level_filter_from_verbosity(verbosity: u8) -> Option<LevelFilter> {
    match verbosity {
        3 => Some(LevelFilter::TRACE),
        2 => Some(LevelFilter::DEBUG),
        1 => Some(LevelFilter::INFO),
        _ => None,
    }
}

/// Flushes stdout/stderr and terminates the current process.
///
/// This is used internally in the library to handle non-critical CLI errors.
pub fn safe_exit(code: i32) -> ! {
    use std::io::Write;

    let _ = std::io::stdout().lock().flush();
    let _ = std::io::stderr().lock().flush();

    std::process::exit(code)
}