#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <inttypes.h>
#include <ctype.h>
#include <errno.h>
#include <pwd.h>
#include CURSESINC
#include "colors.h"
#include "gettext_curses.h"
#include "utils.h"
#include "curskey.h"
#include "bindings.h"
#include "mixer_widget.h"

#define ERROR_CONFIG (-1)
#define ERROR_MISSING_ARGUMENTS (-2)
#define ERROR_TOO_MUCH_ARGUMENTS (-3)

static const char *error_message;
static const char *error_cause;

static int strlist_index(const char *haystack, unsigned int itemlen, const char *needle) {
	unsigned int needle_len;
	unsigned int pos;
	const char *found;

	needle_len = strlen(needle);
	if (needle_len <= itemlen && needle[needle_len - 1] != ' ') {
		found = strstr(haystack, needle);
		if (found) {
			pos = (found - haystack);
			if (pos % itemlen == 0 && (needle_len == itemlen || haystack[pos+needle_len] == ' '))
				return pos / itemlen;
		}
	}

	return -1;
}

static int color_by_name(const char *name) {
	return strlist_index(
		"default"
		"black  "
		"red    "
		"green  "
		"yellow "
		"blue   "
		"magenta"
		"cyan   "
		"white  ", 7, name) - 1;
};

static int attr_by_name(const char *name) {
	return (int[]) {
		-1,
		A_BOLD,
		A_REVERSE,
		A_STANDOUT,
		A_DIM,
		A_UNDERLINE,
#ifdef A_ITALIC
		A_ITALIC,
#endif
		A_NORMAL,
		A_BLINK,
	}[strlist_index(
		"bold     "
		"reverse  "
		"standout "
		"dim      "
		"underline"
#ifdef A_ITALIC
		"italic   "
#endif
		"normal   "
		"blink    ", 9, name) + 1];
};

#define W_NUMBER (1U << 0)

enum textbox_word {
	TW_BOTTOM = (1U << 1),
	TW_CLOSE = (1U << 2),
	TW_DOWN = (1U << 3),
	TW_LEFT = (1U << 4),
	TW_PAGE = (1U << 5),
	TW_RIGHT = (1U << 6),
	TW_TOP = (1U << 7),
	TW_UP = (1U << 8),
};

const char *textbox_words =
	"bottom"
	"close "
	"down  "
	"left  "
	"page  "
	"right "
	"top   "
	"up    ";

enum mixer_word {
	MW_ALL = (1U << 1),
	MW_BALANCE = (1U << 2),
	MW_CAPTURE = (1U << 3),
	MW_CARD = (1U << 4),
	MW_CLOSE = (1U << 5),
	MW_CONTROL = (1U << 6),
	MW_DOWN = (1U << 7),
	MW_FOCUS = (1U << 8),
	MW_HELP = (1U << 9),
	MW_INFORMATION = (1U << 10),
	MW_LEFT = (1U << 11),
	MW_MODE = (1U << 12),
	MW_MUTE = (1U << 13),
	MW_NEXT = (1U << 14),
	MW_PLAYBACK = (1U << 15),
	MW_PREVIOUS = (1U << 16),
	MW_REFRESH = (1U << 17),
	MW_RIGHT = (1U << 18),
	MW_SELECT = (1U << 19),
	MW_SET = (1U << 20),
	MW_SYSTEM = (1U << 21),
	MW_TOGGLE = (1U << 22),
	MW_UP = (1U << 23),
};

const char *mixer_words =
	"all        "
	"balance    "
	"capture    "
	"card       "
	"close      "
	"control    "
	"down       "
	"focus      "
	"help       "
	"information"
	"left       "
	"mode       "
	"mute       "
	"next       "
	"playback   "
	"previous   "
	"refresh    "
	"right      "
	"select     "
	"set        "
	"system     "
	"toggle     "
	"up         ";

static unsigned int parse_words(const char *name, const char* wordlist, unsigned int itemlen, unsigned int *number) {
	unsigned int words = 0;
	unsigned int word;
	unsigned int i;
	char buf[16];
	char *endptr;

	while (*name) {
		for (i = 0; i < sizeof(buf) - 1; ++i) {
			if (*name == '\0')
				break;
			if (*name == '_') {
				++name;
				break;
			}
			buf[i] = *name;
			++name;
		}
		buf[i] = '\0';

		if (buf[0] >= '0' && buf[0] <= '9') {
			if (number) {
				*number = strtoumax(buf, &endptr, 10);
				if (*endptr != '\0')
					return 0;
			}
			word = W_NUMBER;
		}
		else if ((i = strlist_index(wordlist, itemlen, buf)) >= 0)
			word = 2U << i;
		else
			return 0;

		if (words & word) // no duplicate words
			return 0;
		words |= word;
	}

	return words;
}

static int textbox_command_by_name(const char *name) {
	switch (parse_words(name, textbox_words, 6, NULL)) {
		case TW_TOP: return CMD_TEXTBOX_TOP;
		case TW_BOTTOM: return CMD_TEXTBOX_BOTTOM;
		case TW_CLOSE: return CMD_TEXTBOX_CLOSE;
		case TW_UP: return CMD_TEXTBOX_UP;
		case TW_DOWN: return CMD_TEXTBOX_DOWN;
		case TW_LEFT: return CMD_TEXTBOX_LEFT;
		case TW_RIGHT: return CMD_TEXTBOX_RIGHT;
		case TW_PAGE|TW_UP: return CMD_TEXTBOX_PAGE_UP;
		case TW_PAGE|TW_DOWN: return CMD_TEXTBOX_PAGE_DOWN;
		case TW_PAGE|TW_LEFT: return CMD_TEXTBOX_PAGE_LEFT;
		case TW_PAGE|TW_RIGHT: return CMD_TEXTBOX_PAGE_RIGHT;
		default: return 0;
	}
}

static int mixer_command_by_name(const char *name) {
	unsigned int channel = 0;
	unsigned int number = 1; // default numeric arg
	unsigned int words = parse_words(name, mixer_words, 11, &number);

	switch (words) {
		case MW_HELP: return CMD_MIXER_HELP;
		case MW_CLOSE: return CMD_MIXER_CLOSE;
		case MW_REFRESH: return CMD_MIXER_REFRESH;
		case MW_SELECT|MW_CARD: return CMD_MIXER_SELECT_CARD;
		case MW_SYSTEM|MW_INFORMATION: return CMD_MIXER_SYSTEM_INFORMATION;
		case MW_MODE|MW_ALL: return CMD_WITH_ARG(CMD_MIXER_SET_VIEW_MODE, VIEW_MODE_ALL);
		case MW_MODE|MW_CAPTURE: return CMD_WITH_ARG(CMD_MIXER_SET_VIEW_MODE, VIEW_MODE_CAPTURE);
		case MW_MODE|MW_PLAYBACK: return CMD_WITH_ARG(CMD_MIXER_SET_VIEW_MODE, VIEW_MODE_PLAYBACK);
		case MW_MODE|MW_TOGGLE: return CMD_MIXER_TOGGLE_VIEW_MODE;
		case MW_CONTROL|MW_BALANCE: return CMD_MIXER_BALANCE_CONTROL;
		case MW_NEXT:
		case MW_NEXT|W_NUMBER:
		case MW_PREVIOUS:
		case MW_PREVIOUS|W_NUMBER:
			return ((number < 1 || number > 511) ? 0 :
					CMD_WITH_ARG((words & MW_NEXT
							? CMD_MIXER_NEXT
							: CMD_MIXER_PREVIOUS), number));
		case MW_CONTROL|MW_FOCUS|W_NUMBER:
			return ((number < 1 || number > 512) ? 0 :
					CMD_WITH_ARG(CMD_MIXER_FOCUS_CONTROL, number - 1));
	}

	if (words & MW_LEFT)
		channel |= LEFT;
	if (words & MW_RIGHT)
		channel |= RIGHT;
	if (!channel)
		channel = LEFT|RIGHT;

	switch (words & ~(MW_LEFT|MW_RIGHT)) {
		case MW_CONTROL|MW_UP:
		case MW_CONTROL|MW_UP|W_NUMBER:
		case MW_CONTROL|MW_DOWN:
		case MW_CONTROL|MW_DOWN|W_NUMBER:
			return ((number < 1 || number > 100) ? 0 :
					CMD_WITH_ARG((words & MW_UP
						 ? CMD_MIXER_CONTROL_UP_LEFT
						 : CMD_MIXER_CONTROL_DOWN_LEFT) + channel - 1, number));
		case MW_CONTROL|MW_SET|W_NUMBER:
			return (number > 100 ? 0 :
					CMD_WITH_ARG(CMD_MIXER_CONTROL_SET_PERCENT_LEFT + channel - 1, number));
		case MW_TOGGLE|MW_MUTE:
			return CMD_WITH_ARG(CMD_MIXER_TOGGLE_MUTE, channel);
		case MW_TOGGLE|MW_CAPTURE:
			return CMD_WITH_ARG(CMD_MIXER_TOGGLE_CAPTURE, channel);
	}

	return 0;
}

static int* element_by_name(const char *name) {
	int idx = strlist_index(
#ifdef TRICOLOR_VOLUME_BAR
		"ctl_bar_hi        "
#endif
		"ctl_bar_lo        "
#ifdef TRICOLOR_VOLUME_BAR
		"ctl_bar_mi        "
#endif
		"ctl_capture       "
		"ctl_frame         "
		"ctl_inactive      "
		"ctl_label         "
		"ctl_label_focus   "
		"ctl_label_inactive"
		"ctl_mark_focus    "
		"ctl_mute          "
		"ctl_nocapture     "
		"ctl_nomute        "
		"errormsg          "
		"infomsg           "
		"menu              "
		"menu_selected     "
		"mixer_active      "
		"mixer_frame       "
		"mixer_text        "
		"textbox           "
		"textfield         ", 18, name);

	if (idx < 0) {
#ifndef TRICOLOR_VOLUME_BAR
		if (strlist_index(
			"ctl_bar_hi"
			"ctl_bar_mi", 10, name) >= 0)
			return &errno; // dummy element
#endif
		return NULL;
	}

	return &( ((int*) &attrs)[idx] );
}

static int cfg_bind(char **argv, unsigned int argc) {
	const char *command_name;
	command_enum command = 0;
	unsigned int i;
	int keys[3] = { -1, -1, -1 };
	union {
		command_enum *mixer_bindings;
		uint8_t *textbox_bindings;
	} bind_to = {
		.mixer_bindings = mixer_bindings
	};

	if (argc == 2)
		command_name = argv[1];
	else if (argc == 3) {
		command_name = argv[2];

		if (! strcmp(argv[1], "textbox")) {
			bind_to.textbox_bindings = textbox_bindings;
		}
		else if (! strcmp(argv[1], "mixer"))
			; // bind_to.mixer_bindings = mixer_bindings
		else {
			error_message = _("invalid widget");
			error_cause = argv[1];
			return ERROR_CONFIG;
		}
	}
	else {
		return (argc < 2 ? ERROR_MISSING_ARGUMENTS : ERROR_TOO_MUCH_ARGUMENTS);
	}

	keys[0] = curskey_parse(argv[0]);
	if (keys[0] < 0 || keys[0] >= ARRAY_SIZE(mixer_bindings)) {
		error_message = _("invalid key");
		error_cause = argv[0];
		return ERROR_CONFIG;
	}

	if (keys[0] == KEY_ENTER || keys[0] == '\n' || keys[0] == '\r') {
		keys[0] = KEY_ENTER;
		keys[1] = '\n';
		keys[2] = '\r';
	}

	if (bind_to.textbox_bindings == textbox_bindings)
		command = textbox_command_by_name(command_name);
	else
		command = mixer_command_by_name(command_name);

	if (!command) {
		if (!strcmp(command_name, "none"))
			; // command = 0
		else {
			error_message = _("invalid command");
			error_cause = command_name;
			return ERROR_CONFIG;
		}
	}

	for (i = 0; i < ARRAY_SIZE(keys) && keys[i] != -1; ++i) {
		if (bind_to.textbox_bindings == textbox_bindings)
			bind_to.textbox_bindings[keys[i]] = command;
		else
			bind_to.mixer_bindings[keys[i]] = command;
	}

	return 0;
}

static int cfg_color(char **argv, unsigned int argc)
{
	short fg_color, bg_color;
	unsigned int i;
	int *element;
	int attr;

	if (argc < 3)
		return ERROR_MISSING_ARGUMENTS;

	if (NULL == (element = element_by_name(argv[0]))) {
		error_message = _("unknown theme element");
		error_cause = argv[0];
		return ERROR_CONFIG;
	}

	if (-2 == (fg_color = color_by_name(argv[1]))) {
		error_message = _("unknown color");
		error_cause = argv[1];
		return ERROR_CONFIG;
	}

	if (-2 == (bg_color = color_by_name(argv[2]))) {
		error_message = _("unknown color");
		error_cause = argv[2];
		return ERROR_CONFIG;
	}

	*element = get_color_pair(fg_color, bg_color);

	for (i = 3; i < argc; ++i) {
		if (-1 == (attr = attr_by_name(argv[i]))) {
			error_message = _("unknown color attribute");
			error_cause = argv[i];
			return ERROR_CONFIG;
		}
		else
			*element |= attr;
	}
	return 0;
}

static int cfg_set(char **argv, unsigned int argc)
{
	char *endptr;

	if (argc == 2) {
		if (! strcmp(argv[0], "mouse_wheel_step")) {
			mouse_wheel_step = strtoumax(argv[1], &endptr, 10);
			if (mouse_wheel_step > 100 || *endptr != '\0') {
				mouse_wheel_step = 1;
				error_message = _("invalid value");
				error_cause = argv[1];
				return ERROR_CONFIG;
			}
		}
		else if (! strcmp(argv[0], "mouse_wheel_focuses_control")) {
			if ((argv[1][0] == '0' || argv[1][0] == '1') && argv[1][1] == '\0')
				mouse_wheel_focuses_control = argv[1][0] - '0';
			else {
				error_message = _("invalid value");
				error_cause = argv[1];
				return ERROR_CONFIG;
			}
		}
		else {
			error_message = _("unknown option");
			error_cause = argv[0];
			return ERROR_CONFIG;
		}
	}
	else {
		return (argc < 2 ? ERROR_MISSING_ARGUMENTS : ERROR_TOO_MUCH_ARGUMENTS);
	}

	return 0;
}

/* Split $line on whitespace, store it in $args, return the argument count.
 * Return 0 for commented lines ('\s*#').
 *
 * This will modify contents of $line.
 */
static unsigned int parse_line(char *line, char **args, unsigned int args_size)
{
	unsigned int count;

	for (count = 0; count < args_size; ++count) {
		while (*line && isspace(*line))
			++line;

		if (*line == '\0')
			break;

		if (*line == '#' && count == 0)
			break;

		args[count] = line;

		while (*line && !isspace(*line))
			++line;

		if (*line != '\0') {
			*line = '\0';
			++line;
		}
	}

	return count;
}

static int process_line(char *line) {
	char *args[16];
	unsigned int argc = parse_line(line, args, ARRAY_SIZE(args));
	int ret = 0;

	if (argc >= 1) {
		error_cause = NULL;
		//error_message = _("unknown error");

		if (argc >= ARRAY_SIZE(args))
			ret = ERROR_TOO_MUCH_ARGUMENTS;
		else {
			ret = strlist_index(
				"bind "
				"color"
				"set  ", 5, args[0]);
			switch (ret) {
				case 0: ret = cfg_bind(args + 1, argc - 1); break;
				case 1: ret = cfg_color(args + 1, argc - 1); break;
				case 2: ret = cfg_set(args + 1, argc - 1); break;
				default: error_message = _("unknown command");
			}
		}

		if (ret == ERROR_MISSING_ARGUMENTS)
			error_message = _("missing arguments");
		else if (ret == ERROR_TOO_MUCH_ARGUMENTS)
			error_message = _("too much arguments");
	}

	return ret;
}

void parse_config_file(const char *file_name)
{
	char *buf;
	unsigned int file_size;
	unsigned int lineno;
	unsigned int i;
	char *line;

	endwin(); // print warnings to stderr

	buf = read_file(file_name, &file_size);
	if (!buf) {
		fprintf(stderr, "%s: %s\n", file_name, strerror(errno));
		return;
	}

	curskey_init();
	curskey_define_meta_keys(128);

	lineno = 0;
	line = buf;
	for (i = 0; i < file_size; ++i) {
		if (buf[i] == '\n') {
			buf[i] = '\0';
			++lineno;
			if (process_line(line) < 0) {
				if (error_cause)
					fprintf(stderr, "%s:%d: %s: %s: %s\n", file_name, lineno, line, error_message, error_cause);
				else
					fprintf(stderr, "%s:%d: %s: %s\n", file_name, lineno, line, error_message);
			}
			line = &buf[i + 1];
		}
	}

	free(buf);
	curskey_destroy();
}

void parse_default_config_file() {
	char file[4096];
	const char *home;

	home = getenv("XDG_CONFIG_HOME");
	if (home && *home) {
		snprintf(file, sizeof(file), "%s/alsamixer.rc", home);
		if (! access(file, F_OK))
			return parse_config_file(file);
	}

	home = getenv("HOME");
	if (!home || !*home) {
		struct passwd *pwd = getpwuid(getuid());
		if (pwd)
			home = pwd->pw_dir;
	}

	if (home && *home) {
		snprintf(file, sizeof(file), "%s/.config/alsamixer.rc", home);
		if (! access(file, F_OK))
			return parse_config_file(file);

		snprintf(file, sizeof(file), "%s/.alsamixer.rc", home);
		if (! access(file, F_OK))
			return parse_config_file(file);
	}
}