/*

 * card_select.c - select a card by list or device name

 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */

#include "aconfig.h"

#include <stdio.h>

#include <stdlib.h>

#include <assert.h>

#include <alsa/asoundlib.h>

#include <menu.h>

#include "gettext_curses.h"

#include "die.h"

#include "mem.h"

#include "utils.h"

#include "colors.h"

#include "widget.h"

#include "mixer_widget.h"

#include "device_name.h"

#include "card_select.h"

struct card {

	struct card *next;

	char *indexstr;

	char *name;

	char *device_name;

};

static struct widget list_widget;

static struct card first_card;

static ITEM **items;

static MENU *menu;

static ITEM *initial_item;

static void on_key_enter(void)

{

	ITEM *item = current_item(menu);

	if (item) {

		struct card *card = item_userptr(item);

		if (card->device_name) {

			if (select_card_by_name(card->device_name))

				list_widget.close();

		} else {

			create_device_name_form();

		}

	}

}

static void on_menu_key(int key)

{

	static const struct {

		int key;

		int request;

	} key_map[] = {

		{ KEY_DOWN, REQ_DOWN_ITEM },

		{ KEY_UP, REQ_UP_ITEM },

		{ KEY_HOME, REQ_FIRST_ITEM },

		{ KEY_NPAGE, REQ_SCR_DPAGE },

		{ KEY_PPAGE, REQ_SCR_UPAGE },

		{ KEY_BEG, REQ_FIRST_ITEM },

		{ KEY_END, REQ_LAST_ITEM },

	};

	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(key_map); ++i)

		if (key_map[i].key == key) {

			menu_driver(menu, key_map[i].request);

			break;

		}

}

static void on_handle_key(int key)

{

	switch (key) {

	case 27:

	case KEY_CANCEL:

	case 'q':

	case 'Q':

		list_widget.close();

		break;

	case 10:

	case 13:

	case KEY_ENTER:

		on_key_enter();

		break;

	default:

		on_menu_key(key);

		break;

	}

}

static bool create(void)

{

	int rows, columns;

	const char *title;

	if (screen_lines < 3 || screen_cols < 10) {

		beep();

		list_widget.close();

		return FALSE;

	}

	scale_menu(menu, &rows, &columns);

	rows += 2;

	columns += 2;

	if (rows > screen_lines)

		rows = screen_lines;

	if (columns > screen_cols)

		columns = screen_cols;

	widget_init(&list_widget, rows, columns, SCREEN_CENTER, SCREEN_CENTER,

		    attr_menu, WIDGET_BORDER | WIDGET_SUBWINDOW);

	title = _("Sound Card");

	mvwprintw(list_widget.window, 0, (columns - 2 - get_mbs_width(title)) / 2, " %s ", title);

	set_menu_win(menu, list_widget.window);

	set_menu_sub(menu, list_widget.subwindow);

	return TRUE;

}

static void on_window_size_changed(void)

{

	unpost_menu(menu);

	if (!create())

		return;

	post_menu(menu);

}

static void on_close(void)

{

	unsigned int i;

	struct card *card, *next_card;

	unpost_menu(menu);

	free_menu(menu);

	for (i = 0; items[i]; ++i)

		free_item(items[i]);

	free(items);

	for (card = first_card.next; card; card = next_card) {

		next_card = card->next;

		free(card->indexstr);

		free(card->name);

		free(card->device_name);

		free(card);

	}

	widget_free(&list_widget);

}

void close_card_select_list(void)

{

	on_close();

}

static struct widget list_widget = {

	.handle_key = on_handle_key,

	.window_size_changed = on_window_size_changed,

	.close = on_close,

};

static int get_cards(void)

{

	int count, number, err;

	snd_ctl_t *ctl;

	snd_ctl_card_info_t *info;

	char buf[16];

	struct card *card, *prev_card;

	first_card.indexstr = "-";

	first_card.name = _("(default)");

	first_card.device_name = "default";

	count = 1;

	snd_ctl_card_info_alloca(&info;;

	prev_card = &first_card;

	number = -1;

	for (;;) {

		err = snd_card_next(&number);

		if (err < 0)

			fatal_alsa_error(_("cannot enumerate sound cards"), err);

		if (number < 0)

			break;

		sprintf(buf, "hw:%d", number);

		err = snd_ctl_open(&ctl, buf, 0);

		if (err < 0)

			continue;

		err = snd_ctl_card_info(ctl, info);

		snd_ctl_close(ctl);

		if (err < 0)

			continue;

		card = ccalloc(1, sizeof *card);

		sprintf(buf, "%d", number);

		card->indexstr = cstrdup(buf);

		card->name = cstrdup(snd_ctl_card_info_get_name(info));

		sprintf(buf, "hw:%d", number);

		card->device_name = cstrdup(buf);

		prev_card->next = card;

		prev_card = card;

		++count;

	}

	card = ccalloc(1, sizeof *card);

	card->indexstr = cstrdup(" ");

	card->name = cstrdup(_("enter device name..."));

	prev_card->next = card;

	++count;

	return count;

}

static void create_list_items(int cards)

{

	int i;

	struct card *card;

	ITEM *item;

	initial_item = NULL;

	items = ccalloc(cards + 1, sizeof(ITEM*));

	i = 0;

	for (card = &first_card; card; card = card->next) {

		item = new_item(card->indexstr, card->name);

		if (!item)

			fatal_error("cannot create menu item");

		set_item_userptr(item, card);

		items[i++] = item;

		if (!initial_item &&

		    mixer_device_name &&

		    (!card->device_name ||

		     !strcmp(card->device_name, mixer_device_name)))

			initial_item = item;

	}

	assert(i == cards);

}

void create_card_select_list(void)

{

	int cards;

	cards = get_cards();

	create_list_items(cards);

	menu = new_menu(items);

	if (!menu)

		fatal_error("cannot create menu");

	set_menu_fore(menu, attr_menu_selected);

	set_menu_back(menu, attr_menu);

	set_menu_mark(menu, NULL);

	if (initial_item)

		set_current_item(menu, initial_item);

	set_menu_spacing(menu, 2, 1, 1);

	menu_opts_on(menu, O_SHOWDESC);

	if (!create())

		return;

	post_menu(menu);

}