/* Mesh Internal Communication Example

   This example code is in the Public Domain (or CC0 licensed, at your option.)

   Unless required by applicable law or agreed to in writing, this
   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
   CONDITIONS OF ANY KIND, either express or implied.
*/
#include <string.h>
#include <inttypes.h>
#include "esp_wifi.h"
#include "esp_mac.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_mesh.h"
#include "esp_mesh_internal.h"
#include "nvs_flash.h"

#include "mesh_netif.h"
#include "main.h"

/*******************************************************
 *                Macros
 *******************************************************/

/*******************************************************
 *                Constants
 *******************************************************/
#define RX_SIZE          (1500)
#define TX_SIZE          (1460)

/*******************************************************
 *                Variable Definitions
 *******************************************************/
static uint8_t tx_buf[TX_SIZE] = { 0, };
static uint8_t rx_buf[RX_SIZE] = { 0, };
static bool is_running = true;
static bool is_mesh_connected = false;
static mesh_addr_t mesh_parent_addr;
static int mesh_layer = -1;
static esp_netif_t *netif_sta = NULL;

//mesh_light_ctl_t light_on = {
//    .cmd = MESH_CONTROL_CMD,
//    .on = 1,
//    .token_id = MESH_TOKEN_ID,
//    .token_value = MESH_TOKEN_VALUE,
//};
//
//mesh_light_ctl_t light_off = {
//    .cmd = MESH_CONTROL_CMD,
//    .on = 0,
//    .token_id = MESH_TOKEN_ID,
//    .token_value = MESH_TOKEN_VALUE,
//};

/*******************************************************
 *                Function Declarations
 *******************************************************/

/*******************************************************
 *                Function Definitions
 *******************************************************/
#if CONFIG_MESH_ROOT == 1
esp_err_t esp_mesh_boardcast_to_nodes(uint8_t *payload, uint16_t payload_len)
{
    int i;
    esp_err_t err;
    mesh_addr_t route_table[CONFIG_MESH_ROUTE_TABLE_SIZE];
    int route_table_size = 0;
    mesh_data_t data;
    data.data = payload;
    data.size = payload_len;
    data.proto = MESH_PROTO_BIN;
    data.tos = MESH_TOS_P2P;

    esp_mesh_get_routing_table((mesh_addr_t *) &route_table,
                                CONFIG_MESH_ROUTE_TABLE_SIZE * 6, &route_table_size);

    printf("route table size -> %d\n", route_table_size);
    for (i = 0; i < route_table_size; i++) {
        err = esp_mesh_send(&route_table[i], &data, MESH_DATA_P2P, NULL, 0);
        if (err) {
            ESP_LOGE(MESH_TAG,
                     "[ROOT-2-UNICAST][L:%d]parent:"MACSTR" to "MACSTR", heap:%" PRId32 "[err:0x%x, proto:%d, tos:%d]",
                     mesh_layer, MAC2STR(mesh_parent_addr.addr),
                     MAC2STR(route_table[i].addr), esp_get_minimum_free_heap_size(),
                     err, data.proto, data.tos);
            return err;
        }
    }
    return ESP_OK;
}
#else
esp_err_t esp_mesh_send_to_root(uint8_t *payload, uint16_t payload_len)
{
    esp_err_t err;
    mesh_data_t data;
    data.data = payload;
    data.size = payload_len;
    data.proto = MESH_PROTO_BIN;
    data.tos = MESH_TOS_P2P;

    err = esp_mesh_send(NULL, &data, MESH_DATA_P2P, NULL, 0);
    if (err) {
        //ESP_LOGE(MESH_TAG,
        //         "[ROOT-2-UNICAST][L:%d]parent:"MACSTR" to "MACSTR", heap:%" PRId32 "[err:0x%x, proto:%d, tos:%d]",
        //         mesh_layer, MAC2STR(mesh_parent_addr.addr),
        //         MAC2STR(route_table[i].addr), esp_get_minimum_free_heap_size(),
        //         err, data.proto, data.tos);
        ESP_LOGE(MESH_TAG, "Error while sending message to root, heap:%" PRId32 "[err:0x%x, proto:%d, tos:%d]",
                            esp_get_minimum_free_heap_size(), err, 
                            data.proto, data.tos);
        return err;
    }

    return ESP_OK;
}
#endif

void esp_mesh_p2p_rx_main(void *arg)
{
    esp_err_t err;
    mesh_addr_t from;
    mesh_data_t data;
    int flag = 0;
    data.data = rx_buf;
    data.size = RX_SIZE;
    is_running = true;

    while (is_running) {
        data.size = RX_SIZE;
        memset(rx_buf, 0, sizeof(rx_buf));
        err = esp_mesh_recv(&from, &data, portMAX_DELAY, &flag, NULL, 0);
        if (err != ESP_OK || !data.size) {
            ESP_LOGE(MESH_TAG, "err:0x%x, size:%d", err, data.size);
            continue;
        }
        //if (data.size > sizeof(packet_t)) {
        //    ESP_LOGE(MESH_TAG, "err:data.size > sizeof(packet_t), size:%d", data.size);
        //    continue;
        //}
        // extract data and process
        //packet_t *packet = calloc(1, sizeof(packet_t));
        //if (!packet) {
        //    ESP_LOGE(MESH_TAG, "failed to allocate memory");
        //    continue;
        //}
        //memcpy(packet, data.data, data.size);
#if CONFIG_MESH_ROOT == 1
        printf("[root] received:%s\n", data.data);
#else
        printf("recvived aaa\n");
        printf("[root] received:%s\n", data.data);
        char result_str[128] = {0};
        int result = mesh_client_callback((char *)data.data, data.size);
        switch (result) {
            case 0:
                strcpy(result_str, "ok\n");
                break;
            case -2:
                strcpy(result_str, "invalid request\n");
                break;
            case -3:
                strcpy(result_str, "locked\n");
                break;
            default:
                strcpy(result_str, "unknown error\n");
                break;
        }
        printf("returned -> %s\n", result_str);
        esp_mesh_send_to_root((uint8_t *)result_str, strlen(result_str)+1);
#endif
        //free(packet);
        //packet = NULL;
        
        // log
        ESP_LOGW(MESH_TAG,
                 "[#RX][L:%d] parent:"MACSTR", receive from "MACSTR", size:%d, heap:%" PRId32 ", flag:%d[err:0x%x, proto:%d, tos:%d]",
                 mesh_layer,
                 MAC2STR(mesh_parent_addr.addr), MAC2STR(from.addr),
                 data.size, esp_get_minimum_free_heap_size(), flag, err, data.proto,
                 data.tos);
    }
    vTaskDelete(NULL);
}