#define pr_fmt(fmt) "[hui][generic]" fmt

#include "hui_internal.h"
#include "hui_generic.h"

#include <linux/spinlock.h>
#include <linux/timer.h>
#include <linux/slab.h>
#include <linux/of.h>
#include <linux/list.h>
#include <avm/hui/led.h>
#include <avm/hui/button.h>

#define ON 1
#define ON_125ms 1
#define ON_250ms 1, 1
#define ON_500ms 1, 1, 1, 1
#define ON_1s 1, 1, 1, 1, 1, 1, 1, 1
#define OFF 0
#define OFF_125ms 0
#define OFF_250ms 0, 0
#define OFF_500ms 0, 0, 0, 0
#define OFF_1s 0, 0, 0, 0, 0, 0, 0, 0

/* Each blink1/blink2 has to end with one of the following states, else the
 * state machine will not work */
/* If blink1 'stays' in blink1 there is no need to define blink2 */
#define GOTO_BLINK1 2
#define REPEAT_GOTO_BLINK2 3
#define GOTO_BLINK2 4
#define REPEAT_GOTO_BLINK1 5
#define END 6

struct led_blink_code {
	const int8_t *blink1;
	const int8_t *blink2;
};

const int8_t code_einschalten_blink1[] = { ON, END };
const struct led_blink_code code_einschalten = {
	.blink1 = code_einschalten_blink1,
};
/*--- DEFINE STATE ausschalten OFF(), END ; ---*/
const int8_t code_ausschalten_blink1[] = { OFF, END };
const struct led_blink_code code_ausschalten = {
	.blink1 = code_ausschalten_blink1,
};
/*--- DEFINE STATE keine_action END ;; ---*/
const int8_t code_keine_action_blink1[] = { END };
const struct led_blink_code code_keine_action = {
	.blink1 = code_keine_action_blink1,
};
/*--- DEFINE STATE 0_5HZ_binking start:, ON(), WAIT(1000) , OFF(), WAIT(1000),
 * LOOP TO start, END ; ---*/
const int8_t code_0_5HZ_blinking_blink1[] = { ON_1s, OFF_1s, GOTO_BLINK1 };
const struct led_blink_code code_0_5HZ_blinking = {
	.blink1 = code_0_5HZ_blinking_blink1,
};
/*--- DEFINE STATE 1HZ_binking start:, ON(), WAIT(500) , OFF(), WAIT(500), LOOP
 * TO start, END ; ---*/
const int8_t code_1HZ_blinking_blink1[] = { ON_500ms, OFF_500ms, GOTO_BLINK1 };
const struct led_blink_code code_1HZ_blinking = {
	.blink1 = code_1HZ_blinking_blink1,
};
/*--- DEFINE STATE 2HZ_binking start:, ON(), WAIT(250) , OFF(), WAIT(250), LOOP
 * TO start, END ; ---*/
const int8_t code_2HZ_blinking_blink1[] = { ON_250ms, OFF_250ms, GOTO_BLINK1 };
const struct led_blink_code code_2HZ_blinking = {
	.blink1 = code_2HZ_blinking_blink1,
};
/*--- DEFINE STATE 4HZ_binking start:, ON(), WAIT(125) , OFF(), WAIT(125), LOOP
 * TO start, END ; ---*/
const int8_t code_4HZ_blinking_blink1[] = { ON_125ms, OFF_125ms, GOTO_BLINK1 };
const struct led_blink_code code_4HZ_blinking = {
	.blink1 = code_4HZ_blinking_blink1,
};

/*  DEFINE STATE hardware_error_blink start:, RELOAD PARAM 1,
				loop1:,
					ON(HARDWARE_ERROR_LED1),
   ON(HARDWARE_ERROR_LED2), ON(HARDWARE_ERROR_LED3), ON(HARDWARE_ERROR_LED4),
					ON(HARDWARE_ERROR_LED5),
   ON(HARDWARE_ERROR_LED6), ON(HARDWARE_ERROR_LED7), ON(HARDWARE_ERROR_LED8),
					WAIT(250),

					OFF(HARDWARE_ERROR_LED1),
   OFF(HARDWARE_ERROR_LED2), OFF(HARDWARE_ERROR_LED3), OFF(HARDWARE_ERROR_LED4),
					OFF(HARDWARE_ERROR_LED5),
   OFF(HARDWARE_ERROR_LED6), OFF(HARDWARE_ERROR_LED7), OFF(HARDWARE_ERROR_LED8),
					WAIT(250),

					PARAM 1 --, LOOP TO loop1 IF PARAM 1,
					WAIT(750),
				    LOOP TO start, END ;
 */
const struct led_blink_code code_hardware_error_blinking = {
	.blink1 = (const int8_t[]){ ON_250ms, OFF_250ms, REPEAT_GOTO_BLINK2 },
	.blink2 = (const int8_t[]){ OFF_500ms, OFF_250ms, GOTO_BLINK1 },
};

const int8_t code_double_blink_code_2HZ_blink1[] = {
	ON_250ms, OFF_250ms, ON_250ms, OFF_250ms, OFF_500ms, REPEAT_GOTO_BLINK2
};
const int8_t code_double_blink_code_2HZ_blink2[] = { OFF_1s, GOTO_BLINK1 };
const struct led_blink_code code_double_blink_code_2HZ = {
	.blink1 = code_double_blink_code_2HZ_blink1,
	.blink2 = code_double_blink_code_2HZ_blink2,
};

const int8_t code_einschalten_off_on_blink1[] = { OFF_250ms, ON_250ms, END };
const struct led_blink_code code_einschalten_off_on = {
	.blink1 = code_einschalten_off_on_blink1,
};

/**
 * @brief The blink codes are stored in this array. The access is done via the
 * @ref LED_BLINK_CODE_DEFINES
 *
 * When changing this table be aware of the order.
 * The order has to match the #defines in led_controller.h
 */
const struct led_blink_code *blink_codes[] = {
	&code_ausschalten, /*--- #define LED_OFF         0 ---*/
	&code_einschalten, /*--- #define LED_ON          1 ---*/
	&code_0_5HZ_blinking, /*--- #define LED_0_5HZ       2 ---*/
	&code_1HZ_blinking, /*--- #define LED_1HZ         3 ---*/
	&code_2HZ_blinking, /*--- #define LED_2HZ         4 ---*/
	&code_4HZ_blinking, /*--- #define LED_4HZ         5 ---*/
	&code_hardware_error_blinking, /*--- 6 ---*/
	&code_double_blink_code_2HZ, /*--- 7 ---*/
	&code_einschalten_off_on, /*--- 8 ---*/
};

static inline void blink_handle_timer(unsigned long j);
static DEFINE_TIMER(blink_timer, blink_handle_timer, 0, 0);
static LIST_HEAD(all_leds);
static LIST_HEAD(all_buttons);

static inline void blink_handle_timer(unsigned long k)
{
	struct hui_generic_led *led;
	struct hui_generic_button *button;

	mod_timer(&blink_timer, blink_timer.expires + msecs_to_jiffies(125));

	// First move through all, to update the engine
	list_for_each_entry (led, &all_leds, engine.list) {
		/* check if 125 ms have passed --> we can advance in the blink
		 * _code */
		const int8_t *blink12;

		/* store a pointer to the blink1/blink2 array depending on
		 * blink1_blink2 */
		if (led->engine.blink1_blink2 == 0) {
			blink12 = blink_codes[led->engine._code]->blink1;
		} else {
			blink12 = blink_codes[led->engine._code]->blink2;
		}

		/* we only treat the on off here */
		if ((blink12[led->engine.current_blink_step] == ON) ||
		    (blink12[led->engine.current_blink_step] == OFF)) {
			led->engine.on_off =
				blink12[led->engine.current_blink_step];
			/* advance in blink _code */
			led->engine.current_blink_step++;
		}

		/* all looping and switching states are treated here */
		if (blink12[led->engine.current_blink_step] == GOTO_BLINK1) {
			led->engine.current_blink_step = 0;
			led->engine.blink1_blink2 = 0;
			led->engine.param_cnt = led->engine.param1;
		} else if (blink12[led->engine.current_blink_step] ==
			   REPEAT_GOTO_BLINK2) {
			led->engine.current_blink_step = 0;
			/* repeat blink1 param1 times */
			if (led->engine.param_cnt) {
				led->engine.param_cnt--;
			}
			/* goto blink2 */
			if (led->engine.param_cnt == 0) {
				led->engine.param_cnt = led->engine.param2;
				led->engine.blink1_blink2 = 1;
			}
		} else if (blink12[led->engine.current_blink_step] ==
			   GOTO_BLINK2) {
			led->engine.current_blink_step = 0;
			led->engine.blink1_blink2 = 1;
			led->engine.param_cnt = led->engine.param2;
		} else if (blink12[led->engine.current_blink_step] ==
			   REPEAT_GOTO_BLINK1) {
			led->engine.current_blink_step = 0;
			/* repeat blink2 param2 times */
			if (led->engine.param_cnt) {
				led->engine.param_cnt--;
			}
			/* goto blink0 */
			if (led->engine.param_cnt == 0) {
				led->engine.param_cnt = led->engine.param1;
				led->engine.blink1_blink2 = 0;
			}
		}
	}

	// Second, move through all to output values
	list_for_each_entry (led, &all_leds, engine.list) {
		struct led_color color = { 0 };
		int ret;

		if (led->engine.on_off)
			color = led->code.color;

		// Sadly, some low-level gpio handlers are really expensive,
		// therefore we avoid calling them with the same value multiple
		// times.
		if (!led_color_equals(led->engine.last_color, color))
			ret = led->out(led, color);

		// Only store if setting was successful
		if (!ret)
			led->engine.last_color = color;
	}

	list_for_each_entry (button, &all_buttons, engine.list) {
		int state = button->in(button);

		if (button->engine.state == state)
			continue;

		avm_hui_button_input(button->handle, state > 0);

		button->engine.state = state;
	}
}

static void hui_generic_led_handler(struct blink_code code, void *ctx)
{
	struct hui_generic_led *led = ctx;
	struct hui_generic_led *other;

	if (blink_code_equals(led->code, code))
		return;

	pr_debug("Set code %d (%d, %d; %02x%02x%02x) for <%s>\n", code.type,
		 code.params[0], code.params[1], code.color.c[0],
		 code.color.c[1], code.color.c[2], led->name);

	led->engine.param1 = code.params[0];
	led->engine.param2 = code.params[1];
	led->engine._code = code.type;
	led->engine.param_cnt = 0;
	led->engine.current_blink_step = 0;
	led->engine.blink1_blink2 = 0;
	led->code = code;

	/* make blinking per state synchronized, find led with same code and
	 * param and copy values */
	list_for_each_entry (other, &all_leds, engine.list) {
		if (led == other)
			continue;

		if (other->engine._code == led->engine._code &&
		    other->engine.param1 == led->engine.param1 &&
		    other->engine.param2 == led->engine.param2) {
			led->engine.on_off = other->engine.on_off;
			led->engine.param_cnt = other->engine.param_cnt;
			led->engine.current_blink_step =
				other->engine.current_blink_step;
			led->engine.blink1_blink2 = other->engine.blink1_blink2;
			break;
		}
	}
}

static void raw_out(struct led_color color, void *ctx)
{
	struct hui_generic_led *led = ctx;

	led->out(led, color);
}

struct avm_hui_led_ops hui_generic_ops = {
	.out = hui_generic_led_handler,
	.raw_out = raw_out,
};

static bool is_running(void)
{
	return !list_empty(&all_leds) || !list_empty(&all_buttons);
}

int hui_generic_blink_add_led(struct hui_generic_led *led)
{
	int running = is_running();

	/*
	 * Initialize with odd values to trigger at least one call at the
	 * beginning.
	 *
	 * Brightness zero and other components set should not happen normally.
	 */
	led->engine.last_color.brightness = 0x0;
	led->engine.last_color.c[0] = 0xFF;
	led->engine.last_color.c[1] = 0xFF;
	led->engine.last_color.c[2] = 0xFF;

	list_add_tail(&led->engine.list, &all_leds);

	if (!running && is_running()) {
		pr_debug("Start blink timer\n");
		mod_timer(&blink_timer, jiffies + msecs_to_jiffies(125));
	}

	return 0;
}

int hui_generic_blink_add_button(struct hui_generic_button *button)
{
	int running = is_running();

	list_add_tail(&button->engine.list, &all_buttons);

	if (!running && is_running()) {
		pr_debug("Start blink timer\n");
		mod_timer(&blink_timer, jiffies + msecs_to_jiffies(125));
	}

	return 0;
}