use std::path::PathBuf;

use libpt::log::{Level, Logger};

use clap::Parser;
use clap_verbosity_flag::{InfoLevel, Verbosity};

/// short about section displayed in help
const ABOUT_ROOT: &str = r##"
Let your hosts play ping pong over the network
"##;
/// longer about section displayed in help, is combined with [the short help](ABOUT_ROOT)
static LONG_ABOUT_ROOT: &str = r##"

    Connect to a ping pong server and periodically send a ping. The server will reply with a pong.
    That's it really. You can also host your own netpong server (server feature).
"##;

#[derive(Debug, Clone, Parser)]
#[command(
    author,
    version,
    about = ABOUT_ROOT,
    long_about = format!("{}{}", ABOUT_ROOT ,LONG_ABOUT_ROOT),
    help_template =
r#"{about-section}
{usage-heading} {usage}
{all-args}{tab}

libpt: {version}
Author: {author-with-newline}
"#
    )]
pub(crate) struct Cli {
    // clap_verbosity_flag seems to make this a global option implicitly
    /// set a verbosity, multiple allowed (f.e. -vvv)
    #[command(flatten)]
    pub(crate) verbose: Verbosity<InfoLevel>,

    /// show additional logging meta data
    #[arg(long)]
    pub(crate) meta: bool,

    // host a server instead of connecting to one
    #[cfg(feature = "server")]
    #[arg(short, long, default_value_t = false)]
    pub(crate) server: bool,

    /// Address of the server
    pub(crate) host: String,

    #[cfg(feature = "server")]
    #[arg(short, long)]
    pub key: Option<PathBuf>,
    #[arg(short, long)]
    pub certs: Option<PathBuf>,

    #[cfg(feature = "server")]
    #[arg(short, long)]
    pub indefinitely: bool,
}

impl Cli {
    pub fn cli_parse() -> Self {
        let cli = Self::parse();
        let ll: Level = match cli.verbose.log_level().unwrap().as_str() {
            "TRACE" => Level::TRACE,
            "DEBUG" => Level::DEBUG,
            "INFO" => Level::INFO,
            "WARN" => Level::WARN,
            "ERROR" => Level::ERROR,
            _ => {
                unreachable!();
            }
        };
        if cli.meta {
            let _ = Logger::builder()
                .set_level(ll)
                .display_filename(true)
                .build()
                .expect("could not initialize Logger");
        } else {
            // less verbose version
            let _ = Logger::builder()
                .set_level(ll)
                .build()
                .expect("could not initialize Logger");
        }
        cli
    }
}