#include <stdlib.h>
#include "cli.h"
#include "bk_gpio.h"
#include <driver/gpio.h>
#include <driver/hal/hal_gpio_types.h>
#include "gpio_driver.h"

static void cli_gpio_help(void)
{
	CLI_LOGI("gpio_driver [init/deinit] \r\n");

	CLI_LOGI("gpio    [set_config/input_pulldown/input_pullup////]    only in set_sonfig:[io_mode]    [pull mode] \r\n");
	CLI_LOGI("gpio    [output/input]    [gpio_pin]    [pullup/pulldown] \r\n");
	CLI_LOGI("gpio    [output_high/output_low/input_get]    [gpio_pin] \r\n");
	CLI_LOGI("gpio_map    [sdio_map/spi_map]     [mode]\r\n");
	CLI_LOGI("gpio_int    [index]    [inttype/start/stop]    [low/high_level/rising/falling edge]\r\n");
#if CONFIG_GPIO_DYNAMIC_WAKEUP_SUPPORT
	CLI_LOGI("gpio_wake    [index][low/high_level/rising/falling edge][enable/disable wakeup]\r\n");
	CLI_LOGI("gpio_low_power    [simulate][param]\r\n");
	CLI_LOGI("gpio_kpsta [register/unregister][index][io_mode][pull_mode][func_mode]\r\n");
#endif
#if CONFIG_GPIO_SIMULATE_UART_WRITE
	CLI_LOGI("gpio_uart_write    [index][div(baud_rate=1Mbps/(1+div))][string(len < 8)]\r\n");
#endif
}

static void cli_gpio_driver_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
	if (argc < 2)
	{
		cli_gpio_help();
		return;
	}

	if (os_strcmp(argv[1], "init") == 0) {
		BK_LOG_ON_ERR(bk_gpio_driver_init());
		CLI_LOGI("gpio init\n");
	} else if(os_strcmp(argv[1], "deinit") == 0) {
		BK_LOG_ON_ERR(bk_gpio_driver_deinit());
		CLI_LOGI("gpio deinit\n");
	} else {
		cli_gpio_help();
		return;
	}
}



static void cli_gpio_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
	if (argc < 2) {
		cli_gpio_help();
		return;
	}

	 if (os_strcmp(argv[1], "set_config") == 0) {
		gpio_id_t id;
		id = os_strtoul(argv[2], NULL, 10);

		gpio_config_t mode;

		mode.io_mode = os_strtoul(argv[3], NULL, 10);
		mode.pull_mode = os_strtoul(argv[4], NULL, 10);
		BK_LOG_ON_ERR(bk_gpio_set_config(id, &mode));

		CLI_LOGI("gpio io(output/disable/input): %x ,  pull(disable/down/up) : %x\n", mode.io_mode, mode.pull_mode);

	} else if (os_strcmp(argv[1], "output") == 0) {
		gpio_id_t id;

		id = os_strtoul(argv[2], NULL, 10);

		BK_LOG_ON_ERR(bk_gpio_disable_input(id));
		BK_LOG_ON_ERR(bk_gpio_enable_output(id));

		if (os_strcmp(argv[3], "pull_up") == 0) {
			BK_LOG_ON_ERR(bk_gpio_enable_pull(id));
			BK_LOG_ON_ERR(bk_gpio_pull_up(id));
		}else if (os_strcmp(argv[3], "pull_down") == 0) {
			BK_LOG_ON_ERR(bk_gpio_enable_pull(id));
			BK_LOG_ON_ERR(bk_gpio_pull_down(id));
		} else {
			BK_LOG_ON_ERR(bk_gpio_disable_pull(id));
		}

		CLI_LOGI("gpio output test: %d \n", id);

	}else if (os_strcmp(argv[1], "input") == 0) {
		gpio_id_t id;

		id = os_strtoul(argv[2], NULL, 10);

		BK_LOG_ON_ERR(bk_gpio_disable_output(id));
		BK_LOG_ON_ERR(bk_gpio_enable_input(id));

		if (os_strcmp(argv[3], "pull_up") == 0) {
			BK_LOG_ON_ERR(bk_gpio_enable_pull(id));
			BK_LOG_ON_ERR(bk_gpio_pull_up(id));
		}else if (os_strcmp(argv[3], "pull_down") == 0) {
			BK_LOG_ON_ERR(bk_gpio_enable_pull(id));
			BK_LOG_ON_ERR(bk_gpio_pull_down(id));
		} else {
			BK_LOG_ON_ERR(bk_gpio_disable_pull(id));
		}

		CLI_LOGI("gpio input test: %d \n", id);

	}else if (os_strcmp(argv[1], "output_high") == 0) {
		gpio_id_t id;

		id = os_strtoul(argv[2], NULL, 10);

		// must set gpio mode before gpio output test
		BK_LOG_ON_ERR(bk_gpio_set_output_high(id));

		CLI_LOGI("gpio output high\n");
	}else if (os_strcmp(argv[1], "output_low") == 0) {
		gpio_id_t id;

		id = os_strtoul(argv[2], NULL, 10);

		// must set gpio mode before gpio output test
		BK_LOG_ON_ERR(bk_gpio_set_output_low(id));

		CLI_LOGI("gpio output low\n");
	} else if (os_strcmp(argv[1], "input_get") == 0) {
		gpio_id_t id;

		id = os_strtoul(argv[2], NULL, 10);

		// must set gpio mode before gpio output test
		uint8_t input_value = bk_gpio_get_input(id);

		CLI_LOGI("gpio input value is %x\r\n", input_value);
	} else {
		cli_gpio_help();
		return;
	}
}


static void cli_gpio_map_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
	if (argc < 2) {
		cli_gpio_help();
		return;
	}
	 uint8 mode = 0;

	 if (os_strcmp(argv[1], "devs") == 0) {
		gpio_id_t id = 0;

		id = os_strtoul(argv[2], NULL, 10);
		mode = os_strtoul(argv[3], NULL, 10);

		gpio_dev_unmap(id);
		gpio_dev_map(id, mode);
	} else if (os_strcmp(argv[1], "jtag_map") == 0) {
		gpio_id_t id = 0;

		id = os_strtoul(argv[2], NULL, 10);
		gpio_dev_unmap(id);

		if (os_strcmp(argv[3], "tck") == 0) {
			CLI_LOGI("gpio set JTAG_TCK\r\n");
			gpio_dev_map(id, GPIO_DEV_JTAG_TCK);
		} else if(os_strcmp(argv[3], "tms") == 0) {
			CLI_LOGI("gpio set JTAG_TMS\r\n");
			gpio_dev_map(id, GPIO_DEV_JTAG_TMS);
		} else if(os_strcmp(argv[3], "tdi") == 0) {
			CLI_LOGI("gpio set JTAG_TDI\r\n");
			gpio_dev_map(id, GPIO_DEV_JTAG_TDI);
		} else if(os_strcmp(argv[3], "tdo") == 0) {
			CLI_LOGI("gpio set JTAG_TDO\r\n");
			gpio_dev_map(id, GPIO_DEV_JTAG_TDO);
		} else {
			cli_gpio_help();
			return;
		}
	}
#if ((CONFIG_SOC_BK7271) ||(CONFIG_SOC_BK7251) )
	 else if (os_strcmp(argv[1], "sdio_map") == 0) {

		mode = os_strtoul(argv[2], NULL, 10);
		BK_LOG_ON_ERR(gpio_sdio_sel(mode));
	 } else if (os_strcmp(argv[1], "spi_map") == 0){
		 mode = os_strtoul(argv[2], NULL, 10);
		 BK_LOG_ON_ERR(gpio_spi_sel(mode));
	 }
#if (CONFIG_SOC_BK7271)
	else if (os_strcmp(argv[1], "uart2_map") == 0) {

		mode = os_strtoul(argv[2], NULL, 10);
		BK_LOG_ON_ERR(gpio_uart2_sel(mode));
	 } else if (os_strcmp(argv[1], "pwms_map") == 0){
		 mode = os_strtoul(argv[2], NULL, 10);
		 uint32 channel = os_strtoul(argv[3], NULL, 10);
		BK_LOG_ON_ERR(gpio_pwms_sel(channel,mode));
	 }

#endif
#endif
	else {
		cli_gpio_help();
		return;
	}
}

#if CONFIG_GPIO_DYNAMIC_WAKEUP_SUPPORT
static void cli_gpio_set_wake_source_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
	if (argc < 4) {
		cli_gpio_help();
		return;
	}

	gpio_id_t id = 0;
	uint32_t mode = 0;

	id = os_strtoul(argv[2], NULL, 10);
	mode = os_strtoul(argv[3], NULL, 10);

	if(os_strcmp(argv[1], "register") == 0)
		bk_gpio_register_wakeup_source(id, mode);
	else if(os_strcmp(argv[1], "unregister") == 0)
		bk_gpio_unregister_wakeup_source(id);
	else if(os_strcmp(argv[1], "get_id") == 0)
		CLI_LOGI("GET wakeup gpio id: %d\r\n", bk_gpio_get_wakeup_gpio_id());
	else
		return cli_gpio_help();
}

static void cli_gpio_set_keep_status_config(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
	if (argc < 2) {
		cli_gpio_help();
		return;
	}

	gpio_id_t gpio_id = 0;
	gpio_config_t config;

	gpio_id = os_strtoul(argv[2], NULL, 10);

	if(argc > 3)
		config.io_mode = os_strtoul(argv[3], NULL, 10);
	else
		config.io_mode = GPIO_IO_DISABLE;

	if(argc > 4)
		config.pull_mode = os_strtoul(argv[4], NULL, 10);
	else
		config.pull_mode = GPIO_PULL_DISABLE;

	if(argc > 5)
		config.func_mode = os_strtoul(argv[5], NULL, 10);
	else
		config.func_mode = GPIO_SECOND_FUNC_DISABLE;


	if(os_strcmp(argv[1], "register") == 0) {
		CLI_LOGI("cli_gpio_set_keep_status_config register gpio_id: %d\r\n", gpio_id);
		bk_gpio_register_lowpower_keep_status(gpio_id, &config);
	} else if(os_strcmp(argv[1], "unregister") == 0) {
		CLI_LOGI("cli_gpio_set_keep_status_config unregister gpio_id: %d\r\n", gpio_id);
		bk_gpio_unregister_lowpower_keep_status(gpio_id);
	} else
		return cli_gpio_help();



}

static void cli_gpio_simulate_low_power_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
	if (argc < 3) {
		cli_gpio_help();
		return;
	}

	uint32_t param = 0;

	param = os_strtoul(argv[2], NULL, 10);

	if(os_strcmp(argv[1], "simulate") == 0)
	{
		uint32_t int_level = 0;

		//if param == 0x534b4950 == "SKIP" == 1,397,442,896
		//means not switch GPIO to low power status just do save and restore
		CLI_LOGD("mode:%d,0x%x\n", param, param);
		int_level = rtos_enter_critical();
		gpio_enter_low_power((void *)param);
		rtos_exit_critical(int_level);

		//TODO:simulate sytem entry low voltage.

		int_level = rtos_enter_critical();
		gpio_exit_low_power((void *)param);
		rtos_exit_critical(int_level);
		return;
	}
	else
		return cli_gpio_help();
}
#endif


#if CONFIG_GPIO_SIMULATE_UART_WRITE
static void cli_gpio_simulate_uart_write_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
	uint32_t id = 0, div = 0;
	uint32_t len = 8;

	if (argc < 4) {
		cli_gpio_help();
		return;
	}

	id = os_strtoul(argv[1], NULL, 10);
	div = os_strtoul(argv[2], NULL, 10);
	if(len > strlen(argv[3]))
		len = strlen(argv[3]);
	gpio_simulate_uart_write((uint8_t *)argv[3], len, id, div);
}
#endif

static void cli_gpio_int_isr(gpio_id_t id)
{
	CLI_LOGI("gpio isr index:%d\n",id);
	bk_gpio_clear_interrupt(id);
}

static void cli_gpio_retention_test_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
#if CONFIG_GPIO_RETENTION_SUPPORT
	gpio_id_t gpio_id = GPIO_24;
	GPIO_UP(gpio_id);

#if !CONFIG_GPIO_RETENTION_DISPOSABLE
	if (argc == 2)
	{
		uint32_t en = os_strtoul(argv[1], NULL, 10);
		if (en)
			bk_gpio_retention_set(gpio_id, GPIO_OUTPUT_STATE_HIGH);
		else
			bk_gpio_retention_clr(gpio_id);
	}
	else
#endif
	{
		bk_gpio_retention_set(gpio_id, GPIO_OUTPUT_STATE_HIGH);
	}
#endif

	bk_reboot();
}

static void cli_gpio_int_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
{
	uint32_t id;
	gpio_config_t cfg;

	cfg.io_mode =GPIO_INPUT_ENABLE;

	if (argc < 2) {
		cli_gpio_help();
		return;
	}

	id = os_strtoul(argv[1], NULL, 10);

	if (os_strcmp(argv[2], "intype") == 0) {
		CLI_RET_ON_INVALID_ARGC(argc, 4);
		gpio_int_type_t int_type = 0;
		if (os_strcmp(argv[3], "low_level") == 0) {
			int_type = GPIO_INT_TYPE_LOW_LEVEL;
			cfg.pull_mode = GPIO_PULL_UP_EN;
			bk_gpio_set_config(id, &cfg);
		} else if (os_strcmp(argv[3], "high_level") == 0) {
			int_type = GPIO_INT_TYPE_HIGH_LEVEL;
			cfg.pull_mode = GPIO_PULL_DOWN_EN;
			bk_gpio_set_config(id, &cfg);
		}else if (os_strcmp(argv[3], "rising_edge") == 0) {
			int_type = GPIO_INT_TYPE_RISING_EDGE;
			cfg.pull_mode = GPIO_PULL_DOWN_EN;
			bk_gpio_set_config(id, &cfg);
		} else if (os_strcmp(argv[3], "falling_edge") == 0) {
			int_type = GPIO_INT_TYPE_FALLING_EDGE;
			cfg.pull_mode = GPIO_PULL_UP_EN;
			bk_gpio_set_config(id, &cfg);
		} else {
			cli_gpio_help();
			return;
		}
		bk_gpio_register_isr(id ,cli_gpio_int_isr);

		BK_LOG_ON_ERR(bk_gpio_set_interrupt_type(id, int_type));
		CLI_LOGI("gpio[%d] set int type:%x\n", id, int_type);
	} else if (os_strcmp(argv[2], "start") == 0) {
		BK_LOG_ON_ERR(bk_gpio_enable_interrupt(id));
	} else if (os_strcmp(argv[2], "stop") == 0) {
		BK_LOG_ON_ERR(bk_gpio_disable_interrupt(id));
		CLI_LOGI("gpio[%d] int  stop \r\n", id);

	} else {
		cli_gpio_help();
		return;
	}
}

#define GPIO_CMD_CNT (sizeof(s_gpio_commands) / sizeof(struct cli_command))
static const struct cli_command s_gpio_commands[] = {
	{"gpio_int", "gpio_int    [index]     [inttype/start/stop]     [low/high_level/rising/falling edge]", cli_gpio_int_cmd},
	{"gpio", "gpio     [set_mode/output_low/output_high/input/spi_mode]      [id]     [mode]", cli_gpio_cmd},
	{"gpio_driver", "gpio_driver    [init/deinit]}", cli_gpio_driver_cmd},
	{"gpio_map", "gpio_map     [sdio_map/spi_map]",cli_gpio_map_cmd},
#if CONFIG_GPIO_DYNAMIC_WAKEUP_SUPPORT
	{"gpio_wake", "gpio_wake [index][low/high_level/rising/falling edge][enable/disable wakeup]", cli_gpio_set_wake_source_cmd},
	{"gpio_kpsta", "gpio_kpsta [register/unregister][index][io_mode][pull_mode][func_mode]", cli_gpio_set_keep_status_config},
	{"gpio_low_power", "gpio_low_power [simulate][param]", cli_gpio_simulate_low_power_cmd},
#endif
	{"gpio_retention_test", "gpio_retention_test", cli_gpio_retention_test_cmd},
#if CONFIG_GPIO_SIMULATE_UART_WRITE
	{"gpio_uart_write", "[index][div(baud_rate=1Mbps/(1+div))][string]", cli_gpio_simulate_uart_write_cmd}
#endif

};

int cli_gpio_init(void)
{
	BK_LOG_ON_ERR(bk_gpio_driver_init());
	return cli_register_commands(s_gpio_commands, GPIO_CMD_CNT);
}