/* Heltec Automation LoRaWAN communication example
 *
 * Function:
 * 1. Upload node data to the server using the standard LoRaWAN protocol.
 *
 * Description:
 * 1. Communicate using LoRaWAN protocol.
 *
 * HelTec AutoMation, Chengdu, China
 * 成都惠利特自动化科技有限公司
 * www.heltec.org
 *
 * */

#define DEBUG_MODE 0

#if DEBUG_MODE
#define DEBUG_PRINT(x) Serial.print(x)
#define DEBUG_PRINTLN(x) Serial.println(x)
#else
#define DEBUG_PRINT(x)
#define DEBUG_PRINTLN(x)
#endif

#include "LoRaWan_APP.h"
#include <EEPROM.h>

#define APP_EUI_ADDRESS 0
#define APP_KEY_ADDRESS 8

/* OTAA para*/
uint8_t devEui[] = {0x70, 0xB3, 0xD5, 0x7E, 0xD0, 0x06, 0x53, 0xC8};
uint8_t defaultAppEui[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
uint8_t defaultAppKey[16] = {0x74, 0xD6, 0x6E, 0x63, 0x45, 0x82, 0x48, 0x27, 0xFE, 0xC5, 0xB7, 0x70, 0xBA, 0x2B, 0x50, 0x45};
// uint8_t appEui[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
// uint8_t appKey[] = {0x74, 0xD6, 0x6E, 0x63, 0x45, 0x82, 0x48, 0x27, 0xFE, 0xC5, 0xB7, 0x70, 0xBA, 0x2B, 0x50, 0x45};
uint8_t appEui[8];
uint8_t appKey[16];

/* ABP para*/
uint8_t nwkSKey[] = {0x15, 0xb1, 0xd0, 0xef, 0xa4, 0x63, 0xdf, 0xbe, 0x3d, 0x11, 0x18, 0x1e, 0x1e, 0xc7, 0xda, 0x85};
uint8_t appSKey[] = {0xd7, 0x2c, 0x78, 0x75, 0x8c, 0xdc, 0xca, 0xbf, 0x55, 0xee, 0x4a, 0x77, 0x8d, 0x16, 0xef, 0x67};
uint32_t devAddr = (uint32_t)0x007e6ae1;

/*LoraWan channelsmask, default channels 0-7*/
uint16_t userChannelsMask[6] = {0x00FF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000};

/*LoraWan region, select in arduino IDE tools*/
LoRaMacRegion_t loraWanRegion = ACTIVE_REGION;

/*LoraWan Class, Class A and Class C are supported*/
DeviceClass_t loraWanClass = CLASS_C;

/*the application data transmission duty cycle.  value in [ms].*/
uint32_t appTxDutyCycle = 15000;

/*OTAA or ABP*/
bool overTheAirActivation = true;

/*ADR enable*/
bool loraWanAdr = true;

/* Indicates if the node is sending confirmed or unconfirmed messages */
bool isTxConfirmed = true;

/* Application port */
uint8_t appPort = 2;
/*!
 * Number of trials to transmit the frame, if the LoRaMAC layer did not
 * receive an acknowledgment. The MAC performs a datarate adaptation,
 * according to the LoRaWAN Specification V1.0.2, chapter 18.4, according
 * to the following table:
 *
 * Transmission nb | Data Rate
 * ----------------|-----------
 * 1 (first)       | DR
 * 2               | DR
 * 3               | max(DR-1,0)
 * 4               | max(DR-1,0)
 * 5               | max(DR-2,0)
 * 6               | max(DR-2,0)
 * 7               | max(DR-3,0)
 * 8               | max(DR-3,0)
 *
 * Note, that if NbTrials is set to 1 or 2, the MAC will not decrease
 * the datarate, in case the LoRaMAC layer did not receive an acknowledgment
 */
uint8_t confirmedNbTrials = 4;

void device_restart()
{
    DEBUG_PRINTLN("Restarting device...");
    delay(1000);
    ESP.restart();
}

/* Prepares the payload of the frame */
static void prepareTxFrame(uint8_t port)
{
    /*appData size is LORAWAN_APP_DATA_MAX_SIZE which is defined in "commissioning.h".
     *appDataSize max value is LORAWAN_APP_DATA_MAX_SIZE.
     *if enabled AT, don't modify LORAWAN_APP_DATA_MAX_SIZE, it may cause system hanging or failure.
     *if disabled AT, LORAWAN_APP_DATA_MAX_SIZE can be modified, the max value is reference to lorawan region and SF.
     *for example, if use REGION_CN470,
     *the max value for different DR can be found in MaxPayloadOfDatarateCN470 refer to DataratesCN470 and BandwidthsCN470 in "RegionCN470.h".
     */

    if (Serial.available() > 0)
    {
        String incomingData = Serial.readStringUntil('\n'); // Read until newline
        DEBUG_PRINT("Received message: ");
        DEBUG_PRINTLN(incomingData);

        unsigned char payload[32];
        incomingData.getBytes(payload, incomingData.length() + 1); // Convert String to byte array

        uint8_t command = payload[0];
        String data = incomingData.substring(1); // Extract data after the command byte

        DEBUG_PRINTLN("Command byte: " + String(command));
        DEBUG_PRINTLN("Data: " + data);
        // The payload structure is defined as follows:
        // Byte 0 [command byte] -> '1' for sending data, '2' for restart device, '3' for change app EUI, '4' for change app key

        switch (command)
        {
            // Note: The command byte is expected to be a character representing a number, so we compare it with the ASCII values of '1', '2', '3', and '4'.
        case 49:
            DEBUG_PRINTLN("Command: Send Data");
            appDataSize = data.length();

            memcpy(appData, payload + 1, appDataSize);
            DEBUG_PRINTLN("Send Data");
            LoRaWAN.send();
            break;
        case 50:
            DEBUG_PRINTLN("Command: Restart Device");
            device_restart();
            break;
        case 51:
            DEBUG_PRINTLN("Command: Change App EUI");
            if (data.length() != 8)
            {
                DEBUG_PRINTLN("Invalid App EUI length. Expected 8 characters.");
                break;
            }
            // Replace appEui in EEPROM
            for (int i = 0; i < 8; i++)
            {
                EEPROM.write(APP_EUI_ADDRESS + i, data[i]);
            }
            EEPROM.commit();
            DEBUG_PRINTLN("App EUI updated in EEPROM");
            // Restart device to apply new appEui
            device_restart();
            break;
        case 52:
            DEBUG_PRINTLN("Command: Change App Key");
            if (data.length() != 16)
            {
                DEBUG_PRINTLN("Invalid App Key length. Expected 16 characters.");
                break;
            }
            // Replace appKey in EEPROM
            for (int i = 0; i < 16; i++)
            {
                EEPROM.write(APP_KEY_ADDRESS + i, data[i]);
            }
            EEPROM.commit();
            DEBUG_PRINTLN("App Key updated in EEPROM");
            // Restart device to apply new appKey
            device_restart();

            break;
        default:
            DEBUG_PRINTLN("Unknown command");
            break;
        }
    }
    else
    {
        memset(appData, 0, sizeof(appData));
    }
}

// if true, next uplink will add MOTE_MAC_DEVICE_TIME_REQ

void setup()
{
    EEPROM.begin(32); // Initialize EEPROM with a size of 32 bytes
    // Read appEui and appKey from EEPROM
    for (int i = 0; i < 8; i++)
    {
        appEui[i] = EEPROM.read(APP_EUI_ADDRESS + i);
    }
    for (int i = 0; i < 16; i++)
    {
        appKey[i] = EEPROM.read(APP_KEY_ADDRESS + i);
    }

    // Set default appEui and appKey if EEPROM is empty (all bytes are 0xFF)
    if (appEui[0] == 0xFF && appEui[1] == 0xFF && appEui[2] == 0xFF && appEui[3] == 0xFF &&
        appEui[4] == 0xFF && appEui[5] == 0xFF && appEui[6] == 0xFF && appEui[7] == 0xFF)
    {

        memcpy(appEui, defaultAppEui, sizeof(defaultAppEui));
        for (int i = 0; i < 8; i++)
        {
            EEPROM.write(APP_EUI_ADDRESS + i, appEui[i]);
        }
        EEPROM.commit();
    }

    if (appKey[0] == 0xFF && appKey[1] == 0xFF && appKey[2] == 0xFF && appKey[3] == 0xFF &&
        appKey[4] == 0xFF && appKey[5] == 0xFF && appKey[6] == 0xFF && appKey[7] == 0xFF &&
        appKey[8] == 0xFF && appKey[9] == 0xFF && appKey[10] == 0xFF && appKey[11] == 0xFF &&
        appKey[12] == 0xFF && appKey[13] == 0xFF && appKey[14] == 0xFF && appKey[15] == 0xFF)
    {

        memcpy(appKey, defaultAppKey, sizeof(defaultAppKey));
        for (int i = 0; i < 16; i++)
        {
            EEPROM.write(APP_KEY_ADDRESS + i, appKey[i]);
        }
        EEPROM.commit();
    }

    Serial.begin(115200);
    while (!Serial)
        ;

    DEBUG_PRINTLN("APP EUI: ");
    for (int i = 0; i < 8; i++)
    {
        DEBUG_PRINT(appEui[i]);
        if (i < 7)
            DEBUG_PRINT(":");
    }
    DEBUG_PRINTLN();

    DEBUG_PRINTLN("APP Key: ");
    for (int i = 0; i < 16; i++)
    {
        DEBUG_PRINT(appKey[i]);
        if (i < 15)
            DEBUG_PRINT(":");
    }
    DEBUG_PRINTLN();

    Mcu.begin(HELTEC_BOARD, SLOW_CLK_TPYE);
    DEBUG_PRINTLN("HELTEC CT-R2 ready");
}

void loop()
{
    switch (deviceState)
    {
    case DEVICE_STATE_INIT:
    {
        DEBUG_PRINTLN("Device INIT");
#if (LORAWAN_DEVEUI_AUTO)
        LoRaWAN.generateDeveuiByChipID();
#endif
        LoRaWAN.init(loraWanClass, loraWanRegion);
        // both set join DR and DR when ADR off
        LoRaWAN.setDefaultDR(3);
        break;
    }
    case DEVICE_STATE_JOIN:
    {
        DEBUG_PRINTLN("Join Network");
        LoRaWAN.join();
        break;
    }
    case DEVICE_STATE_SEND:
    {

        prepareTxFrame(appPort);

        deviceState = DEVICE_STATE_CYCLE;
        break;
    }
    case DEVICE_STATE_CYCLE:
    {
        DEBUG_PRINTLN("Schedule packet transmission");
        // Schedule next packet transmission
        // txDutyCycleTime = appTxDutyCycle + randr(-APP_TX_DUTYCYCLE_RND, APP_TX_DUTYCYCLE_RND);
        txDutyCycleTime = appTxDutyCycle;
        
        LoRaWAN.cycle(txDutyCycleTime);
        deviceState = DEVICE_STATE_SLEEP;
        break;
    }
    case DEVICE_STATE_SLEEP:
    {
        // DEBUG_PRINTLN("Device Sleep");
        LoRaWAN.sleep(loraWanClass);
        break;
    }
    default:
    {
        deviceState = DEVICE_STATE_INIT;
        break;
    }
    }
}