#include <FastLED.h>
#include "main.h"

#define WS2812B_PIN 14
#define LED_DATA_PIN  13 // D7 // Hardware-MOSI
#define LED_CLOCK_PIN 14 // D5 // Hardware-CLK
#define STATUS_LED_PIN 16
#define FIRMWARE_VERSION_MAJOR 1
#define FIRMWARE_VERSION_MINOR 3
#define MAX_LED_COUNT 10000

CRGB* leds;
uint16_t led_count;
uint8_t blink_mode = 0;
unsigned long blink_timer_ts;
unsigned long blink_mode_timeout_timer_ts;
unsigned long last_data_at = 0;
bool connected = false;


void setup() {
	//Serial.setRxBufferSize(1);
	Serial.begin(9600);
	
	
	//send_ack();
	//Serial.println("Online!");
	led_count = 256;
	leds = new CRGB[256];
	//FastLED.addLeds<WS2812B, WS2812B_PIN, GRB>(leds, 256);
	FastLED.addLeds<APA102, LED_DATA_PIN, LED_CLOCK_PIN, RGB, DATA_RATE_MHZ(1)>(leds, 256);
	FastLED[0].setLeds(leds, 256);
	pinMode(STATUS_LED_PIN, OUTPUT);
	set_blink(0);
	blink_timer_ts = blink_mode_timeout_timer_ts = millis();

	/* fill(CRGB::DarkRed);
	delay(250);
	fill(CRGB::DarkGreen);
	delay(250);
	fill(CRGB::DarkBlue);
	delay(250); */
	fill(CRGB::Black);

	// CLear the receive buffer
	while (Serial.available()) { Serial.read(); }

}

void loop() {
	if (connected && last_data_at + 1000 < millis()) connected=false;
	byte cmd;
	if (Serial.available()) {
		cmd = Serial.read();
	
		switch(cmd) {
			case 'L': cmd_length();       break;
			case 'F': cmd_fill();         break;
			case 'R': cmd_receive();      break;
			case 'O': cmd_output();       break;
			case 'C': cmd_clear();        break;
			case 'V': cmd_version();      break;
			case 'M': cmd_get_max();      break;
			case 'r': cmd_random_color(); break;
			case 't': cmd_test();         break;
			case '?': cmd_help();         break;
			case 0:   if (!connected) {
				connected = true;
				send_ack();
			}
				break;
			default:  send_nack();        break;
		}
		set_blink(1);
		last_data_at = millis();
	}
	blink();
}

void set_blink(uint8_t mode) {
	blink_mode = mode;
	blink_mode_timeout_timer_ts = millis();
}

void blink() {
	unsigned long now = millis();
	unsigned long blink_timer = now - blink_timer_ts;
	unsigned long blink_mode_timeout_timer = now - blink_mode_timeout_timer_ts;
	
	switch(blink_mode) {
		case 0: // active until first command is received
			if(blink_timer < 1500) {
				status_led_on();
			} else if(blink_timer < 1600) {
				status_led_off();
			} else {
				blink_timer_ts = now;
				status_led_on();
			}
			break;
		case 1: // active after receiving a command - ends after 500ms
			/*if(blink_timer > 30) {
				blink_timer_ts = now;
				status_led_toggle();
			}
			if(blink_mode_timeout_timer > 500) {
				set_blink(2);
			}
			break;
		case 2: // waiting for commands
			if (blink_timer < 1500) {
				status_led_off();
			} else if (blink_timer < 1600) {
				status_led_on();
			} else if (blink_timer < 1700) {
				status_led_off();
			} else if (blink_timer < 1800) {
				status_led_on();
			} else {
				blink_timer_ts = now;
				status_led_off();
			}*/
			status_led_toggle();
			set_blink(2);
			break;
		case 2: // do nothing
			break;
		default: // should newer be reached
			if (blink_timer > 1000) {
				status_led_toggle();
				blink_timer_ts = now;
			}
			break;
	}
}

void fill(CRGB color) {
	for (int i=0; i<led_count; i++) {
		leds[i] = color;
	}
	FastLED.show();
}

void cmd_output() {
	FastLED.show();
	send_ack();
}

void cmd_fill() {
	uint16_t first_led = receive_word();
	uint16_t cmd_leds = receive_word();
	CRGB color = receive_color();
	
	if (first_led <= led_count && cmd_leds>0 && first_led + cmd_leds <= led_count) {
		uint16_t end_led = first_led + cmd_leds;
		for(uint16_t i=first_led; i<end_led; i++) {
			leds[i] = color;
		}
		send_ack();
	} else {
		send_nack();
	}
}

void cmd_receive() {
	uint16_t first_led = receive_word();
	uint16_t cmd_leds = receive_word();
	if (first_led <= led_count && cmd_leds>0 && first_led + cmd_leds <= led_count) {
		uint16_t end_led = first_led + cmd_leds;
		for(uint16_t i=first_led; i<end_led; i++) {
			leds[i] = receive_color();
		}
		send_ack();
	} else {
		send_nack();
	}
}

void cmd_length() {
	uint16_t new_len = receive_word();
	
	if (new_len>0 && new_len<=MAX_LED_COUNT) {
		delete leds;
		leds = new CRGB[new_len];
		led_count = new_len;
		FastLED[0].setLeds(leds, led_count);
		send_ack();
	} else {
		send_nack();
	}
}

void cmd_clear() {
	for(uint16_t i=0; i<led_count; i++) {
		leds[i] = CRGB::Black;
	}
	send_ack();
}

void cmd_version() {
	send(FIRMWARE_VERSION_MAJOR);
	send(FIRMWARE_VERSION_MINOR);
	send_ack();
}

void cmd_get_max() {
	Serial.write(MAX_LED_COUNT >> 8);
	send((byte)(MAX_LED_COUNT & 0xFF));
	send_ack();
}

void cmd_random_color() {
	for (int i=0; i<led_count; i++) {
		leds[i] = CRGB(random8(), random8(), random8());
	}
	FastLED.show();
	send_ack();
}

void cmd_test() {
	for (int i=0; i<led_count; i++) {
		leds[i] = CRGB::Red;
	}
	FastLED.show();
	send_ack();
}

void cmd_help() {
	Serial.println("L <length>                  Set new LED strip length.");
	Serial.println("F <start> <count> <color>   Fills the given part with color.");
	Serial.println("R <start> <count> <color>[] Sets colors for the fiven area.");
	Serial.println("O                           Shows the set colors on the strip.");
	Serial.println("C                           Sets all LEDs to black.");
	Serial.println("V                           Returns the firmware version as two bytes.");
	Serial.println("M                           Returns the maximum number of LEDs.");
	Serial.println("r                           Sets all LEDs to random colors.");
	Serial.println("t                           Sets the whole strip to red.");
	Serial.println("?                           Displays this help.");
	send_ack();
}

void send_ack() {
	send('A');
}

void send_nack() {
	send('N');
}

void send(byte data) {
	Serial.write(data);
	//Serial.write(0x00);
	Serial.flush();
}

uint8_t receive_byte() {
	/*byte buffer;
	Serial.setTimeout(5);
	size_t count = Serial.readBytes(&buffer, 1);
	if (count==1) return buffer;
	else return 0;*/
	while (!Serial.available()) {}
	return Serial.read();
}

uint16_t receive_word() {
	return (receive_byte() << 8) | receive_byte();
}

CRGB receive_color() {
	return CRGB(receive_byte(), receive_byte(), receive_byte());
}

void status_led_on() {
	digitalWrite(STATUS_LED_PIN, LOW);
}

void status_led_off() {
	digitalWrite(STATUS_LED_PIN, HIGH);
}

void status_led_toggle() {
	digitalWrite(STATUS_LED_PIN, !digitalRead(STATUS_LED_PIN));
}