#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "esp_timer.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "spi_flash_mmap.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "freertos/event_groups.h"
#include "esp_log.h"
#include "esp_netif.h"
#include <lwip/sockets.h>
#include <lwip/sys.h>
#include <lwip/api.h>
#include <lwip/netdb.h>

#include "metrics.h"
#include "outputs.h"
#include "inputs.h"
#include "safety.h"

static EventGroupHandle_t s_wifi_event_group;

static const char *TAG = "smart-oil-heater-control-system-metrics";

char caHtmlResponse[HTML_RESPONSE_SIZE];
SemaphoreHandle_t xMutexAccessMetricResponse = NULL;
static sMetric aMetrics[METRIC_MAX_COUNT];
static uint16_t u16MetricCounter = 0U;

void taskMetrics(void *pvParameters);
void connect_wifi(void);
httpd_handle_t setup_server(void);
esp_err_t get_metrics_handler(httpd_req_t *req);

void initMetrics(void)
{
    connect_wifi();
    setup_server();

    BaseType_t taskCreated = xTaskCreate(
        taskMetrics,   // Function to implement the task
        "taskMetrics", // Task name
        16384,         // Stack size (in words, not bytes)
        NULL,          // Parameters to the task function (none in this case)
        5,             // Task priority (higher number = higher priority)
        NULL           // Task handle (optional)
    );

    if (taskCreated == pdPASS)
    {
        ESP_LOGI(TAG, "Task created successfully!");
    }
    else
    {
        ESP_LOGE(TAG, "Failed to create task");
    }
}

void taskMetrics(void *pvParameters)
{
    while (1)
    {
        vTaskDelay(1000U / portTICK_PERIOD_MS);

        u16MetricCounter = 0U;

        /*Uptime*/
        strcpy(aMetrics[u16MetricCounter].caMetricName, "uptime_seconds");
        aMetrics[u16MetricCounter].fMetricValue = (esp_timer_get_time() / 1000000U);
        u16MetricCounter++;

        /*Wifi RSSI*/
        wifi_ap_record_t ap;
        esp_wifi_sta_get_ap_info(&ap);
        // printf("WiFi RSSI: %d\n", ap.rssi);
        strcpy(aMetrics[u16MetricCounter].caMetricName, "wifi_rssi");
        aMetrics[u16MetricCounter].fMetricValue = ap.rssi;
        u16MetricCounter++;

        /*Burner State*/
        if (getBurnerState() == ENABLED)
        {
            strcpy(aMetrics[u16MetricCounter].caMetricName, "burner_enabled");
            aMetrics[u16MetricCounter].fMetricValue = 1.0f;
            u16MetricCounter++;
        }
        else
        {
            strcpy(aMetrics[u16MetricCounter].caMetricName, "burner_enabled");
            aMetrics[u16MetricCounter].fMetricValue = 0.0f;
            u16MetricCounter++;
        }

        /*Circulation Pump State*/
        if (getCirculationPumpState() == ENABLED)
        {
            strcpy(aMetrics[u16MetricCounter].caMetricName, "circulation_pump_enabled");
            aMetrics[u16MetricCounter].fMetricValue = 1.0f;
            u16MetricCounter++;
        }
        else
        {
            strcpy(aMetrics[u16MetricCounter].caMetricName, "circulation_pump_enabled");
            aMetrics[u16MetricCounter].fMetricValue = 0.0f;
            u16MetricCounter++;
        }

        /*Burner Error State*/
        if (getBurnerError() == FAULT)
        {
            strcpy(aMetrics[u16MetricCounter].caMetricName, "burner_fault_pending");
            aMetrics[u16MetricCounter].fMetricValue = 1.0f;
            u16MetricCounter++;
        }
        else
        {
            strcpy(aMetrics[u16MetricCounter].caMetricName, "burner_fault_pending");
            aMetrics[u16MetricCounter].fMetricValue = 0.0f;
            u16MetricCounter++;
        }

        /*Chamber Temperature*/
        strcpy(aMetrics[u16MetricCounter].caMetricName, "chamber_temperature");
        aMetrics[u16MetricCounter].fMetricValue = getChamberTemperature().fCurrentValue;
        u16MetricCounter++;

        /*Outdoor Temperature*/
        strcpy(aMetrics[u16MetricCounter].caMetricName, "outdoor_temperature");
        aMetrics[u16MetricCounter].fMetricValue = getOutdoorTemperature().fCurrentValue;
        u16MetricCounter++;

        /*Chamber Temperature*/
        strcpy(aMetrics[u16MetricCounter].caMetricName, "inlet_flow_temperature");
        aMetrics[u16MetricCounter].fMetricValue = getInletFlowTemperature().fCurrentValue;
        u16MetricCounter++;

        /*Chamber Temperature*/
        strcpy(aMetrics[u16MetricCounter].caMetricName, "return_flow_temperature");
        aMetrics[u16MetricCounter].fMetricValue = getReturnFlowTemperature().fCurrentValue;
        u16MetricCounter++;

        /*Chamber Temperature Average 10s*/
        strcpy(aMetrics[u16MetricCounter].caMetricName, "chamber_temperature_avg10");
        aMetrics[u16MetricCounter].fMetricValue = getChamberTemperature().average10s.fValue;
        u16MetricCounter++;

        /*Outdoor Temperature Average 10s*/
        strcpy(aMetrics[u16MetricCounter].caMetricName, "outdoor_temperature_avg10");
        aMetrics[u16MetricCounter].fMetricValue = getOutdoorTemperature().average10s.fValue;
        u16MetricCounter++;

        /*Chamber Temperature Average 10s*/
        strcpy(aMetrics[u16MetricCounter].caMetricName, "inlet_flow_temperature_avg10");
        aMetrics[u16MetricCounter].fMetricValue = getInletFlowTemperature().average10s.fValue;
        u16MetricCounter++;

        /*Chamber Temperature Average 10s*/
        strcpy(aMetrics[u16MetricCounter].caMetricName, "return_flow_temperature_avg10");
        aMetrics[u16MetricCounter].fMetricValue = getReturnFlowTemperature().average10s.fValue;
        u16MetricCounter++;

        /*Chamber Temperature Average 60s*/
        strcpy(aMetrics[u16MetricCounter].caMetricName, "chamber_temperature_avg60");
        aMetrics[u16MetricCounter].fMetricValue = getChamberTemperature().average60s.fValue;
        u16MetricCounter++;

        /*Outdoor Temperature Average 60s*/
        strcpy(aMetrics[u16MetricCounter].caMetricName, "outdoor_temperature_avg60");
        aMetrics[u16MetricCounter].fMetricValue = getOutdoorTemperature().average60s.fValue;
        u16MetricCounter++;

        /*Chamber Temperature Average 60s*/
        strcpy(aMetrics[u16MetricCounter].caMetricName, "inlet_flow_temperature_avg60");
        aMetrics[u16MetricCounter].fMetricValue = getInletFlowTemperature().average60s.fValue;
        u16MetricCounter++;

        /*Chamber Temperature Average 60s*/
        strcpy(aMetrics[u16MetricCounter].caMetricName, "return_flow_temperature_avg60");
        aMetrics[u16MetricCounter].fMetricValue = getReturnFlowTemperature().average60s.fValue;
        u16MetricCounter++;

        /*Sensor status*/
        sSensorSanityCheck aChecks[NUMBER_OF_SENSOR_SANITY_CHECKS];
        getSensorSanityStates(aChecks);
        for (size_t i = 0; i < NUMBER_OF_SENSOR_SANITY_CHECKS; i++)
        {
            strcpy(aMetrics[u16MetricCounter].caMetricName, aChecks[i].name);
            strcat(aMetrics[u16MetricCounter].caMetricName, "_status");
            aMetrics[u16MetricCounter].fMetricValue = aChecks[i].status;
            u16MetricCounter++;
        }

        /*Safety state*/
        strcpy(aMetrics[u16MetricCounter].caMetricName, "safety_state");
        aMetrics[u16MetricCounter].fMetricValue = getSafetyState();
        u16MetricCounter++;

        vSetMetrics(aMetrics, u16MetricCounter);
    }
}

void vSetMetrics(sMetric *paMetrics, uint16_t u16Size)
{

    if (xSemaphoreTakeRecursive(xMutexAccessMetricResponse, pdMS_TO_TICKS(5000)) == pdTRUE)
    {
        memset(caHtmlResponse, 0, strlen(caHtmlResponse));
        for (uint16_t u16Index = 0U; u16Index < u16Size; u16Index++)
        {
            char caValueBuffer[64];
            sprintf(caValueBuffer, " %f", paMetrics[u16Index].fMetricValue);
            // printf("%s\n", caValueBuffer);
            strcat(caHtmlResponse, paMetrics[u16Index].caMetricName);
            strcat(caHtmlResponse, caValueBuffer);
            strcat(caHtmlResponse, "\n");
        }
        xSemaphoreGiveRecursive(xMutexAccessMetricResponse);
    }
    else
    {
        ESP_LOGI(TAG, "[SET] Unable to obtain mutex for metric response");
    }
}

static void event_handler(void *arg, esp_event_base_t event_base,
                          int32_t event_id, void *event_data)
{
    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START)
    {
        esp_wifi_connect();
    }
    else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED)
    {
        esp_wifi_connect();
        ESP_LOGI(TAG, "Retry to connect to the AP");
    }
    else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP)
    {
        ip_event_got_ip_t *event = (ip_event_got_ip_t *)event_data;
        ESP_LOGI(TAG, "Got ip:" IPSTR, IP2STR(&event->ip_info.ip));
        xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
    }
}

void connect_wifi(void)
{
    s_wifi_event_group = xEventGroupCreate();
    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());

    esp_netif_t *my_sta = esp_netif_create_default_wifi_sta();
    esp_netif_dhcpc_stop(my_sta);
    esp_netif_ip_info_t ip_info;
    ip_info.ip.addr = ipaddr_addr(CONFIG_STATIC_IP_ADDR);
    ip_info.gw.addr = ipaddr_addr(CONFIG_STATIC_GATEWAY_IP_ADDR);
    ip_info.netmask.addr = ipaddr_addr(CONFIG_STATIC_IP_NETMASK);
    esp_netif_set_ip_info(my_sta, &ip_info);

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));
    esp_event_handler_instance_t instance_any_id;
    esp_event_handler_instance_t instance_got_ip;
    ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,
                                                        ESP_EVENT_ANY_ID,
                                                        &event_handler,
                                                        NULL,
                                                        &instance_any_id));
    ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT,
                                                        IP_EVENT_STA_GOT_IP,
                                                        &event_handler,
                                                        NULL,
                                                        &instance_got_ip));

    wifi_config_t wifi_config = {
        .sta = {
            .ssid = CONFIG_SSID,
            .password = CONFIG_WIFI_PASSWORD,
            .threshold.authmode = WIFI_AUTH_WPA2_PSK,
        },
    };
    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));

    ESP_ERROR_CHECK(esp_wifi_start());

    ESP_ERROR_CHECK(esp_wifi_set_max_tx_power(78));      // Set max power to 19.5 dBm (78 in units of 0.25 dBm)
    ESP_ERROR_CHECK(esp_wifi_set_ps(WIFI_PS_MIN_MODEM)); // Use power-saving mode

    ESP_LOGI(TAG, "wifi_init_sta finished.");

    EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group,
                                           WIFI_CONNECTED_BIT | WIFI_FAIL_BIT,
                                           pdFALSE,
                                           pdFALSE,
                                           portMAX_DELAY);

    if (bits & WIFI_CONNECTED_BIT)
    {
        ESP_LOGI(TAG, "Connected to ap SSID:%s", CONFIG_SSID);
    }
    else if (bits & WIFI_FAIL_BIT)
    {
        ESP_LOGI(TAG, "Failed to connect to SSID:%s", CONFIG_SSID);
    }
    else
    {
        ESP_LOGE(TAG, "Unexpected event");
    }
    vEventGroupDelete(s_wifi_event_group);
}

esp_err_t get_metrics_handler(httpd_req_t *req)
{
    if (xSemaphoreTakeRecursive(xMutexAccessMetricResponse, pdMS_TO_TICKS(5000)) == pdTRUE)
    {
        esp_err_t err = httpd_resp_send(req, caHtmlResponse, HTTPD_RESP_USE_STRLEN);
        xSemaphoreGiveRecursive(xMutexAccessMetricResponse);
        return err;
    }
    else
    {
        ESP_LOGI(TAG, "[GET] Unable to obtain mutex for metric response");
        return httpd_resp_send(req, 0, 0);
    }
}

httpd_handle_t setup_server(void)
{
    httpd_config_t config = HTTPD_DEFAULT_CONFIG();
    config.server_port = 9100;
    httpd_handle_t server = NULL;

    httpd_uri_t uri_get = {
        .uri = "/metrics",
        .method = HTTP_GET,
        .handler = get_metrics_handler,
        .user_ctx = NULL};

    xMutexAccessMetricResponse = xSemaphoreCreateRecursiveMutex();
    if (xMutexAccessMetricResponse == NULL)
    {
        ESP_LOGE(TAG, "Unable to create mutex for metric response");
    }
    xSemaphoreGiveRecursive(xMutexAccessMetricResponse);

    if (httpd_start(&server, &config) == ESP_OK)
    {
        httpd_register_uri_handler(server, &uri_get);
    }

    return server;
}