// Hello LoRa - ABP TTN Packet Sender (Multi-Channel)
// Tutorial Link: https://learn.adafruit.com/the-things-network-for-feather/using-a-feather-32u4
//
// Adafruit invests time and resources providing this open source code.
// Please support Adafruit and open source hardware by purchasing
// products from Adafruit!
//
// Copyright 2015, 2016 Ideetron B.V.
//
// Modified by Brent Rubell for Adafruit Industries, 2018
/************************** Configuration ***********************************/
#include <TinyLoRa.h>
#include <SPI.h>
#include "gateway/message.pb.h"

#include "pb_common.h"
#include "pb.h"
#include "pb_encode.h"
#include "pb_decode.h"

#include "gateway/message.pb.h"

// Visit your thethingsnetwork.org device console
// to create an account, or if you need your session keys.

// Network Session Key (MSB)
uint8_t NwkSkey[16] = {0x52, 0x92, 0xC0, 0x72, 0x2D, 0x3C, 0x55, 0x5E, 0xE4, 0xB9, 0x9E, 0x9B, 0x88, 0x66, 0x47, 0xF1};

// Application Session Key (MSB)
uint8_t AppSkey[16] = {0xC4, 0x30, 0xEF, 0x56, 0x4F, 0x6D, 0xA2, 0x56, 0x1F, 0x15, 0x2F, 0xB8, 0x62, 0xC7, 0xCA, 0xC2};

// Device Address (MSB)
uint8_t DevAddr[4] = {0x26, 0x02, 0x12, 0xB6};

/************************** Example Begins Here ***********************************/
// Data Packet to Send to TTN
unsigned char loraData[50] = {"hello LoRa"};

// How many times data transfer should occur, in seconds
const unsigned int sendInterval = 30;

// Pinout for Adafruit Feather 32u4 LoRa
TinyLoRa lora = TinyLoRa(2, 10, 9);

// Pinout for Adafruit Feather M0 LoRa
//TinyLoRa lora = TinyLoRa(3, 8, 4);

const uint8_t N_POLY_MAX=100;
float polyx[N_POLY_MAX];
float polyy[N_POLY_MAX];
int n_poly=0;
int push_vert(float x, float y) {
  if(n_poly>N_POLY_MAX)
    return 0;
  polyx[n_poly]=x;
  polyy[n_poly]=y;
  n_poly++;
  return 1;
}
void clear_verts() {
  n_poly=0;
}
int pnpoly(int nvert, float *vertx, float *verty, float testx, float testy)
{ //from stack overflow
  int i, j, c = 0;
  for (i = 0, j = nvert-1; i < nvert; j = i++) {
    if ( ((verty[i]>testy) != (verty[j]>testy)) &&
     (testx < (vertx[j]-vertx[i]) * (testy-verty[i]) / (verty[j]-verty[i]) + vertx[i]) )
       c = !c;
  }
  return c;
}
int check_bounds(float x, float y) {
  return pnpoly(n_poly, polyx, polyy, x, y);
}
bool Fenceless_Coordinates_callback(pb_istream_t *stream, const pb_field_iter_t *field, void **arg) {
  Serial.println("Called");
  while(stream->bytes_left) {
	  Fenceless_Coordinate m = Fenceless_Coordinate_init_zero;
    if(!pb_decode(stream, Fenceless_Coordinate_fields, &m)) {
      return false;
    }
    push_vert(m.x,m.y);
    return true;
  }
}
void import_protobuf(uint8_t *protobuffer, uint32_t size) {
  Fenceless_Coordinates m;
	pb_istream_t stream = pb_istream_from_buffer(protobuffer, size);
  int status = pb_decode(&stream, Fenceless_Coordinates_fields, &m);
  if(!status){
    Serial.println("Failed to decode");
  }
  clear_verts();
  switch(m.isr) {
    case 10:
      push_vert(m.coord9.x, m.coord9.y);
    case 9:
      push_vert(m.coord8.x, m.coord8.y);
    case 8:
      push_vert(m.coord7.x, m.coord7.y);
    case 7:
      push_vert(m.coord6.x, m.coord6.y);
    case 6:
      push_vert(m.coord5.x, m.coord5.y);
    case 5:
      push_vert(m.coord4.x, m.coord4.y);
    case 4:
      push_vert(m.coord3.x, m.coord3.y);
    case 3:
      push_vert(m.coord2.x, m.coord2.y);
      push_vert(m.coord1.x, m.coord1.y);
      push_vert(m.coord0.x, m.coord0.y);
  }
}
bool Fenceless_Coordinates_encode(pb_ostream_t *stream, const pb_field_iter_t *field, void * const * arg) {
  Serial.println("Encode called");
  return false;
  Fenceless_Coordinate c = *(Fenceless_Coordinate*)field->pData;
  if(!pb_encode_tag_for_field(stream, field)) {
    return false;
  }
  return pb_encode(stream, Fenceless_Coordinate_fields, field);
}
void test() {
  Serial.println("Testing protobuf");
  uint8_t buffer[100] = {0};
  Fenceless_Coordinates m = Fenceless_Coordinates_init_zero;
  pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
  int status = pb_encode(&stream, Fenceless_Coordinates_fields, &m);
  if(!status){
    Serial.println("Failed to encode");
  }
  import_protobuf(buffer, sizeof(buffer));
}
int recieved = 0;
void on_recieve(int n) {
  recieved = 1;
}
void setup()
{
  delay(2000);
  Serial.begin(9600);
  while (! Serial);

  delay(4000);
  // Initialize pin LED_BUILTIN as an output
  pinMode(LED_BUILTIN, OUTPUT);

  // Initialize LoRa
  Serial.print("Starting LoRa...");
  // define multi-channel sending
  lora.setChannel(MULTI);
  // set datarate
  lora.setDatarate(SF7BW125);
  if(!lora.begin())
  {
    Serial.println("Failed");
    Serial.println("Check your radio");
    while(true);
  }

  Fenceless_Coordinates coords;
  coords.isr = 10;
  coords.coord0.x = 1; coords.coord0.y = 2;
  coords.coord1.x = 1; coords.coord1.y = 2;
  coords.coord2.x = 1; coords.coord2.y = 2;
  coords.coord3.x = 1; coords.coord3.y = 2;
  coords.coord4.x = 1; coords.coord4.y = 2;
  coords.coord5.x = 1; coords.coord5.y = 2;
  coords.coord6.x = 1; coords.coord6.y = 2;
  coords.coord7.x = 1; coords.coord7.y = 2;
  coords.coord8.x = 1; coords.coord8.y = 2;
  coords.coord9.x = 1; coords.coord9.y = 2;

  pb_ostream_t stream;
  stream  = pb_ostream_from_buffer(loraData, sizeof(loraData));
  int err = pb_encode(&stream, Fenceless_Coordinates_fields, &coords);
  // Optional set transmit power. If not set default is +17 dBm.
  // Valid options are: -80, 1 to 17, 20 (dBm).
  // For safe operation in 20dBm: your antenna must be 3:1 VWSR or better
  // and respect the 1% duty cycle.

  lora.setPower(1);
  Serial.println("OK");
}

void loop()
{
  Serial.println("Sending LoRa Data...");
  lora.sendData(loraData, sizeof(loraData), lora.frameCounter);
  // Optionally set the Frame Port (1 to 255)
  // uint8_t framePort = 1;
  // lora.sendData(loraData, sizeof(loraData), lora.frameCounter, framePort);
  Serial.print("Frame Counter: ");Serial.println(lora.frameCounter);
  lora.frameCounter++;

  // blink LED to indicate packet sent
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  
  Serial.println("delaying...");

  if(recieved) {
    Serial.println("Recieved something");
  } else {
    Serial.println("Nothing yet");
  }
  delay(sendInterval * 1000);
}