#include <neotimer.h>

#include <RF24Network.h>
#include <RF24.h>
#include <SPI.h>

#define judge1_red_led    1
#define judge1_white_led  2
#define judge2_red_led    3
#define judge2_white_led  4
#define judge3_red_led    5
#define judge3_white_led  6
#define buzzer            7
#define test_mode_switch  8
#define channel           90

RF24 radio(7,8); //CE,CSN
RF24Network network(radio);
const uint16_t  base_station = 00;
const uint16_t  judge1 = 01;
const uint16_t  judge2 = 02;
const uint16_t  judge3 = 03;

unsigned long judge1_send;
unsigned long judge2_send;
unsigned long judge3_send;

unsigned long judge1_rcv;
unsigned long judge2_rcv;
unsigned long judge3_rcv;

Neotimer timer_30s = Neotimer(30000);
Neotimer timer_15s = Neotimer(15000);
Neotimer timer_3s = Neotimer(3000);

long previous_milis;
long current_milis;

bool judge1_red_call;
bool judge2_red_call;
bool judge3_red_call;
bool judge1_white_call;
bool judge2_white_call;
bool judge3_white_call;
bool buzzed;

void setup() {
  SPI.begin();
  radio.begin();
  network.begin(channel, base_station);
  radio.setDataRate(RF24_250KBPS);
  radio.setPALevel(RF24_PA_HIGH);

  pinMode(judge1_red_led, OUTPUT);
  pinMode(judge1_white_led, OUTPUT);
  pinMode(judge2_red_led, OUTPUT);
  pinMode(judge2_white_led, OUTPUT);
  pinMode(judge3_red_led, OUTPUT);
  pinMode(judge3_white_led, OUTPUT);
  pinMode(buzzer, OUTPUT);
  pinMode(test_mode_switch, INPUT);

  previous_milis = 0;
  current_milis = 0;
}



void loop() {
  radio_comms();

  judge_decipher(judge1_rcv, judge1_red_call, judge1_white_call);
  judge_decipher(judge2_rcv, judge2_red_call, judge2_white_call);
  judge_decipher(judge3_rcv, judge3_red_call, judge3_white_call);

  if (digitalRead(test_mode_switch) == HIGH)  {
    judge1_send = 3;
    judge2_send = 3;
    judge3_send = 3;
    led_outputs();
  }

//Guts of the program
  else {

    //Display the lights for 15 seconds and buzz for 3 if majority fail
    if (timer_15s.waiting() == true) {
      led_outputs();
      if ((red_voting() == true) && (buzzed == false)) {
        timer_3s.start();
        buzzed = true;
        digitalWrite(buzzer,HIGH);
      }
      if (timer_3s.done() == true) {
        digitalWrite(buzzer,LOW);
        timer_3s.stop();
        timer_3s.reset();
      }
    }
    else if (timer_15s.done() == true) {
      timer_15s.stop();
      timer_15s.reset();
      judge1_send = 0;
      judge2_send = 0;
      judge3_send = 0;
      digitalWrite(judge1_red_led,LOW);
      digitalWrite(judge1_white_led,LOW);
      digitalWrite(judge2_red_led,LOW);
      digitalWrite(judge2_white_led,LOW);
      digitalWrite(judge3_red_led,LOW);
      digitalWrite(judge3_white_led,LOW);
    }

    //This is the waiting period after the first judge has submitted a call
    //Alerts the other judges and waits for their call
    if (timer_30s.waiting() == true) {
      if (judge1_red_call || judge1_white_call ) {
        judge1_send = 2;
      }
      if (judge2_red_call || judge2_white_call ) {
        judge2_send = 2;
      }
      if (judge3_red_call || judge3_white_call ) {
        judge3_send = 2;
      }
      if ((judge1_send == 2) && (judge2_send == 2) && (judge3_send == 2)) {
        timer_15s.start();
        timer_30s.stop();
        timer_30s.reset();
      }
    }
    else if (timer_30s.done() == true) {
      timer_15s.start();
      timer_30s.stop();
      timer_30s.reset();
    }

    //This is the default state of the system. The system waits for a call from any judge
    // and starts a 30 second timer during which period the other judges must make a call
    else {
      buzzed = false;
      if (judge1_red_call || judge1_white_call ) {
        timer_30s.start();
        judge1_send = 2;
        judge2_send = 1;
        judge3_send = 1;
      }
      if (judge2_red_call || judge2_white_call ) {
        timer_30s.start();
        judge1_send = 1;
        judge2_send = 2;
        judge3_send = 1;
      }
      if (judge3_red_call || judge3_white_call ) {
        timer_30s.start();
        judge1_send = 1;
        judge2_send = 1;
        judge3_send = 2;
      }
    }

  }

}

void radio_comms()  {
  network.update();

  //RECEIVING
  while (network.available()){
    RF24NetworkHeader header;
    unsigned long incomingData;
    network.read(header, &incomingData, sizeof(incomingData));
    if(header.from_node == judge1){
        judge1_rcv = incomingData;
    }
    if(header.from_node == judge2){
        judge2_rcv = incomingData;
    }
    if(header.from_node == judge3){
        judge3_rcv = incomingData;
    }
    }
  //SENDING
  RF24NetworkHeader header1(judge1);
  bool ok1 = network.write(header1, &judge1_send, sizeof(judge1_send));

  RF24NetworkHeader header2(judge2);
  bool ok2 = network.write(header2, &judge2_send, sizeof(judge2_send));

  RF24NetworkHeader header3(judge3);
  bool ok3 = network.write(header3, &judge3_send, sizeof(judge3_send));
}

void judge_decipher(unsigned long judge_rcv, bool judge_red_call, bool judge_white_call ) {
  switch(judge_rcv) {
    case 0:
      judge_white_call = false;
      judge_red_call = false;
    case 1:
      judge_white_call = true;
      judge_red_call = false;
    case 2:
      judge_white_call = false;
      judge_red_call = true;
    default:
      judge_white_call = false;
      judge_red_call = false;
  }
}

void led_outputs() {
  if (judge1_red_call) digitalWrite(judge1_red_led, HIGH);
  else digitalWrite(judge1_red_led, LOW);
  if (judge2_red_call) digitalWrite(judge2_red_led, HIGH);
  else digitalWrite(judge2_red_led, LOW);
  if (judge3_red_call) digitalWrite(judge3_red_led, HIGH);
  else digitalWrite(judge3_red_led, LOW);
  if (judge1_white_call) digitalWrite(judge1_white_led, HIGH);
  else digitalWrite(judge1_white_led, LOW);
  if (judge2_white_call) digitalWrite(judge2_white_led, HIGH);
  else digitalWrite(judge2_white_led, LOW);
  if (judge3_white_call) digitalWrite(judge3_white_led, HIGH);
  else digitalWrite(judge3_white_led, LOW);
}

bool red_voting() {
  if (judge1_red_call && judge2_red_call) return true;
  else if (judge1_red_call && judge3_red_call) return true;
  else if (judge2_red_call && judge3_red_call) return true;
  else return false;
}