#include "esp_log.h"
#include "esp_now.h"
#include "esp_timer.h"
#include "freertos/idf_additions.h"

#include "client_handler.h"
#include "communication_handler.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>

static const char *TAG = "ALOX - COM";

QueueHandle_t messageQueue = NULL; // Warteschlange für empfangene Nachrichten
bool hasMaster = false;
static ClientList *esp_client_list;

#define MAC_STRING_BUFFER_SIZE 18

void init_com(ClientList *clients) {
  // Initialisiere die Kommunikations-Warteschlange
  messageQueue = xQueueCreate(MESSAGE_QUEUE_SIZE, sizeof(BaseMessage));
  if (messageQueue == NULL) {
    ESP_LOGE(TAG, "Message queue creation failed");
  }

  esp_client_list = clients;
  hasMaster = false;
}

void add_peer(uint8_t *macAddr) {
  esp_now_peer_info_t peerInfo = {
      .channel =
          0, // Standardkanal, sollte uit den anderen Geräten übereinstimmen
      .ifidx = ESP_IF_WIFI_STA,
      .encrypt = false, // Keine Verschlüsselung (kann geändert werden)
  };
  memcpy(peerInfo.peer_addr, macAddr, ESP_NOW_ETH_ALEN);

  esp_err_t result = esp_now_add_peer(&peerInfo);
  if (result == ESP_OK) {
    ESP_LOGI(TAG, "Peer added: %02X:%02X:%02X:%02X:%02X:%02X",
             peerInfo.peer_addr[0], peerInfo.peer_addr[1],
             peerInfo.peer_addr[2], peerInfo.peer_addr[3],
             peerInfo.peer_addr[4], peerInfo.peer_addr[5]);

    if (!IS_BROADCAST_ADDR(macAddr)) {
      int ret = add_client(esp_client_list, peerInfo.peer_addr);
      if (ret < 0) {
        ESP_LOGE(TAG, "Client could not be added to client handler, removing "
                      "it from esp now client list!");
        esp_now_del_peer(peerInfo.peer_addr);
      }
      ESP_LOGI(TAG, "New client added.");
    }
  } else if (result == ESP_ERR_ESPNOW_EXIST) {
    ESP_LOGW(TAG, "Peer already exists.");
    int id = get_client_id(esp_client_list, peerInfo.peer_addr);
    if (id >= 0) {
      ESP_LOGI(TAG, "Client found again, welcome back!");
      esp_client_list->Clients[id].isAvailable = true;
    }
  } else {
    ESP_LOGE(TAG, "Failed to add peer: %s", esp_err_to_name(result));
  }
}

void MACtoString(const uint8_t *macAddr, char *outputBuffer) {
  sprintf(outputBuffer, "%02X:%02X:%02X:%02X:%02X:%02X", macAddr[0], macAddr[1],
          macAddr[2], macAddr[3], macAddr[4], macAddr[5]);
}

BaseMessage MessageBuilder(CommandPages commandPage, PayloadUnion payload,
                           size_t payload_size) {
  BaseMessage message;

  // Initialisierung der BaseMessage
  message.commandPage = commandPage;
  message.version = 1;
  message.length = (uint16_t)payload_size;

  // Kopieren des Payloads in die Union
  memset(&message.payload, 0, sizeof(message.payload)); // Sicherheitsmaßnahme
  memcpy(&message.payload, &payload, payload_size);

  return message;
}

void master_broadcast_task(void *param) {
  while (1) {
    BroadCastPayload payload = {};

    BaseMessage message = MessageBuilder(
        BroadCastPage, *(PayloadUnion *)&payload, sizeof(payload));

    ESP_ERROR_CHECK(esp_now_send(broadcast_address, (uint8_t *)&message,
                                 sizeof(BaseMessage)));
    ESP_LOGI(TAG, "Broadcast Message sent");
    vTaskDelay(pdMS_TO_TICKS(5000));
  }
}

void master_broadcast_ping(void *param) {
  while (1) {
    // BroadCastPayload payload = {};
    PingPayload payload = {};
    payload.timestamp = esp_timer_get_time();
    BaseMessage message =
        MessageBuilder(PingPage, *(PayloadUnion *)&payload, sizeof(payload));
    ESP_ERROR_CHECK(esp_now_send(broadcast_address, (uint8_t *)&message,
                                 sizeof(BaseMessage)));
    ESP_LOGI(TAG, "Broadcast PING Message sent");
    vTaskDelay(pdMS_TO_TICKS(2500));
  }
}

void master_ping_task(void *param) {
  char macBuffer[MAC_STRING_BUFFER_SIZE];
  while (1) {
    for (size_t i = 0; i < MAX_CLIENTS; i++) {
      if (esp_client_list->Clients[i].isAvailable) {
        MACtoString(esp_client_list->Clients[i].macAddr, macBuffer);
        ESP_LOGI(TAG, "SEND PING TO %zu: %s", i, macBuffer);
        PingPayload payload = {};
        payload.timestamp = esp_timer_get_time();
        BaseMessage message = MessageBuilder(
            PingPage, *(PayloadUnion *)&payload, sizeof(payload));
        esp_now_send(esp_client_list->Clients[i].macAddr, (uint8_t *)&message,
                     sizeof(BaseMessage));
        ESP_LOGI(TAG, "SENDING PING!!!!");
      }
    }
    vTaskDelay(pdMS_TO_TICKS(1000));
  }
}

void master_receive_callback(const esp_now_recv_info_t *esp_now_info,
                             const uint8_t *data, int data_len) {
  char macBuffer[MAC_STRING_BUFFER_SIZE];
  ESP_LOGI(TAG, "MASTER GOT MESSAGE");

  const BaseMessage *message = (const BaseMessage *)data;
  switch (message->commandPage) {
  case StatusPage:
    ESP_LOGI(TAG, "GOT STATUS MESSAGE");
    break;
  case PingPage:
    ESP_LOGI(TAG, "GOT PING MESSAGE");
    uint32_t currentTime = esp_timer_get_time();
    uint32_t diff = currentTime - message->payload.ping_payload.timestamp;

    ESP_LOGI(TAG, "Start: %lu, End: %lu, Diff: %lu, Ping: %lu",
             message->payload.ping_payload.timestamp, currentTime, diff,
             diff / 1000); // ping in ms

    int id = get_client_id(esp_client_list, esp_now_info->src_addr);
    if (id >= 0) {
      esp_client_list->Clients[id].lastSuccessfullPing = xTaskGetTickCount();
      esp_client_list->Clients[id].lastPing = (diff / 1000);
      MACtoString(esp_now_info->src_addr, macBuffer);
      ESP_LOGI(TAG, "Updated client %d: %s last ping time to %lu", id,
               macBuffer, esp_client_list->Clients[id].lastSuccessfullPing);
    }
    break;
  case BroadCastPage:
    ESP_LOGI(TAG, "MASTER SHOULD NOT GET BROADCAST MESSAGE, is there another "
                  "master calling?");
    break;
  case RegisterPage:
    ESP_LOGI(TAG, "WILL REGISTER DEVICE");
    esp_now_peer_info_t checkPeerInfo;
    esp_err_t checkPeer =
        esp_now_get_peer(esp_now_info->src_addr, &checkPeerInfo);
    switch (checkPeer) {
    case (ESP_OK):
      ESP_LOGI(TAG, "CLIENT BEKANNT");
      int id = get_client_id(esp_client_list, esp_now_info->src_addr);
      esp_client_list->Clients[id].isAvailable = true;
      esp_client_list->Clients[id].lastSuccessfullPing = xTaskGetTickCount();
      ESP_LOGI(TAG, "Updated client %d last ping time to %lu", id,
               esp_client_list->Clients[id].lastSuccessfullPing);
      break;
    case (ESP_ERR_ESPNOW_NOT_INIT):
      ESP_LOGI(TAG, "Not initalised");
      break;
    case (ESP_ERR_ESPNOW_ARG):
      ESP_LOGI(TAG, "ESP ERR ESPNOW_ARG");
      break;
    case (ESP_ERR_ESPNOW_NOT_FOUND):
      ESP_LOGI(TAG, "CLIENT WIRD IN DIE LISTE AUFGENOMMEN");
      add_peer(esp_now_info->src_addr);
      break;
    default:
      ESP_LOGI(TAG, "Unknown Message %i", checkPeer);
    }
    break;
  default:
    ESP_LOGI(TAG, "Unknown CommandPage %i", message->commandPage);
    break;
  }
}
void client_receive_callback(const esp_now_recv_info_t *esp_now_info,
                             const uint8_t *data, int data_len) {
  char macBuffer[MAC_STRING_BUFFER_SIZE];
  ESP_LOGI(TAG, "SLAVE GOT MESSAGE");
  MACtoString(esp_now_info->src_addr, macBuffer);
  ESP_LOGI(TAG, "Received message from: %s", macBuffer);
  ESP_LOGI(TAG, "Message: %.*s", data_len, data);

  BaseMessage replyMessage = {};

  const BaseMessage *message = (const BaseMessage *)data;
  switch (message->commandPage) {
  case StatusPage:
    ESP_LOGI(TAG, "GOT STATUS MESSAGE");
    break;
  case PingPage:
    ESP_LOGI(TAG, "GOT PING MESSAGE");
    replyMessage = MessageBuilder(PingPage, *(PayloadUnion *)&message->payload,
                                  sizeof(message->payload));
    ESP_ERROR_CHECK(esp_now_send(
        esp_now_info->src_addr, (uint8_t *)&replyMessage, sizeof(BaseMessage)));
    break;
  case BroadCastPage:
    ESP_LOGI(TAG, "GOT BROADCAST MESSAGE");
    if (!hasMaster) {
      if (IS_BROADCAST_ADDR(esp_now_info->des_addr)) {
        ESP_LOGI(TAG,
                 "GOT BROADCAST MESSAGE ATTEMPTING TO REGISTER TO MASTER!");
        add_peer(esp_now_info->src_addr);
        replyMessage =
            MessageBuilder(RegisterPage, *(PayloadUnion *)&message->payload,
                           sizeof(message->payload));
        ESP_ERROR_CHECK(esp_now_send(esp_now_info->src_addr,
                                     (uint8_t *)&replyMessage,
                                     sizeof(BaseMessage)));
        hasMaster = true;
      }
    }
    break;
  case RegisterPage:
    break;
  default:
    ESP_LOGI(TAG, "GOT UNKONW MESSAGE");
    break;
  }
}

void client_data_sending_task(void *param) {
  while (1) {
    const char *dataToSend = "DATA:42";
    ESP_LOGI(TAG, "SEND DATA");
    esp_now_send(NULL, (uint8_t *)dataToSend,
                 strlen(dataToSend)); // Sende Daten an Master
    vTaskDelay(pdMS_TO_TICKS(5000));
  }
}

void client_monitor_task(void *pvParameters) {
  char macBuffer[MAC_STRING_BUFFER_SIZE];
  TickType_t timeout_ticks =
      pdMS_TO_TICKS(CLIENT_TIMEOUT_MS); // Timeout in Ticks
  TickType_t interval_ticks =
      pdMS_TO_TICKS(CHECK_INTERVAL_MS); // Prüfintervall in Ticks

  while (1) {
    TickType_t now = xTaskGetTickCount(); // Aktuelle Zeit in Ticks

    for (int i = 0; i < MAX_CLIENTS; i++) {
      if (esp_client_list->Clients[i].isAvailable) {
        TickType_t time_diff =
            now - esp_client_list->Clients[i].lastSuccessfullPing;

        // Prüfen, ob der Client als "nicht verfügbar" markiert werden soll
        if (time_diff > timeout_ticks) {
          esp_client_list->Clients[i].isAvailable = false;
          MACtoString(esp_client_list->Clients[i].macAddr, macBuffer);
          ESP_LOGW(TAG, "Client %d (MAC: %s) is unavailable", macBuffer);
        }
      }
    }

    // Task für das Prüfintervall anhalten
    vTaskDelay(interval_ticks);
  }
}