#include <util/delay.h>

#include <inttypes.h>
#include <avr/io.h>

#include <stdio.h>

#include "uart.h"
#include "serial.h"
#include "portdeclarations.h"
#include "softuart.h"
#include "rfcomm.h"
#include "ops.h"
#include "stepper.h"
#include "main.h"

char payload[4];
char state;
char invalid;
volatile int timeoutcount;

// Timeout
#ifdef BASESTATION_PROG
// Timeout count in ms
#define TIMEOUT_C 1000

ISR(TIMER1_COMPA_vect) {
  if (timeoutcount < 65535) { // Greater than actual timeout
    timeoutcount++;
  }
}
#endif

#ifdef REMOTEDEVICE_PROG
// sensor data
char temp;
char adclight1;
char adclight2;
char lightR;

// user memory data
char height1[45];
char angle1[45];
char height2[45];
char angle2[45];
char light_set[9] = {3, 21, 56, 103, 151, 198, 233, 251, 255};
char temp_set[5] = {52, 64, 81, 93, 255};
char index_lvl[9] = {0, 5, 10, 15, 20, 25, 30, 35, 40};
char indexi;
char new_height;
char new_angle;
#endif

void initialize() {

  DDRB = 0xFF;
  rf_init();
  serial_initialize();
#ifdef REMOTEDEVICE_PROG
  stepper_init();
  // Create initial memory table
  for (char i=0; i < 9; i++) {
    for (char j=0; j < 5; j++) {
      height1[(int)index_lvl[(int)i] + (int)j] = (int)(31.875*i);		
      angle1[(int)index_lvl[(int)i] + (int)j] = (int)(63.75*j);

      height2[(int)index_lvl[(int)i] + (int)j] = 255;
      angle2[(int)index_lvl[(int)i] + (int)j] = 255;
    }
  }
    	
#endif

  DDRC = 0xFF;

#ifdef BASESTATION_PROG
  serial_getstr();
  state = BS_WAITSERIAL_S;
  OCR1A = 249;
  TCCR1B |= (1<<WGM12) | (1<<CS11) | (1<<CS10);
  TIMSK1 |= (1<<OCIE1A);
#endif

  // Following line for receiver
#ifdef REMOTEDEVICE_PROG
  rf_receive_msg();
  state = RD_AUTO_S;
  
  // ADC sensor input
  ADMUX = (1<<REFS0) | (1<<ADLAR); // A_ref = 2.56V
  ADCSRA = ((1<<ADEN) | (1<<ADSC))+7; // enable, set prescalar, begin conversion
  temp = 128;
  lightR = 128;

  // initialize look-up tables
#endif

  sei();
}

int gomanual;
void interpretCommand() {

#ifdef BASESTATION_PROG
  invalid = 1;
  serial_tx_buffer[0] = 'F';
  if (serial_rx_index >=2) {
    switch(serial_rx_buffer[1]) {
    case OP_CALIB:
      // No args required
      payload[0] = serial_rx_buffer[0];
      payload[1] = serial_rx_buffer[1];
      payload[2] = 0x00;
      payload[3] = 0x00;
      serial_tx_buffer[0] = 'W';
      invalid = 0;
      rf_send_msg(payload);
    case OP_OPEN:
    case OP_CLOSE:
    case OP_UP:
    case OP_DOWN:
    case OP_REQUEST:
      if (serial_rx_index >= 3) {
	payload[0] = serial_rx_buffer[0];
	payload[1] = serial_rx_buffer[1];
	payload[2] = serial_rx_buffer[2];
	payload[3] = 0x00;
	serial_tx_buffer[0] = 'W';
	invalid = 0;
	rf_send_msg(payload);
      }
      break;    
    case OP_ADJ:
      if (serial_rx_index >= 4) {
	payload[0] = serial_rx_buffer[0];
	payload[1] = serial_rx_buffer[1];
	payload[2] = serial_rx_buffer[2];
	payload[3] = serial_rx_buffer[3];
	serial_tx_buffer[0] = 'W';
	invalid = 0;
	rf_send_msg(payload);
      }
      break;
    }
  }
  serial_tx_buffer[1] = '\n';
  serial_tx_buffer[2] = '\r';
  serial_tx_buffer[3] = 0x00;
  serial_putstr();
#endif

#ifdef REMOTEDEVICE_PROG
  gomanual = 0;
  if (rf_payload[0] == DEVICEADDR) { // Check if meant for this
    payload[0] = 0x00;
    payload[1] = DEVICEADDR;
    switch(rf_payload[1]) {
    case OP_UP:
      adjup_pos = 8;
      adjdown_pos = 0;
      payload[2] = 0x00; // Acknowledgement
      payload[3] = 'A'; // Acknowledged
      rf_send_msg(payload);
      gomanual = 1;
      break;
    case OP_DOWN:
      adjdown_pos = 8;
      adjup_pos = 0;
      payload[2] = 0x00; // Acknowledgement
      payload[3] = 'A'; // Acknowledged
      gomanual = 1;
      rf_send_msg(payload);
      break;
    case OP_OPEN:
      adjopen_pos = 4;
      adjclose_pos = 0;
      payload[2] = 0x00; // Acknowledgement
      payload[3] = 'A'; // Acknowledged
      gomanual = 1;
      rf_send_msg(payload);
      break;
    case OP_CLOSE:
      adjclose_pos = 4;
      adjopen_pos = 0;
      payload[2] = 0x00; // Acknowledgement
      payload[3] = 'A'; // Acknowledged
      gomanual = 1;
      rf_send_msg(payload);
      break;
    case OP_ADJ:
      adjup_pos = current_blind_pos - payload[2];
      adjopen_pos = current_flap_pos - payload[3];
      gomanual = 1;
      break;
    case OP_REQUEST:
      payload[2] = rf_payload[2];
      if (rf_payload[2] == 'X') { // Indoor sensor
        payload[3] = adclight1;
      } else if (rf_payload[2] == 'Y') { // Outdoor sensor
        payload[3] = adclight2;
      } else if (rf_payload[2] == 'Z') { // Temperature sensor
	payload[3] = temp;
      } else if (rf_payload[2] == 'W') { // Current position
	payload[3] = current_blind_pos;
      } else if (rf_payload[2] == 'V') { // Current flap position
	payload[3] = current_flap_pos;
      } else if (rf_payload[2] == 'D') { // Light difference
	payload[3] = lightR;
      } else if (rf_payload[2] == 'A') {
	payload[3] = new_height;
      } else if (rf_payload[2] == 'B') {
	payload[3] = new_angle;
      } else if (rf_payload[2] == 'G') {
	payload[3] = adjup_pos;
      } else if (rf_payload[2] == 'H') {
	payload[3] = adjdown_pos;
      }

      rf_send_msg(payload);
      gomanual = 0;
      break;
    case OP_CALIB:
      payload[2] = 0x00;
      payload[3] = 'A';
      stepper_calib();
      rf_send_msg(payload);
      gomanual = 1;
      break;
    }
  }
#endif
}


int main() {
  initialize();
  
  while (1) {
  

    //TRANSMITTER STUFF
#ifdef BASESTATION_PROG
    if (state == BS_WAITSERIAL_S && serial_rx_ready == 1 && rf_state == RF_IDLE_S) {
      state = BS_PROCCMD_S;
      interpretCommand();
    } else if (state == BS_PROCCMD_S && serial_tx_ready == 1 && rf_state == RF_IDLE_S) {
      if (invalid==0) {
	state = BS_WAITRESP_S;
	rf_receive_msg(); //Receiver for ACK or sensor value
      } else {
		 
	state = BS_WAITSERIAL_S;	
      }
      serial_tx_buffer[0] = 'D';
      serial_tx_buffer[1] = '\n';
      serial_tx_buffer[2] = '\r';
      serial_tx_buffer[3] = 0x00;
      serial_putstr();
      serial_getstr();
      timeoutcount = 0;
    } else if (state == BS_WAITRESP_S && rf_state == RF_IDLE_S) {
      rf_decode_pl();
      timeoutcount = 0;
      if (rf_payload[0] != 0x00) {
	state = BS_WAITRESP_S;
	rf_receive_msg();
      } else {
	state = BS_WAITSERIAL_S;
	// Print return value
	serial_tx_buffer[0] = 'R'; // Response
	serial_tx_buffer[1] = rf_payload[1]; // Origin address
	serial_tx_buffer[2] = (rf_payload[2]==0?'0':rf_payload[2]); // Sensor / ACK
	serial_tx_buffer[3] = rf_payload[3]; // Value
	serial_tx_buffer[4] = '\n';
	serial_tx_buffer[5] = '\r';
	serial_tx_buffer[6] = 0x00;
	serial_putstr();
      }
    } else if (state == BS_WAITRESP_S && timeoutcount >= TIMEOUT_C && rf_state != RF_IDLE_S) {	   
      rf_reset();
      timeoutcount = 0;
      serial_tx_buffer[0] = 'T'; // Timed
      serial_tx_buffer[1] = 'O'; // Out
      serial_tx_buffer[2] = '\n';
      serial_tx_buffer[3] = '\r';
      serial_tx_buffer[4] = 0x00;
      serial_putstr();
      state = BS_WAITSERIAL_S;
    } else if (rf_state != RF_IDLE_S) {
      rf_process_byte();
    }
#endif
    
    // RECEIVER STUFF
#ifdef REMOTEDEVICE_PROG
    PORTB ^= 1<<2;
    // temperature sensor input
    if (ADCSRA&(1<<ADIF)) {// a conversion is done	
      switch(ADMUX & 0x1F) {
      case 0: // temp sensor done
	temp = ADCH; // take temp reading and shift to get room temp
	// begin light sensor 1 conversion (inside light)
	//ADMUX = 0x61; // set for AVcc = 5V and pin A.1
	ADMUX+=1; // => A.1
	ADCSRA |= (1<<ADIF);
	ADCSRA |= (1<<ADSC); // begin conversion
	break;
      case 1: // inside light done
	adclight1 = (ADCH >> 1); // take light reading/2
	// begin light sensor 2 conversion (outside light)
	ADMUX+=1; // => A.2
	ADCSRA |= (1<<ADIF);
	ADCSRA |= (1<<ADSC);	
	break;
      case 2: // outside light done
	adclight2 = (ADCH >> 1); // take light reading/2
	ADMUX &= ~(0x1F); // => A.0
	ADCSRA |= (1<<ADIF);
	ADCSRA |= (1<<ADSC);
	lightR = adclight1-adclight2+128; // difference between light centered at 128
	break;
      }
    }
		
    if (adjdown_pos == 0 && adjup_pos == 0 &&
	adjopen_pos == 0 && adjclose_pos ==0) { // done manual adjusting
		
      STEPPER_PORT = 0x00; // De-energize shade (power saving)
    }
    if (state == 0x99) {
      if (rf_state == RF_IDLE_S) { // Done transmitting acknowledgement
	rf_receive_msg();
	state = RD_AUTO_S;
      } else {
	rf_process_byte();
      }
    }
    else if (state == RD_AUTO_S) {
      PORTB ^= 1<<7;
      if (rf_state == RF_IDLE_S) { // Finished receiving a command
	rf_decode_pl();
	interpretCommand(); // Interpret command will do manual setting
	//Interpret command will also transmit an ACK
	if (gomanual) state = RD_MANUAL1_S;
	else state = 0x99;
      } else {
	rf_process_byte();
		
	// AUTOMATIC SETTING HERE
	// SET ADJOPEN_POS, ADJCLOSE_POS, ADJUP_POS, ADJDOWN_POS
	// ACCORDING TO THE TABLE HERE
	for(char i = 0; i < 9; i++) { // gets light level
	  if(lightR < light_set[(int)i]) {
	    indexi = i;
	    break;
	  }
	}
	for(char j = 0; j < 5; j++) { // gets temperature adjustment
	  if(temp < temp_set[(int)j]) {
	    indexi = index_lvl[(int)indexi] + j;
	    break;
	  }
	}
	if(adclight2 > 20) { // checks for day/night settings
	  new_height = height1[(int)indexi];
	  new_angle = angle1[(int)indexi];
	} else {
	  new_height = height2[(int)indexi];
	  new_angle = angle2[(int)indexi];
	}

	if (new_height > current_blind_pos) {adjdown_pos = new_height - current_blind_pos;adjup_pos = 0;}
	else {adjup_pos = current_blind_pos - new_height;adjdown_pos = 0;}
	if (new_angle > current_flap_pos) {adjclose_pos = new_angle - current_flap_pos; adjopen_pos = 0;}
	else {adjopen_pos = current_flap_pos - new_angle; adjclose_pos = 0;}

      }
    } else if (state == RD_MANUAL1_S) {
      if (rf_state == RF_IDLE_S) { // ACK transmitted
	rf_receive_msg(); // Listen for next command
	state = RD_MANUAL2_S;
			
      } else {
	rf_process_byte(); // Until transmit done.
      }
      if (adjdown_pos == 0 && adjup_pos == 0 &&
	  adjopen_pos == 0 && adjclose_pos ==0) { // done manual adjusting
	state = RD_AUTO_S;}
      // SAVE SETTINGS HERE
      // SAVE CURRENT_BLIND_POS AND CURRENT_FLAP_POS TO TABLE HERE
      for(char i = 0; i < 9; i++) {
				
	if(lightR < light_set[(int)i]) {
	  indexi = i;
	  break;
	}
      }
      for(char j = 0; j < 5; j++) {
	if(temp < temp_set[(int)j]) {
	  indexi = index_lvl[(int)indexi] + j;
	  break;
	}
      }
      if(adclight2 > 50) {
	height1[(int)indexi] = current_blind_pos;
	angle1[(int)indexi] = current_flap_pos;
      } else {
	height2[(int)indexi] = current_blind_pos;
	angle2[(int)indexi] = current_flap_pos;
      }
    } else if (state == RD_MANUAL2_S) { 
      PORTB ^= 1<<1;	
      if (rf_state == RF_IDLE_S) { // New command received
	rf_decode_pl(); // Process new command
	interpretCommand();
	state = RD_MANUAL1_S; // Transmit
      } else {
	rf_process_byte(); // Until new command received
      }
      if (adjdown_pos == 0 && adjup_pos == 0 &&
	  adjopen_pos == 0 && adjclose_pos ==0) { // done manual adjusting
	rf_reset();
	state = RD_AUTO_S; }
      // SAVE SETTINGS HERE
      // SAVE CURRENT_BLIND_POS AND CURRENT_FLAP_POS TO TABLE HERE
      for(char i = 0; i < 9; i++) {
	if(lightR < light_set[(int)i]) {
	  indexi = i;
	  break;
	}
      }
      for(char j = 0; j < 5; j++) {
	if(temp < temp_set[(int)j]) {
	  indexi = index_lvl[(int)indexi] + j;
	  break;
	}
      }
      if(adclight2 > 50) {
	height1[(int)indexi] = current_blind_pos;
	angle1[(int)indexi] = current_flap_pos;
      } else {
	height2[(int)indexi] = current_blind_pos;
	angle2[(int)indexi] = current_flap_pos;
      }
    } 
#endif
  }
}