/**
 * Project2B.
 * ESP-Now communication 
 */

#include "WiFi.h"
#include <esp_now.h>

// CONFIG
#define isSender 0                // if is sender, set to 1
#define isEmulatingEsp32 1        // if is physical ESP8266, set to 0
#define isFakeReceiverEnabled 1   // if is emulated ESP32 receiver, set to 1
uint8_t senderMacAddress[] = {0x24, 0x0a, 0xc4, 0x12, 0x45, 0x56};
uint8_t receiverMacAddress[] = {0x24, 0x0a, 0xc4, 0x34, 0x45, 0x56};


// HEADERS
/**
 * Setup the port signal at 115200 bit/s and configure GPIO pins.
 */
void enablePins();

/**
 * Setup wifi station & esp now
 */
int enableEspNow();

/**
 * Sends a message from the sender to the receiver.
 */
void sendMessage(int eventId, int value);

typedef struct Message {
  int eventId;
  int value;
} Message;
Message outgoingPacketData;
Message receivedPacketData;
int initEspNowSender();
int initEspNowReceiver();

// emulator interop
#if isEmulatingEsp32
  esp_now_peer_info_t receiverPeerInfo;
  #define esp_now_set_self_role Serial.println
  #define ESP_NOW_ROLE_CONTROLLER 1
  #define ESP_NOW_ROLE_SLAVE 2
  void onDataReceived(const esp_now_recv_info *packetInfo, const uint8_t *incomingData, int len);
  void onDataSent(const unsigned char *mac_addr, esp_now_send_status_t sendStatus);
#else
  void onDataReceived(const uint8_t *mac, const uint8_t *incomingData, int len);
  void onDataSent(uint8_t *mac_addr, uint8_t sendStatus);
#endif



// MAIN

void setup () {
  enablePins();
  if (enableEspNow() == ESP_FAIL) return;
  Serial.println("OK Done setup");
}

void loop () {
  if (isSender || isFakeReceiverEnabled) {
    sendMessage(1, 1);
  }
  digitalWrite(13, HIGH);
  delay(1000); 
  
  digitalWrite(13, LOW);
  delay(1000);
}


// IMPLEMENTATIONS

void enablePins() {
  Serial.begin(115200);
  pinMode(13, OUTPUT);
}
int enableEspNow() {
  WiFi.mode(WIFI_STA);
  if (isEmulatingEsp32) {
    WiFi.STA.begin();
  }

  if (esp_now_init() != ESP_OK) {
    Serial.println("ERR Esp-now failure, exiting.");
    return ESP_FAIL;
  }
  Serial.print("OK Esp Now launched with mac=");
  Serial.println(WiFi.macAddress());

  if (isSender) {
    return initEspNowSender();
  } else {
    return initEspNowReceiver();
  }
}


int initEspNowSender() {
  esp_now_set_self_role(ESP_NOW_ROLE_CONTROLLER);
  esp_now_register_send_cb(onDataSent);

  #if isEmulatingEsp32    
    memcpy(receiverPeerInfo.peer_addr, receiverMacAddress, 6);
    receiverPeerInfo.channel = 0;  
    receiverPeerInfo.encrypt = false;
    if (esp_now_add_peer(&receiverPeerInfo) != ESP_OK){
      Serial.println("Failed to add peer");
      return ESP_FAIL;
    }
  #else
    esp_now_add_peer(receiverMacAddress, ESP_NOW_ROLE_SLAVE, 1, NULL, 0);
  #endif

  return ESP_OK;
}
void traceEventOut(int eventId, int value) {
  Serial.print("OK Sending eventId=");
  Serial.print(outgoingPacketData.eventId);
  Serial.print(", value=");
  Serial.print(outgoingPacketData.value);
  Serial.print("\n"); 
}
void sendMessage(int eventId, int value) {
  outgoingPacketData.eventId = eventId;
  outgoingPacketData.value = value;
  traceEventOut(outgoingPacketData.eventId, outgoingPacketData.value);

  if (isSender) {
    esp_now_send(receiverMacAddress, (uint8_t *) &outgoingPacketData, sizeof(outgoingPacketData));
  } else if (isFakeReceiverEnabled) {
    onDataReceived(NULL, (uint8_t *) &outgoingPacketData, sizeof(outgoingPacketData));
  }
}


int initEspNowReceiver() {
  esp_now_set_self_role(ESP_NOW_ROLE_SLAVE);
  esp_now_register_recv_cb(onDataReceived);
  return ESP_OK;
}
void traceEventIn(int eventId, int value) {
  Serial.print("OK Got eventId=");
  Serial.print(eventId);
  Serial.print(", value=");
  Serial.print(value);
  Serial.print("\n");
}
#if isEmulatingEsp32    
void onDataSent(const unsigned char *mac_addr, esp_now_send_status_t sendStatus) {
  Serial.println(sendStatus == ESP_NOW_SEND_SUCCESS ? "OK Packet sent" : "ERR Packet dropped");
}
void onDataReceived(const esp_now_recv_info *packetInfo, const uint8_t *incomingData, int len) {
  memcpy(&receivedPacketData, incomingData, sizeof(receivedPacketData));
  traceEventIn(receivedPacketData.eventId, receivedPacketData.value);
}
#else
void onDataSent(uint8 *mac_addr, uint8 sendStatus) {
  Serial.println(sendStatus == 0 ? "OK Packet sent" : "ERR Packet dropped");
}
void onDataReceived(const uint8_t *mac, const uint8_t *incomingData, int len) {
  memcpy(&receivedPacketData, incomingData, sizeof(receivedPacketData));
  traceEventInt(receivedPacketData.eventId, receivedPacketData.value);
}
#endif