/// © MiroZ 2024

#ifndef __MQTT_T__
#define __MQTT_T__

#include <stdint.h>
#include <esp_log.h>
#include <WiFiClientSecure.h>
#include <PubSubClient.h>
#include <functional>

#include "mqtt_client.h"

static const char *TAG = "MQTTS";

extern const uint8_t server_cert[] asm("_binary_eventgrid_azure_pem_start");
extern const uint8_t client_cert[] asm("_binary_client1_authn_ID_pem_start");
extern const uint8_t client_key[] asm("_binary_client1_authn_ID_key_start");

extern const uint8_t test_cert[] asm("_binary_mosquitto_org_crt_start");
extern const uint8_t test_client_cert[] asm("_binary_client_crt_start");
extern const uint8_t test_client_key[] asm("_binary_client_key_start");

esp_mqtt_client_handle_t client;

using namespace std::placeholders;

class Mqtt
{
#if 0
public:

static void log_error_if_nonzero(const char *message, int error_code)
{
    if (error_code != 0) {
        ESP_LOGE(TAG, "Last error %s: 0x%x", message, error_code);
    }
}


static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
{
    ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%d", base, event_id);
    esp_mqtt_event_handle_t event = (esp_mqtt_event_handle_t)event_data;
    esp_mqtt_client_handle_t client = event->client;
    int msg_id;
    switch ((esp_mqtt_event_id_t)event_id) {
    case MQTT_EVENT_CONNECTED:
        ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED");
//        msg_id = esp_mqtt_client_subscribe(client, "wellnuotopics/topic1", 0);
//        ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id);

        // msg_id = esp_mqtt_client_subscribe(client, "/topic/qos1", 1);
        // ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id);

        // msg_id = esp_mqtt_client_unsubscribe(client, "/topic/qos1");
        // ESP_LOGI(TAG, "sent unsubscribe successful, msg_id=%d", msg_id);
        break;
    case MQTT_EVENT_DISCONNECTED:
        ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED");
        break;

    case MQTT_EVENT_SUBSCRIBED:
        ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);
        msg_id = esp_mqtt_client_publish(client, "wellnuotopics/topic1", "0", 0, 0, 0);
        ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id);
        break;
    case MQTT_EVENT_UNSUBSCRIBED:
        ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id);
        break;
    case MQTT_EVENT_PUBLISHED:
        ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id);
        break;
    case MQTT_EVENT_DATA:
        ESP_LOGI(TAG, "MQTT_EVENT_DATA");
        printf("TOPIC=%.*s\r\n", event->topic_len, event->topic);
        printf("DATA=%.*s\r\n", event->data_len, event->data);
        break;
    case MQTT_EVENT_ERROR:
        ESP_LOGI(TAG, "MQTT_EVENT_ERROR");
        if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) {
            log_error_if_nonzero("reported from esp-tls", event->error_handle->esp_tls_last_esp_err);
            log_error_if_nonzero("reported from tls stack", event->error_handle->esp_tls_stack_err);
            log_error_if_nonzero("captured as transport's socket errno",  event->error_handle->esp_transport_sock_errno);
            ESP_LOGI(TAG, "Last errno string (%s)", strerror(event->error_handle->esp_transport_sock_errno));

        }
        break;
    default:
        ESP_LOGI(TAG, "Other event id:%d", event->event_id);
        break;
    }
}


static void mqtt_app_start(void)
{
    esp_mqtt_client_config_t mqtt_cfg;
    memset(&mqtt_cfg, 0, sizeof(mqtt_cfg));

    // test server
    // mqtt_cfg.uri = "mqtts://test.mosquitto.org:8884";
    // mqtt_cfg.cert_pem = (const char *)test_cert;
    // mqtt_cfg.client_key_pem =  (const char *)test_client_key;
    // mqtt_cfg.client_cert_pem = (const char *)test_client_cert;
    mqtt_cfg.uri = "mqtts://mqtt-dev-server.westus2-1.ts.eventgrid.azure.net:8883";
    mqtt_cfg.username = "client1-authn-ID";
    mqtt_cfg.client_id = "client1-esp";
    mqtt_cfg.cert_pem = (const char *)server_cert;
    mqtt_cfg.client_key_pem =  (const char *)client_key;
    mqtt_cfg.client_cert_pem = (const char *)client_cert;


    ESP_LOGI(TAG, "[APP] Free memory: %d bytes", esp_get_free_heap_size());
    client = esp_mqtt_client_init(&mqtt_cfg);
    /* The last argument may be used to pass data to the event handler, in this example mqtt_event_handler */
    esp_mqtt_client_register_event(client, (esp_mqtt_event_id_t)ESP_EVENT_ANY_ID, mqtt_event_handler, NULL);
    esp_mqtt_client_start(client);
}

static void test()
{
    mqtt_app_start();

    while(true)
    {
        delay(5000);
        int val = esp_mqtt_client_publish (client, "wellnuotopics/topic1", "mytestdata", 10, 0, false);
        ESP_LOGI(TAG, "publish: %d", val);
    }
}
#endif
public:
#if 1
	void callback(char* topic, byte* payload, unsigned int length) {
		printf("Message arrived in topic: %s\n", topic);
		printf("Message:'");
		for (int i = 0; i < length; i++) {
			printf("%c", (char)payload[i]);
		}
        printf("'\n");
		printf("-----------------------\n");
	}

#include "time.h"


    void printLocalTime()
    {
        struct tm timeinfo;
        char buf[48];
        if(!getLocalTime(&timeinfo)){
            printf("Failed to obtain time\n");
            return;
        }
        strftime(buf, 26, "%Y-%m-%d %H:%M:%S", &timeinfo);
        ESP_LOGI(TAG, "%s", buf);
    }

	void test()
	{
		const char* mqtt_broker = "mqtt-dev-server.westus2-1.ts.eventgrid.azure.net";
		const char* topic = "wellnuotopics/topic1";
		const int mqtt_port = 8883 ;

		WiFiClientSecure espClient;
		PubSubClient client(espClient);

		espClient.setCACert((const char*)server_cert);
		espClient.setCertificate((const char *)client_cert);  // for client verification
		espClient.setPrivateKey((const char *)client_key);    // for client verification

		client.setServer(mqtt_broker, mqtt_port);
  		client.setCallback(std::bind(&Mqtt::callback, this, _1, _2, _3));

        printLocalTime();

		while (!client.connected()) 
		{
			String client_id = "esp32-client";
			client_id += String(WiFi.macAddress());
		    // Print the Name and the id of the esp32 controller
			ESP_LOGI("", "connecting client %s mqtt broker...", client_id.c_str());
			if (client.connect("Esp32 client", "client1-authn-ID", NULL)) {
				ESP_LOGI("", "Public emqx mqtt broker connected");
			} else {
				ESP_LOGE("", "failed with state %d", client.state());
			    delay(5000);
			}
		}
        
        bool val;

        // val = client.subscribe(topic);
        // if(val)
        //     ESP_LOGI(TAG, "sub ok");
        // else
        //     ESP_LOGI(TAG, "sub failed");
        // Publish and Subscribe
		
        // val = client.publish(topic, "Hi I'm ESP32 ^^");
        // if(val)
        //     ESP_LOGI(TAG, "publish ok");
        // else
        //     ESP_LOGI(TAG, "publish failed");

        int n = 0;

		while(true)
		{
//			client.loop();
			delay(2500);

            val = client.publish(topic, "Hi I'm ESP32 ^^");
            if(val)
                ESP_LOGI(TAG, "%d publish ok", n);
            else
                ESP_LOGE(TAG, "%d publish failed", n);

            n++;
		}

	}
#endif
};

#endif