/*  
   XMMS-SID - SIDPlay input plugin for X MultiMedia System (XMMS)

   Configuration dialog
   
   Written by Matti "ccr" Hamalainen <ccr@tnsp.org>
   
   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, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "xs_config.h"
#include <xmms/configfile.h>
#include <stdio.h>
#include "xs_glade.h"
#include "xs_interface.h"


/*
 * Global widgets
 */
static GtkWidget	*xs_configwin = NULL,
			*xs_sldb_fileselector = NULL,
			*xs_stil_fileselector = NULL;

#define LUW(x...)	lookup_widget(xs_configwin, ## x)


/*
 * Configuration specific stuff
 */
t_xs_cfg_item xs_cfgtable[] = {
	{ATYPE_INT,	&xs_cfg.fmtBitsPerSample,"bitsPerSample"},
	{ATYPE_INT,	&xs_cfg.fmtChannels,	"channels"},
	{ATYPE_INT,	&xs_cfg.fmtFrequency,	"frequency"},

	{ATYPE_BOOL,	&xs_cfg.mos8580,	"mos8580"},
	{ATYPE_BOOL,	&xs_cfg.emulateFilters,	"emulateFilters"},
	{ATYPE_FLOAT,	&xs_cfg.filterFs,	"filterFs"},
	{ATYPE_FLOAT,	&xs_cfg.filterFm,	"filterFm"},
	{ATYPE_FLOAT,	&xs_cfg.filterFt,	"filterFt"},
	{ATYPE_INT,	&xs_cfg.memoryMode,	"memoryMode"},
	{ATYPE_INT,	&xs_cfg.clockSpeed,	"clockSpeed"},
	{ATYPE_BOOL,	&xs_cfg.forceSpeed,	"forceSpeed"},

	{ATYPE_BOOL,	&xs_cfg.oversampleEnable,"oversampleEnable"},
	{ATYPE_INT,	&xs_cfg.oversampleFactor,"oversampleFactor"},

	{ATYPE_BOOL,	&xs_cfg.playMaxTimeEnable,"playMaxTimeEnable"},
	{ATYPE_INT,	&xs_cfg.playMaxTime,	"playMaxTime"},
	{ATYPE_BOOL,	&xs_cfg.songlenDBEnable,"songlenDBEnable"},
	{ATYPE_STR,	&xs_cfg.songlenDBPath,	"songlenDBPath"},

	{ATYPE_BOOL,	&xs_cfg.stilDBEnable,	"useSTIL"},
	{ATYPE_STR,	&xs_cfg.stilDBPath,	"STILpath"},

	{ATYPE_BOOL,	&xs_cfg.detectMagic,	"detectMagic"},

	{ATYPE_BOOL,	&xs_cfg.titleOverride,	"titleOverride"},
	{ATYPE_STR,	&xs_cfg.titleFormat,	"fileInfo"}
};

const gint XS_CFGTABLE_MAX = (sizeof(xs_cfgtable) / sizeof(t_xs_cfg_item));


/*
 * Reset the filter settings
 */
void xs_reset_filters(void)
{
 /* Reset filter values */
/*
 xs_cfg.filterFs = SIDEMU_DEFAULTFILTERFS;
 xs_cfg.filterFm = SIDEMU_DEFAULTFILTERFM;
 xs_cfg.filterFt = SIDEMU_DEFAULTFILTERFT;
*/
}


/*
 * Get the configuration (from file or default)
 */
void xs_read_configuration(void)
{
 gchar *cfgFilename, *tmpStr;
 ConfigFile *cfgFile;
 gint i;

 XSDEBUG("initializing configuration ...\n");

 /* Pre-initialize configuration structure */
 xs_cfg.fmtBitsPerSample		= 16;
 xs_cfg.fmtChannels		= XS_CHN_MONO;
 xs_cfg.fmtFrequency		= 44100;

 xs_cfg.mos8580			= FALSE;
 xs_cfg.emulateFilters		= TRUE;
 xs_reset_filters();
 xs_cfg.memoryMode		= XS_MPU_BANK_SWITCHING;
 xs_cfg.clockSpeed		= XS_CLOCK_PAL;
 xs_cfg.forceSpeed		= FALSE;

 xs_cfg.oversampleEnable	= FALSE;
 xs_cfg.oversampleFactor	= XS_MIN_OVERSAMPLE;

 xs_cfg.playMaxTimeEnable	= FALSE;
 xs_cfg.playMaxTime		= 150;
 xs_cfg.songlenDBEnable		= FALSE;
 xs_strcalloc(&xs_cfg.songlenDBPath, "~/C64Music/Songlengths.txt");

 xs_cfg.stilDBEnable		= FALSE;
 xs_strcalloc(&xs_cfg.stilDBPath, "~/C64Music/DOCUMENTS/STIL.txt");

 xs_cfg.detectMagic		= FALSE;

 xs_cfg.titleOverride		= FALSE;
 xs_strcalloc(&xs_cfg.titleFormat, "%1 - %2");


 /* Try to open the XMMS configuration file */
 XSDEBUG("loading from config-file ...\n");

 cfgFilename = g_strconcat(g_get_home_dir(), XS_CONFIG_FILE, NULL);
 cfgFile = xmms_cfg_open_file(cfgFilename);
 g_free(cfgFilename);
 if (cfgFile == NULL)
	{
	XSDEBUG("could not open configuration file, trying to write defaults...\n");
	xs_write_configuration();
	return;
	}


 /* Read the new settings from XMMS configuration file */
 for (i = 0; i < XS_CFGTABLE_MAX; i++)
 	{
	switch (xs_cfgtable[i].atype) {
	case ATYPE_INT:
		xmms_cfg_read_int(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].aname, (gint *) xs_cfgtable[i].adata);
		break;

	case ATYPE_BOOL:
		xmms_cfg_read_boolean(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].aname, (gboolean *) xs_cfgtable[i].adata);
		break;

	case ATYPE_FLOAT:
		xmms_cfg_read_float(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].aname, (gfloat *) xs_cfgtable[i].adata);
		break;

	case ATYPE_STR:
		if (xmms_cfg_read_string(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].aname, (gchar **) &tmpStr))
			{
			/* Read was successfull */
			xs_strcalloc((gchar **) xs_cfgtable[i].adata, tmpStr);
			g_free(tmpStr);
			}
		break;

	default:
		XSERR("Internal: Unsupported setting type found while reading configuration file. Please report to author!\n");
		break;
	}
	}


 /* Free the config file */
 xmms_cfg_free(cfgFile);

 xs_write_configuration();
 
 XSDEBUG("OK\n");
}



/*
 * Write the current configuration
 */
gint xs_write_configuration(void)
{
 gchar *cfgFilename;
 ConfigFile *cfgFile;
 gint i;

 XSDEBUG("writing configuration ...\n");

 /*
  * Try to open the XMMS configuration file
  */
 cfgFilename = g_strconcat(g_get_home_dir(), XS_CONFIG_FILE, NULL);
 cfgFile = xmms_cfg_open_file(cfgFilename);

 if (!cfgFile)
	cfgFile = xmms_cfg_new();


 /* Write the new settings to XMMS configuration file */
 for (i = 0; i < XS_CFGTABLE_MAX; i++)
 	{
	switch (xs_cfgtable[i].atype) {
	case ATYPE_INT:
		xmms_cfg_write_int(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].aname, *(gint *) xs_cfgtable[i].adata);
		break;

	case ATYPE_BOOL:
		xmms_cfg_write_boolean(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].aname, *(gboolean *) xs_cfgtable[i].adata);
		break;

	case ATYPE_FLOAT:
		xmms_cfg_write_float(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].aname, *(gfloat *) xs_cfgtable[i].adata);
		break;

	case ATYPE_STR:
		xmms_cfg_write_string(cfgFile, XS_CONFIG_IDENT, xs_cfgtable[i].aname, *(gchar **) xs_cfgtable[i].adata);
		break;

	default:
		XSERR("Internal: Unsupported setting type found while writing configuration file. Please report to author!\n");
		break;
	}
	}

 /* Flush the file */
 xmms_cfg_write_file(cfgFile, cfgFilename);

 /* Free the memory areas */
 xmms_cfg_free(cfgFile);
 g_free(cfgFilename);

 return 0;
}


/*
 * Configuration panel was canceled
 */
void xs_cfg_cancel(void)
{
 gtk_widget_destroy(xs_configwin);
 xs_configwin = NULL;
}


/*
 * Configuration was accepted (OK), save the settings
 */
void xs_cfg_ok(void)
{
 XSDEBUG("get data from widgets to config...\n");

 /* Check the resolution settings */
 if (GTK_TOGGLE_BUTTON(LUW("cfg_res_16bit"))->active)
	xs_cfg.fmtBitsPerSample = XS_RES_16BIT;
	else
	xs_cfg.fmtBitsPerSample = XS_RES_8BIT;


 /* Channel settings */
 if (GTK_TOGGLE_BUTTON(LUW("cfg_chn_mono"))->active)
	xs_cfg.fmtChannels = XS_CHN_MONO;
	else
 if (GTK_TOGGLE_BUTTON(LUW("cfg_chn_stereo"))->active)
	xs_cfg.fmtChannels = XS_CHN_STEREO;
	else
 if (GTK_TOGGLE_BUTTON(LUW("cfg_chn_autopan"))->active)
	xs_cfg.fmtChannels = XS_CHN_AUTOPAN;


 /* Frequency setting */
 xs_cfg.fmtFrequency = (gint) GTK_ADJUSTMENT(LUW("cfg_samplerate_adj"))->value;


 /* Filter and waveform settings */
 xs_cfg.mos8580 = GTK_TOGGLE_BUTTON(LUW("cfg_wav_mos8580"))->active;

 xs_cfg.emulateFilters = GTK_TOGGLE_BUTTON(LUW("cfg_emufilters"))->active;

 xs_cfg.filterFs = GTK_ADJUSTMENT(LUW("cfg_filt_fs_adj"))->value;
 xs_cfg.filterFm = GTK_ADJUSTMENT(LUW("cfg_filt_fm_adj"))->value;
 xs_cfg.filterFt = GTK_ADJUSTMENT(LUW("cfg_filt_ft_adj"))->value;


 /* Memorymode settings */
 if (GTK_TOGGLE_BUTTON(LUW("cfg_mem_banksw"))->active)
	xs_cfg.memoryMode = XS_MPU_BANK_SWITCHING;
	else
 if (GTK_TOGGLE_BUTTON(LUW("cfg_mem_transrom"))->active)
	xs_cfg.memoryMode = XS_MPU_TRANSPARENT_ROM;
	else
 if (GTK_TOGGLE_BUTTON(LUW("cfg_mem_playsid"))->active)
	xs_cfg.memoryMode = XS_MPU_PLAYSID_ENVIRONMENT;

 /* Clockspeed settings */
 if (GTK_TOGGLE_BUTTON(LUW("cfg_clock_ntsc"))->active)
	xs_cfg.clockSpeed = XS_CLOCK_NTSC;
	else
	xs_cfg.clockSpeed = XS_CLOCK_PAL;

 xs_cfg.forceSpeed = GTK_TOGGLE_BUTTON(LUW("cfg_clock_force"))->active;


 /* Songlength-detection settings */
 xs_cfg.playMaxTimeEnable = GTK_TOGGLE_BUTTON(LUW("cfg_sld_usemaxtime"))->active;
 xs_cfg.playMaxTime = GTK_ADJUSTMENT(LUW("cfg_sld_maxtime_adj"))->value;

 xs_cfg.songlenDBEnable = (GTK_TOGGLE_BUTTON(LUW("cfg_sld"))->active);
 xs_strcalloc(&xs_cfg.songlenDBPath, gtk_entry_get_text(GTK_ENTRY(LUW("cfg_sld_dbpath"))));


 /* STIL and miscellaneous settings */
 xs_cfg.stilDBEnable = GTK_TOGGLE_BUTTON(LUW("cfg_stil_use"))->active;
 xs_strcalloc(&xs_cfg.stilDBPath, gtk_entry_get_text(GTK_ENTRY(LUW("cfg_stil_path"))));

 xs_cfg.detectMagic = GTK_TOGGLE_BUTTON(LUW("cfg_detectmagic"))->active;

 /* Title settings */
 xs_cfg.titleOverride = GTK_TOGGLE_BUTTON(LUW("cfg_ftitle_override"))->active;
 xs_strcalloc(&xs_cfg.titleFormat, gtk_entry_get_text(GTK_ENTRY(LUW("cfg_ftitle_format"))));


 /* Write settings */
 xs_write_configuration();

/* NOTICE/FIXME FIX ME: if songlendb or stildb settings changed, we need to flush and reread them */

 /* Close window */
 gtk_widget_destroy(xs_configwin);
 xs_configwin = NULL;
}


/*
 * Update filter setting sliders
 */
void xs_update_filters(void)
{
 gtk_adjustment_set_value(GTK_ADJUSTMENT(LUW("cfg_filt_fs_adj")), xs_cfg.filterFs);
 gtk_adjustment_set_value(GTK_ADJUSTMENT(LUW("cfg_filt_fm_adj")), xs_cfg.filterFm);
 gtk_adjustment_set_value(GTK_ADJUSTMENT(LUW("cfg_filt_ft_adj")), xs_cfg.filterFt);
}


/*
 * Reset filter settings to defaults
 */
void xs_cfg_filter_reset(void)
{
 xs_reset_filters();
 xs_update_filters();
}


/*
 * HVSC songlength-database file selector response-functions
 */
void xs_cfg_sld_dbbrowse(GtkButton *button, gpointer user_data)
{
}


void xs_cfg_sldb_fs_ok(void)
{
 /* Selection was accepted! */
 gtk_entry_set_text(GTK_ENTRY(LUW("cfg_sld_dbpath")),
 	gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_sldb_fileselector))
 	);

 /* Close file selector window */
 gtk_widget_destroy(xs_sldb_fileselector);
 xs_sldb_fileselector = NULL;
}


void xs_cfg_sldb_fs_cancel(void)
{
 /* Close file selector window */
 gtk_widget_destroy(xs_sldb_fileselector);
 xs_sldb_fileselector = NULL;
}


/*
 * STIL-database file selector response-functions
 */
void xs_cfg_stil_browse(GtkButton *button, gpointer user_data)
{

}


void xs_cfg_stil_fs_ok(void)
{
 /* Selection was accepted! */
 gtk_entry_set_text(GTK_ENTRY(LUW("cfg_stil_path")),
 	gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_stil_fileselector)));

 /* Close file selector window */
 gtk_widget_destroy(xs_stil_fileselector);
 xs_stil_fileselector = NULL;
}


void xs_cfg_stil_fs_cancel(void)
{
 /* Close file selector window */
 gtk_widget_destroy(xs_stil_fileselector);
 xs_stil_fileselector = NULL;
}


/*
 * Execute the configuration panel
 */
void xs_configure(void)
{
 /* Check if the window already exists */
 if (xs_configwin != NULL)
	{
	gdk_window_raise(xs_configwin->window);
	return;
	}

 /* Create the window */
 xs_configwin = create_xs_configwin();
 	
#if 0

	/* Set the states of widgets */

	/* Sound resolution settings */
	switch (xs_cfg.fmtBitsPerSample) {
	case 16:
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_res_16bit), TRUE);
		break;
	case 8:
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_res_8bit), TRUE);
		break;
	}

	gtk_adjustment_set_value(GTK_ADJUSTMENT(cfg_samplerate_adj), xs_cfg.fmtFrequency);


	/* Channel settings */
	switch (xs_cfg.fmtChannels) {
	case 0:
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_chn_mono), TRUE);
		break;
	case 1:
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_chn_stereo), TRUE);
		break;
	case 2:
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_chn_autopan), TRUE);
		break;
	}


	/* Memorymode settings */
	switch (xs_cfg.memoryMode) {
	case XS_MPU_BANK_SWITCHING:
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_mem_banksw), TRUE);
		break;

	case XS_MPU_TRANSPARENT_ROM:
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_mem_transrom), TRUE);
		break;

	case XS_MPU_PLAYSID_ENVIRONMENT:
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_mem_playsid), TRUE);
		break;
	}


	/* Filter and waveform settings */
	if (xs_cfg.mos8580) {
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_wav_mos8580), TRUE);
		} else {
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_wav_mos6581), TRUE);
		}


	if (xs_cfg.emulateFilter) {
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_emufilters), TRUE);
		}

	xs_cfg_filt_update();


	/* Song-length detection */
	switch (xs_cfg.playMethod) {
	case XS_PMETHOD_NONE:
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_sld_none), TRUE);
		break;

	case XS_PMETHOD_MAXSILENCE:
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_sld_maxsilence), TRUE);
		break;


	case XS_PMETHOD_DATABASE:
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_sld_database), TRUE);
		break;
	}

	if (xs_cfg.playUseMaxTime) {
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_sld_usemaxtime), TRUE);
		}

	gtk_adjustment_set_value(GTK_ADJUSTMENT(cfg_sld_maxtime_adj), xs_cfg.playMaxTime);
	gtk_adjustment_set_value(GTK_ADJUSTMENT(cfg_sld_silencetime_adj), xs_cfg.playMaxSilentTime);
	gtk_adjustment_set_value(GTK_ADJUSTMENT(cfg_sld_percentage_adj), xs_cfg.playSilentPercent);

	if (xs_cfg.playDBPath != NULL) {
		gtk_entry_set_text(GTK_ENTRY(cfg_sld_dbpath), xs_cfg.playDBPath);
		}


	/* STIL and miscellaneous settings */
	if (xs_cfg.useSTIL) {
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_stil_use), TRUE);
		}

	if (xs_cfg.STILpath != NULL) {
		gtk_entry_set_text(GTK_ENTRY(cfg_stil_path), xs_cfg.STILpath);
		}

	if (xs_cfg.finfoUseColors) {
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_finfo_usecolors), TRUE);
		}

	if (xs_cfg.detectMagic) {
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_detectmagic), TRUE);
		}


	/* Title-settings */
	if (xs_cfg.titleOverride) {
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cfg_ftitle_override), TRUE);
		}

	if (xs_cfg.titleFormat != NULL) {
		gtk_entry_set_text(GTK_ENTRY(cfg_ftitle_format), xs_cfg.titleFormat);
		}

#endif

 gtk_widget_show(xs_configwin);
}