//! Provides an interface to build command line application within CELP
//!
//! This includes functionality for initialising the logger, publishing the application info
//! and building this application info

use std::str::FromStr;

use clap;

use crate::cache::publish_app_info;
use crate::error;
use crate::logger::log::{init_logger, SDKLogLevel};
use crate::protobuf::se::{app_info::SemVer, AppInfo};

/*
 * Public types, constants, ...
 */

/// Expose clap's Arg [`clap::Arg`]
pub type Arg = clap::Arg;

/*
 * Public interface
 */

/// CelpApp: Thin wrapper around [`clap::Command`]. Allows creating a command line application
pub struct CelpApp {
    pub app_name: String,
    init_logger: bool,
    publish_app_info: Option<AppInfo>,
    command: clap::Command,
}

impl CelpApp {
    /// Creates a new CelpApp instantiation with the desired name
    /// # Arguments
    ///
    /// * `app_name` - The application name
    ///
    /// # Example
    /// ```rust,no_run
    /// use celp_sdk::util::celp_app::CelpApp;
    ///
    /// let app = CelpApp::new("test");
    /// ```
    pub fn new(app_name: &'static str) -> Self {
        let mut cmd = Self {
            app_name: app_name.into(),
            init_logger: true,
            publish_app_info: None,
            command: clap::Command::new(app_name),
        };

        cmd = cmd
            .arg(
                Arg::new("log_level")
                    .short('l')
                    .long("log-level")
                    .help("The log level to use when running"),
            )
            .arg(
                Arg::new("app_info")
                    .short('I')
                    .long("app-info")
                    .help("Publish the app info to the broker. Including version info")
                    .action(clap::ArgAction::SetTrue),
            );

        cmd
    }

    /// see [`clap::Command`]
    pub fn ignore_errors(mut self, yes: bool) -> Self {
        self.command = self.command.ignore_errors(yes);

        self
    }

    /// see [`clap::Command`]
    pub fn disable_help_flag(mut self, yes: bool) -> Self {
        self.command = self.command.disable_help_flag(yes);

        self
    }

    /// see [`clap::Command`]
    pub fn allow_missing_positional(mut self, yes: bool) -> Self {
        self.command = self.command.allow_missing_positional(yes);

        self
    }

    /// see [`clap::Command`]
    pub fn arg(mut self, arg: Arg) -> Self {
        self.command = self.command.arg(arg);

        self
    }

    /// Ensures the logger is initialised (true by default)
    /// # Arguments
    ///
    /// * `yes` - Whether to initialise the logging or not
    ///
    /// # Example
    /// ```rust,no_run
    /// use celp_sdk::util::celp_app::CelpApp;
    ///
    /// let matches = CelpApp::new("test")
    ///     .init_logger(false)
    ///     .parse();
    /// ```
    pub fn init_logger(mut self, yes: bool) -> Self {
        self.init_logger = yes;

        self
    }

    /// Ensures the app version is published to the broker
    /// # Arguments
    ///
    /// * `app_info` - The application info to publish
    ///
    /// # Examples
    /// ```rust,no_run
    /// use celp_sdk::util::celp_app::{build_app_info, CelpApp};
    ///
    /// let app_info = build_app_info("1.0.0").unwrap();
    ///
    /// let matches = CelpApp::new("test")
    ///     .publish_app_info(app_info)
    ///     .parse();
    /// ```
    pub fn publish_app_info(mut self, app_info: AppInfo) -> Self {
        self.publish_app_info = Some(app_info);

        self
    }

    /// Parses the command line parameters and propagates the matches
    ///
    /// # Example
    /// ```rust,no_run
    /// use celp_sdk::util::celp_app::{build_app_info, Arg, CelpApp};
    ///
    /// let app_info = build_app_info("1.0.0").unwrap();
    ///
    /// let matches = CelpApp::new("test")
    ///     .publish_app_info(app_info)
    ///     .arg(
    ///         Arg::new("test")
    ///         .short('t')
    ///         .long("test")
    ///         .help("Testing an additional variable")
    ///         .required(true)
    ///     )
    ///     .get_matches();
    ///
    /// if let Some(t) = matches.get_one::<String>("test") {
    ///     println!("Test argument was set to \"{}\"", t);
    /// }
    /// ```
    pub fn get_matches(self) -> clap::ArgMatches {
        let mut matches = self.command.get_matches();

        if self.init_logger {
            initialise_logger(&self.app_name, &mut matches);
        }

        if let Some(ai) = self.publish_app_info {
            publish_app_info_if_requested(ai, &mut matches);
        }

        matches
    }

    /// Just parse the command line parameters
    ///
    /// # Example
    /// ```rust,no_run
    /// use celp_sdk::util::celp_app::CelpApp;
    ///
    /// let matches = CelpApp::new("test")
    ///     .parse();
    /// ```
    pub fn parse(self) {
        let _ = self.get_matches();
    }
}

/// Build the app version, getting the app name automatically an parsing the version
/// # Arguments
///
/// * `version_str` - The version string to parse
///
/// # Example
/// ```rust,no_run
/// use celp_sdk::{
///     protobuf::{se::AppInfo, app_info::SemVer},
///     util::celp_app::build_app_info,
/// };
///
/// let app_info = match build_app_info("1.0.0") {
///     Ok(ai) => ai,
///     Err(e) => {
///         eprintln!("{e:#?}");
///         AppInfo::new("test", SemVer::default())
///     }
/// };
/// ```
pub fn build_app_info(version_str: &str) -> Result<AppInfo, Box<dyn std::error::Error>> {
    let app_name = std::env::current_exe()
        .unwrap_or_default()
        .file_name()
        .ok_or("Executable has no valid file name!")?
        .to_str()
        .ok_or("Executable file name contains invalid UTF-8 characters!")?
        .to_owned();

    Ok(AppInfo::new(
        &app_name,
        SemVer::from_version_str(version_str)?,
    ))
}

/*
 * Private functions
 */

fn initialise_logger(app_name: &str, matches: &mut clap::ArgMatches) {
    let level = if let Some(l) = matches.remove_one::<String>("log_level") {
        if let Ok(n) = l.parse::<usize>() {
            SDKLogLevel::from_repr(n)
        } else {
            SDKLogLevel::from_str(&l).ok()
        }
        .unwrap_or(SDKLogLevel::default())
    } else {
        SDKLogLevel::Info
    };

    init_logger(app_name, Some(level));
}

fn publish_app_info_if_requested(app_info: AppInfo, matches: &mut clap::ArgMatches) {
    if matches.get_flag("app_info") {
        if let Err(e) = publish_app_info(app_info) {
            error!("unable to publish app info: {e:#?}");
        }
    }
}