#ifndef COMMUNICATION_HANDLER_H
#define COMMUNICATION_HANDLER_H

#include "client_handler.h"
#include <esp_now.h>
#include <esp_wifi.h>
#include <freertos/FreeRTOS.h>
#include <freertos/queue.h>
#include <freertos/task.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>

#define BROADCAST_INTERVAL_MS 500

#define CLIENT_TIMEOUT_MS 5000 // 5 Sekunden Timeout
#define CHECK_INTERVAL_MS 1000 // Jede Sekunde überprüfen
static uint8_t broadcast_address[ESP_NOW_ETH_ALEN] = {0xFF, 0xFF, 0xFF,
                                                      0xFF, 0xFF, 0xFF};
#define IS_BROADCAST_ADDR(addr)                                                \
  (memcmp(addr, broadcast_address, ESP_NOW_ETH_ALEN) == 0)

#define MAC2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
#define MACSTR "%02X:%02X:%02X:%02X:%02X:%02X"

#define MESSAGE_QUEUE_SIZE 10

typedef enum {
  OTA_PREP_UPGRADE,
  OTA_SEND_PAYLOAD,
  OTA_WRITE_UPDATE_BUFFER,
  OTA_SEND_MISSING,
  OTA_UPDATE_INFO,
  OTA_END_UPGRADE,
  StatusPage,
  GetStatusPage,
  ConfigPage,
  PingPage,
  BroadCastPage,
  RegisterPage,
} CommandPages;

typedef struct __attribute__((packed)) {

} OTA_PREP_UPGRADE_Payload;

typedef struct __attribute__((packed)) {
} OTA_SEND_PAYLOAD_Payload;
typedef struct __attribute__((packed)) {
} OTA_WRITE_UPDATE_BUFFER_Payload;
typedef struct __attribute__((packed)) {
} OTA_SEND_MISSING_Payload;
typedef struct __attribute__((packed)) {
} OTA_UPDATE_INFO_Payload;
typedef struct __attribute__((packed)) {
} OTA_END_UPGRADE_Payload;

typedef struct __attribute__((packed)) {
  uint16_t version; // software version
  uint8_t runningPartition;
  uint8_t status;
  uint32_t uptime;
} StatusPayload;

typedef struct __attribute__((packed)) {
} GetStatusPayload;

typedef struct __attribute__((packed)) {
  uint8_t timeslot;
} ConfigPayload;

typedef struct __attribute__((packed)) {
  uint32_t timestamp;
} PingPayload;

typedef struct __attribute__((packed)) {
} BroadCastPayload;

typedef struct __attribute__((packed)) {
  bool familierClient;
} RegisterPayload;

// TODO: Check checksum fields
typedef struct __attribute__((packed)) {
  uint16_t length;  // length of complete firmware
  uint8_t checksum; // checksum of firmware
} FirmwarePrepPayload;

// TODO: Check checksum fields
typedef struct __attribute__((packed)) {
  uint8_t length;
  uint8_t checksum;
  uint32_t address;
  uint8_t payload[240]; // TODO: need a way to figure out a safe value for this
} FirmwarePayload;

typedef union __attribute__((packed)) {
  StatusPayload status_payload;
  ConfigPayload config_payload;
  PingPayload ping_payload;
  BroadCastPayload broadcast_payload;
  RegisterPayload register_payload;
  FirmwarePrepPayload firmware_prep_payload;
  FirmwarePayload firmware_payload;
} PayloadUnion;

typedef struct __attribute__((packed)) {
  uint16_t version; // protcol version
  CommandPages commandPage;
  uint16_t length;
  PayloadUnion payload;
} BaseMessage;

static_assert(sizeof(BaseMessage) <= 255,
              "BaseMessage darf nicht größer als 255 sein");

typedef void (*ESP_RegisterFunctionCallback)(
    const esp_now_recv_info_t *esp_now_info, const uint8_t *data, int data_len);
typedef void (*ESP_RegisterTaskCallback)(
    const esp_now_recv_info_t *esp_now_info, const uint8_t *data, int data_len);

struct ESP_RegisterdFunction {
  CommandPages MSGID;
  ESP_RegisterFunctionCallback callback;
};

struct ESP_RegisterdTask {
  CommandPages MSGID;
  ESP_RegisterTaskCallback task;
};

struct ESP_MessageBroker {
  struct ESP_RegisterdFunction FunctionList[64];
  uint8_t num_direct_callbacks;
  struct ESP_RegisterdTask TaskList[64];
  uint8_t num_task_callbacks;
};

typedef struct {
  QueueHandle_t message_queue;
} ESP_MessageBrokerTaskParams_t;

typedef struct {
  esp_now_recv_info_t esp_now_info;
  const uint8_t *data;
  int data_len;
} ESPNOW_MessageInfo;

void ESP_InitMessageBroker(QueueHandle_t msg_queue_handle);
void ESP_RegisterFunction(CommandPages command,
                          ESP_RegisterFunctionCallback callback);
void ESP_RegisterTask(CommandPages command, ESP_RegisterTaskCallback callback);
void ESP_MessageBrokerTask(void *param);

void ESPNOW_RegisterMasterCallbacks();


int init_com(ClientList *clients, uint8_t wifi_channel);
int getNextFreeClientId();
int add_peer(uint8_t *macAddr);
BaseMessage MessageBuilder(CommandPages commandPage, PayloadUnion payload,
                           size_t payload_size);

void master_broadcast_task(void *param);
void master_ping_task(void *param);
void master_broadcast_ping(void *param);
void master_receive_callback(const esp_now_recv_info_t *esp_now_info,
                             const uint8_t *data, int data_len);

void client_receive_callback(const esp_now_recv_info_t *esp_now_info,
                             const uint8_t *data, int data_len);
void client_data_sending_task(void *param);
void client_send_random_data_task(void *param);
void client_monitor_task(void *pvParameters);

#endif