use std::{
    env,
    process,
    time::Duration
};

// Define the qos.
const QOS:i32 = 1;

pub fn init_cli() -> mqtt::Client {

    let host = env::args().nth(1).unwrap_or_else(||
        env::var("BROKER_ADDRESS").unwrap().to_string()
    );

    // Define the set of options for the create.
    // Use an ID for a persistent session.
    let create_opts = mqtt::CreateOptionsBuilder::new()
        .server_uri(host)
        .client_id(env::var("BROKER_CLIENT").unwrap().to_string())
        .finalize();

    // Create a client.
    let cli = mqtt::Client::new(create_opts).unwrap_or_else(|err| {
        println!("Error creating the client: {:?}", err);
        process::exit(1);
    });

    // Define the set of options for the connection.
    let conn_opts = mqtt::ConnectOptionsBuilder::new()
        .keep_alive_interval(Duration::from_secs(20))
        .clean_session(true)
        .finalize();

    // Connect and wait for it to complete or fail.
    if let Err(e) = cli.connect(conn_opts) {
        println!("Unable to connect:\n\t{:?}", e);
        process::exit(1);
    }

    return cli;
}

pub fn publish_message(cli: mqtt::Client, topic: &str, message: &str) -> mqtt::Client {
    // let topic = get_topic_name(topic);
    let msg = mqtt::Message::new(get_topic_name(topic), message, QOS);
    let tok = cli.publish(msg);

    if let Err(e) = tok {
        println!("Error sending message: {:?}", e);
    }

    println!("{} : {}", topic, message);

    return cli;
}

pub fn disconnect(cli: mqtt::Client) {
    // Disconnect from the broker.
    let tok = cli.disconnect(None);
    println!("Disconnect from the broker");
    tok.unwrap();
}

pub fn get_topic_name(types: &str) -> String {

    let mut topic = env::var("SERVICE").unwrap().to_string();
    topic.push('/');
    let capteur = env::var("CAPTEUR").unwrap().to_string();
    topic.push_str(&capteur);
    topic.push('/');
    topic.push_str(&types);

    return topic;
}