#include <errno.h>
#include <stdbool.h>
#include <string.h>

#include <app_event_manager.h>

#define MODULE led_strip_module
#include <caf/events/button_event.h>
#include <caf/events/module_state_event.h>
#include <caf/events/power_event.h>
#include <caf/key_id.h>

#include <zephyr/device.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/led_strip.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>

#include "led_effect/led_effect.h"
#include "led_strip_en_event.h"
#include "module_lifecycle.h"
#include "theme_rgb_update_event.h"
#include "theme_color.h"

LOG_MODULE_REGISTER(MODULE, LOG_LEVEL_INF);

#define LED_STRIP_NODE DT_CHOSEN(zephyr_led_strip)
#define LED_STRIP_NUM_PIXELS DT_PROP(LED_STRIP_NODE, chain_length)
#define LED_STRIP_TICK_INTERVAL K_MSEC(20)

BUILD_ASSERT(DT_NODE_HAS_STATUS(LED_STRIP_NODE, okay),
	     "Missing zephyr,led-strip chosen node");
BUILD_ASSERT(DT_NODE_HAS_PROP(LED_STRIP_NODE, supply_gpios),
	     "Missing supply-gpios on zephyr,led-strip node");
BUILD_ASSERT(LED_STRIP_NUM_PIXELS == 17U,
	     "LED strip key map expects 17 pixels");

struct led_strip_module_ctx {
	struct module_lifecycle_ctx lc;
	const struct device *strip;
	struct gpio_dt_spec strip_en;
	struct led_rgb pixels[LED_STRIP_NUM_PIXELS];
	struct k_work_delayable effect_work;
	struct led_effect *effect;
	struct theme_rgb current_theme;
	bool enabled;
};

static const struct led_key_map led_key_map[] = {
	{ KEY_ID(0, 1), 0U },
	{ KEY_ID(1, 1), 1U },
	{ KEY_ID(2, 1), 2U },
	{ KEY_ID(3, 1), 3U },
	{ KEY_ID(0, 2), 4U },
	{ KEY_ID(1, 2), 5U },
	{ KEY_ID(2, 2), 6U },
	{ KEY_ID(0, 3), 7U },
	{ KEY_ID(1, 3), 8U },
	{ KEY_ID(2, 3), 9U },
	{ KEY_ID(3, 3), 10U },
	{ KEY_ID(0, 4), 11U },
	{ KEY_ID(1, 4), 12U },
	{ KEY_ID(2, 4), 13U },
	{ KEY_ID(0, 5), 14U },
	{ KEY_ID(1, 5), 15U },
	{ KEY_ID(3, 5), 16U },
};

static const struct led_effect_config effect_cfg = {
	.key_map = led_key_map,
	.key_map_len = ARRAY_SIZE(led_key_map),
	.pixel_count = LED_STRIP_NUM_PIXELS,
	.default_brightness = 0xFFU,
};

static int do_init(void);
static int do_start(void);
static int do_stop(void);

static const struct module_lifecycle_cfg lifecycle_cfg = {
	.mode = ML_MODE_POWER,
	.stopped_state = MODULE_STATE_STANDBY,
};

static const struct module_lifecycle_ops lifecycle_ops = {
	.do_init = do_init,
	.do_start = do_start,
	.do_stop = do_stop,
};

static struct led_strip_module_ctx ctx = {
	.lc = {
		.state = LC_UNINIT,
		.cfg = &lifecycle_cfg,
		.ops = &lifecycle_ops,
	},
	.strip = DEVICE_DT_GET(LED_STRIP_NODE),
	.strip_en = GPIO_DT_SPEC_GET(LED_STRIP_NODE, supply_gpios),
	.current_theme = {
		.r = BLINKY_THEME_DEFAULT_R,
		.g = BLINKY_THEME_DEFAULT_G,
		.b = BLINKY_THEME_DEFAULT_B,
	},
	.enabled = true,
};

static void clear_pixels(void)
{
	memset(ctx.pixels, 0, sizeof(ctx.pixels));
}

static int submit_frame(void)
{
	int err;

	err = led_strip_update_rgb(ctx.strip, ctx.pixels, ARRAY_SIZE(ctx.pixels));
	if (err) {
		LOG_WRN("led_strip_update_rgb failed (%d)", err);
	}

	return err;
}

static int set_strip_power(bool on)
{
	int err;

	err = gpio_pin_set_dt(&ctx.strip_en, on ? 1 : 0);
	if (err) {
		LOG_WRN("LED strip EN set failed (%d)", err);
	}

	return err;
}

static int refresh_idle_frame(void)
{
	clear_pixels();
	return submit_frame();
}

static void stop_effect_work(void)
{
	k_work_cancel_delayable(&ctx.effect_work);
}

static void schedule_effect_tick(k_timeout_t delay)
{
	k_work_reschedule(&ctx.effect_work, delay);
}

static int enable_strip_output(void)
{
	int err;

	err = set_strip_power(true);
	if (err) {
		return err;
	}

	return refresh_idle_frame();
}

static void disable_strip_output(void)
{
	stop_effect_work();
	clear_pixels();
	(void)submit_frame();
	(void)set_strip_power(false);
}

static void effect_work_handler(struct k_work *work)
{
	bool keep_running;

	ARG_UNUSED(work);

	if (!module_lifecycle_is_running(&ctx.lc) || !ctx.enabled ||
	    (ctx.effect == NULL)) {
		return;
	}

	keep_running = ctx.effect->ops->tick(ctx.effect,
					     k_ticks_to_ms_floor32(
						     LED_STRIP_TICK_INTERVAL.ticks),
					     ctx.pixels, ARRAY_SIZE(ctx.pixels));
	(void)submit_frame();

	if (keep_running) {
		schedule_effect_tick(LED_STRIP_TICK_INTERVAL);
	}
}

static int do_init(void)
{
	int err;

	if (!device_is_ready(ctx.strip)) {
		LOG_ERR("LED strip device %s not ready", ctx.strip->name);
		return -ENODEV;
	}

	if (!gpio_is_ready_dt(&ctx.strip_en)) {
		LOG_ERR("LED strip supply GPIO not ready");
		return -ENODEV;
	}

	err = gpio_pin_configure_dt(&ctx.strip_en, GPIO_OUTPUT_INACTIVE);
	if (err) {
		LOG_ERR("Failed to configure LED strip supply GPIO (%d)", err);
		return err;
	}

	k_work_init_delayable(&ctx.effect_work, effect_work_handler);
	clear_pixels();

	ctx.effect = led_effect_get_mutable(LED_EFFECT_ID_KEY_FADE);
	if ((ctx.effect == NULL) || (ctx.effect->ops == NULL)) {
		LOG_ERR("LED effect not available");
		return -ENOENT;
	}

	err = ctx.effect->ops->init(ctx.effect, &effect_cfg);
	if (err) {
		LOG_ERR("LED effect init failed (%d)", err);
		return err;
	}

	ctx.effect->ops->set_theme(ctx.effect, &ctx.current_theme);

	LOG_INF("LED strip ready len:%u", (uint32_t)led_strip_length(ctx.strip));
	return 0;
}

static int do_start(void)
{
	int err;

	if (module_lifecycle_is_running(&ctx.lc)) {
		return 0;
	}

	if (!ctx.enabled) {
		return 0;
	}

	err = enable_strip_output();
	return err;
}

static int do_stop(void)
{
	if (!module_lifecycle_is_running(&ctx.lc)) {
		return 0;
	}

	if ((ctx.effect != NULL) && (ctx.effect->ops != NULL)) {
		ctx.effect->ops->reset(ctx.effect);
	}

	disable_strip_output();
	return 0;
}

static bool handle_button_event(const struct button_event *event)
{
	if (!module_lifecycle_is_running(&ctx.lc) || !ctx.enabled ||
	    (ctx.effect == NULL) || !event->pressed) {
		return false;
	}

	ctx.effect->ops->on_key_press(ctx.effect, event->key_id);
	schedule_effect_tick(K_NO_WAIT);

	return false;
}

static bool handle_led_strip_en_event(const struct led_strip_en_event *event)
{
	ctx.enabled = event->enabled;

	if (!module_lifecycle_is_running(&ctx.lc)) {
		return false;
	}

	if (ctx.enabled) {
		int err = enable_strip_output();

		if (err) {
			LOG_WRN("LED strip enable request failed (%d)", err);
			ctx.enabled = false;
			return false;
		}
	} else {
		if ((ctx.effect != NULL) && (ctx.effect->ops != NULL)) {
			ctx.effect->ops->reset(ctx.effect);
		}

		disable_strip_output();
	}

	return false;
}

static bool handle_theme_rgb_update_event(const struct theme_rgb_update_event *event)
{
	ctx.current_theme = event->theme;

	if ((ctx.effect != NULL) && (ctx.effect->ops != NULL)) {
		ctx.effect->ops->set_theme(ctx.effect, &ctx.current_theme);
	}

	if (module_lifecycle_is_running(&ctx.lc) && ctx.enabled &&
	    (ctx.effect != NULL) && ctx.effect->ops->is_active(ctx.effect)) {
		schedule_effect_tick(K_NO_WAIT);
	}

	return false;
}

static bool app_event_handler(const struct app_event_header *aeh)
{
	if (is_button_event(aeh)) {
		return handle_button_event(cast_button_event(aeh));
	}

	if (is_led_strip_en_event(aeh)) {
		return handle_led_strip_en_event(cast_led_strip_en_event(aeh));
	}

	if (is_theme_rgb_update_event(aeh)) {
		return handle_theme_rgb_update_event(cast_theme_rgb_update_event(aeh));
	}

	if (is_module_state_event(aeh)) {
		const struct module_state_event *event = cast_module_state_event(aeh);

		if (check_state(event, MODULE_ID(main), MODULE_STATE_READY)) {
			(void)module_set_lifecycle(&ctx.lc, LC_RUNNING);
		}

		return false;
	}

	if (is_power_down_event(aeh)) {
		if (module_lifecycle_is_initialized(&ctx.lc)) {
			(void)module_set_lifecycle(&ctx.lc, LC_STOPPED);
		}

		return false;
	}

	if (is_wake_up_event(aeh)) {
		if (module_lifecycle_is_initialized(&ctx.lc)) {
			(void)module_set_lifecycle(&ctx.lc, LC_RUNNING);
		}

		return false;
	}

	return false;
}

APP_EVENT_LISTENER(MODULE, app_event_handler);
APP_EVENT_SUBSCRIBE_EARLY(MODULE, button_event);
APP_EVENT_SUBSCRIBE(MODULE, led_strip_en_event);
APP_EVENT_SUBSCRIBE(MODULE, module_state_event);
APP_EVENT_SUBSCRIBE(MODULE, theme_rgb_update_event);
APP_EVENT_SUBSCRIBE_EARLY(MODULE, power_down_event);
APP_EVENT_SUBSCRIBE(MODULE, wake_up_event);