// #include <stddef.h>
#include "ROBO_TX_PRG.h"
#include "ROBO_TX_FW.h"
#include <stddef.h>

#define LIGHT_MAX       DUTY_MAX
#define LIGHT_MIN       DUTY_MIN
#define LIGHT_OFF		0
#define wait			10

#define RC              0x7FFF // return code: 0x7FFF - program should be further called by the firmware;
#define sRC             0

#define BEG_LAMP_IDX    0
#define END_LAMP_IDX    2
#define COLOR_AMOUNT    3
enum color_pin {RED, GREEN, BLUE};
enum color_spectrum {pr, mb, pg, mr, pb, mg};

static unsigned long cur_time;
static unsigned long prev_time;
static short* states[COLOR_AMOUNT];
short green_state;
short red_state;
short blue_state;
enum color_pin pin;
enum color_spectrum spectrum_state;
static int lamp_idx;
static int n_loops;

void simple_rgb_test(TA * p_ta_array);
void spectrum();
void update_lights(TA * p_ta_array);

void PrgInit
(
	TA * p_ta_array,    // pointer to the array of transfer areas
	int ta_count        // number of transfer areas in array (equal to TA_COUNT)
)
{
	prev_time = 0;
	red_state = LIGHT_MIN;
	green_state = LIGHT_MIN;
	blue_state = LIGHT_MIN;
	states[0] = &red_state;
	states[1] = &green_state;
	states[2] = &blue_state;
	spectrum_state = 0;
	pin = 0;
	lamp_idx = BEG_LAMP_IDX;
}

int PrgTic
(
	TA * p_ta_array,    // pointer to the array of transfer areas
	int ta_count        // number of transfer areas in array (equal to TA_COUNT)
)
{
	TA * p_ta = &p_ta_array[TA_LOCAL];
    // Get the current value of the system time
    cur_time = p_ta->hook_table.GetSystemTime(TIMER_UNIT_MILLISECONDS);
    // if(cur_time-prev_time>=wait)
	// {
	// 	prev_time = cur_time;
	// 	simple_rgb_test(p_ta_array);
	// 	update_lights(p_ta_array);
	// }
    if(cur_time-prev_time>=wait)
	{
		prev_time = cur_time;
		spectrum();
		update_lights(p_ta_array);
	}
	return RC;
}

void spectrum()
{
	switch(spectrum_state)
	{
		case pr:
			if(++red_state>LIGHT_MAX) {++spectrum_state;}
			break;
		case mb:
			if(--blue_state<LIGHT_MIN) {++spectrum_state;}
			break;
		case pg:
			if(++green_state>LIGHT_MAX) {++spectrum_state;}
			break;
		case mr:
			if(--red_state<LIGHT_MIN) {++spectrum_state;}
			break;
		case pb:
			if(++blue_state>LIGHT_MAX) {++spectrum_state;}
			break;
		case mg:
			if(--green_state<LIGHT_MIN) {spectrum_state = 0;}
			break;
		default:
			spectrum_state = pr;
	}
}

void simple_rgb_test
(
	TA * p_ta_array    // pointer to the array of transfer areas
)
{
	TA * p_ta = &p_ta_array[TA_LOCAL];
	p_ta->hook_table.DisplayMsg(p_ta, NULL);

	switch(pin)
	{
		
		case RED:
			p_ta->hook_table.DisplayMsg(p_ta, "RED");
			blue_state = LIGHT_MIN;
			red_state = LIGHT_MAX;
			pin = GREEN;
			break;
		case GREEN:
			p_ta->hook_table.DisplayMsg(p_ta, "GREEN");
			red_state = LIGHT_MIN;
			green_state = LIGHT_MAX;
			pin = BLUE;
			break;
		case BLUE:
			p_ta->hook_table.DisplayMsg(p_ta, "BLUE");
			green_state = LIGHT_MIN;
			blue_state = LIGHT_MAX;
			pin = RED;
			break;
		default:
			p_ta->hook_table.DisplayMsg(p_ta, NULL);
			pin = RED;
	}
}

void update_lights(TA * p_ta_array)
{
	TA * p_ta = &p_ta_array[TA_LOCAL];
	if(red_state>LIGHT_MAX) { red_state = LIGHT_MAX; }
	if(green_state>LIGHT_MAX) { green_state=LIGHT_MAX; }
	if(blue_state>LIGHT_MAX) { blue_state = LIGHT_MAX; }
	
	if(red_state<LIGHT_MIN) { red_state = LIGHT_MIN; }
	if(green_state<LIGHT_MIN) { green_state=LIGHT_MIN; }
	if(blue_state<LIGHT_MIN) { blue_state = LIGHT_MIN; }
	
	p_ta->output.duty[RED] = red_state;
	p_ta->output.duty[GREEN] = green_state;
	p_ta->output.duty[BLUE] = blue_state;
}