use std::thread;

use anyhow::Result;
use embedded_svc::mqtt::client::{utils::ConnState, Client, Connection, MessageImpl, Publish, QoS};
use esp_idf_svc::mqtt::client::{EspMqttClient, MqttClientConfiguration};
use esp_idf_sys::EspError;
use log::*;

pub struct MessageQueue {
    pub client: Option<EspMqttClient<ConnState<MessageImpl, EspError>>>,
}

impl MessageQueue {
    pub fn new() -> MessageQueue {
        return MessageQueue { client: None };
    }

    pub fn init(&mut self) -> Result<()> {
        let conf = MqttClientConfiguration {
            client_id: Some("rust-esp32-std-demo"),
            crt_bundle_attach: Some(esp_idf_sys::esp_crt_bundle_attach),

            ..Default::default()
        };

        let (mut client, mut connection) =
            EspMqttClient::new_with_conn("mqtt://192.168.31.11:1883", &conf)?;

        info!("MQTT client started");
        thread::spawn(move || {
            info!("MQTT Listening for messages");

            while let Some(msg) = connection.next() {
                match msg {
                    Err(e) => info!("MQTT Message ERROR: {}", e),
                    Ok(msg) => info!("MQTT Message: {:?}", msg),
                }
            }

            info!("MQTT connection loop exit");
        });

        client
            .subscribe("esp32-c3-rust-wifi-demo", QoS::AtMostOnce)
            .map_err(|err| anyhow::anyhow!("subscribe message from queue failed. {}", err))?;

        info!("Subscribed to all topics (esp32-c3-rust-wifi-demo)");

        client
            .publish(
                "esp32-c3-rust-wifi-demo/ping",
                QoS::AtMostOnce,
                false,
                "Hello".as_bytes(),
            )
            .map_err(|err| anyhow::anyhow!("publish message to queue failed. {}", err))?;

        info!("Published a hello message to topic \"esp32-c3-rust-wifi-demo/ping\"");

        self.client = Some(client);
        anyhow::Ok(())
    }

    pub fn publish(&mut self, bytes: &[u8]) -> Result<u32> {
        self.client
        .as_mut()
            .unwrap()
            .publish("", QoS::AtMostOnce, false, bytes)
            .map_err(|err| {
                anyhow::anyhow!("publish message to queue was failed!. {}", err)
            })
    }
}