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

   Main source file

   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 <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>

#include <xmms/plugin.h>
#include <xmms/util.h>

#include "xmms-sid.h"
#include "xs_support.h"
#include "xs_config.h"
#include "xs_length.h"
#include "xs_stil.h"
#include "xs_interface.h"
#include "xs_glade.h"


/*
 * Include player engines
 */
#ifdef HAVE_SIDPLAY1
#include "xs_sidplay1.h"
#endif
#ifdef HAVE_SIDPLAY2
#include "xs_sidplay2.h"
#endif
#ifdef HAVE_NANOSID
#include "xs_nanosid.h"
#endif


/*
 * Structure defining methods/functions of each player
 */
typedef struct {
	gint		plrIdent;
	gboolean	(*plrIsOurFile)(gchar *);
	gboolean	(*plrInit)(t_xs_status *);
	void		(*plrClose)(t_xs_status *);
	gboolean	(*plrInitSong)(t_xs_status *);
	guint		(*plrFillBuffer)(t_xs_status *, gchar *, guint);
	gboolean	(*plrLoadSID)(t_xs_status *, gchar *);
	void		(*plrDeleteSID)(t_xs_status *);
	t_xs_tune*	(*plrGetSIDInfo)(gchar *);
} t_xs_player;


/*
 * List of players and links to their functions
 */
t_xs_player xs_playerlist[] = {
#ifdef HAVE_SIDPLAY1
	{ XS_ENG_SIDPLAY1,
		xs_sidplay1_isourfile,
		xs_sidplay1_init, xs_sidplay1_close,
		xs_sidplay1_initsong, xs_sidplay1_fillbuffer,
		xs_sidplay1_loadsid, xs_sidplay1_deletesid,
		xs_sidplay1_getsidinfo
	},
#endif
#ifdef HAVE_SIDPLAY2
	{ XS_ENG_SIDPLAY2,
		xs_sidplay2_isourfile,
		xs_sidplay2_init, xs_sidplay2_close,
		xs_sidplay2_initsong, xs_sidplay2_fillbuffer,
		xs_sidplay2_loadsid, xs_sidplay2_deletesid,
		xs_sidplay2_getsidinfo
	},
#endif
#ifdef HAVE_NANOSID
	{ XS_ENG_NANOSID,
		xs_nanosid_isourfile,
		xs_nanosid_init, xs_nanosid_close,
		xs_nanosid_initsong, xs_nanosid_fillbuffer,
		xs_nanosid_loadsid, xs_nanosid_deletesid,
		xs_nanosid_getsidinfo
	},
#endif
};

const gint xs_nplayerlist = (sizeof(xs_playerlist) / sizeof(t_xs_player));


/*
 * Global variables
 */
static GtkWidget		*xs_fileinfowin = NULL;
static pthread_t		xs_decode_thread;
static pthread_mutex_t		xs_mutex	= PTHREAD_MUTEX_INITIALIZER;
struct t_xs_cfg			xs_cfg;
t_xs_status			xs_status;
t_xs_player			*xs_player	= NULL;


/*
 * Initialize XMMS-SID
 */
void xs_init(void)
{
 gint iPlayer;
 gboolean isInitialized;
 
 XSDEBUG("xs_init()\n");

 /* Initialize and get configuration */
 memset(&xs_cfg, 0, sizeof(xs_cfg));
 xs_read_configuration();

 /* Initialize status */
 memset(&xs_status, 0, sizeof(xs_status));

 /* Try to initialize emulator engine */
 XSDEBUG("initializing emulator engine #%i...\n", xs_cfg.playerEngine);

 iPlayer = 0;
 isInitialized = FALSE;
 while ((iPlayer < xs_nplayerlist) && !isInitialized)
 	{
 	if (xs_playerlist[iPlayer].plrIdent == xs_cfg.playerEngine)
 		{
 		if (xs_playerlist[iPlayer].plrInit(&xs_status))
 			{
 			isInitialized = TRUE;
 			xs_player = (t_xs_player *) &xs_playerlist[iPlayer];
 			}
 		}
	iPlayer++;
 	}

 XSDEBUG("init#1: %s, %i\n", (isInitialized) ? "OK" : "FAILED", iPlayer);

 iPlayer = 0;
 while ((iPlayer < xs_nplayerlist) && !isInitialized)
 	{
	if (xs_playerlist[iPlayer].plrInit(&xs_status))
		{
		isInitialized = TRUE;
		xs_player = (t_xs_player *) &xs_playerlist[iPlayer];
 		} else
 		iPlayer++;
 	}
 
 XSDEBUG("init#2: %s, %i\n", (isInitialized) ? "OK" : "FAILED", iPlayer);

 /* Initialize song-length database */
 if (xs_cfg.songlenDBEnable && (xs_songlen_init() < 0))
	{
	XSERR("Error initializing song-length database!\n");
	}
	
 /* Initialize STIL database */
 if (xs_cfg.stilDBEnable && (xs_stil_init() < 0))
 	{
 	XSERR("Error initializing STIL database!\n");
 	}

 XSDEBUG("OK\n");
}


/*
 * Shut down XMMS-SID
 */
void xs_close(void)
{
 XSDEBUG("xs_close(): shutting down...\n");

 /* Stop playing, free structures */
 xs_stop();

 xs_tune_free(xs_status.pTune);
 xs_status.pTune = NULL;
 
 xs_player->plrDeleteSID(&xs_status);
 xs_player->plrClose(&xs_status);

 xs_songlen_close();
 xs_stil_close();

 XSDEBUG("shutdown finished.\n");
}


/*
 * Check whether the given file is handled by this plugin
 */
gint xs_is_our_file(gchar *pcFilename)
{
 char *pcExt;
 assert(xs_player);

 /* Check the filename */
 if (pcFilename == NULL)
	return FALSE;

 /* Try to detect via detection routine, if required */
 if (xs_cfg.detectMagic && xs_player->plrIsOurFile(pcFilename))
 	return TRUE;

 /* Detect just by checking filename extension */
 pcExt = strrchr(pcFilename, '.');
 if (pcExt)
	{
	pcExt++;
	switch (xs_cfg.playerEngine) {
	case XS_ENG_SIDPLAY1:
	case XS_ENG_SIDPLAY2:
		if (!strcasecmp(pcExt, "psid")) return TRUE;
		if (!strcasecmp(pcExt, "sid"))	return TRUE;
		if (!strcasecmp(pcExt, "dat"))	return TRUE;
		if (!strcasecmp(pcExt, "inf"))	return TRUE;
		if (!strcasecmp(pcExt, "info"))	return TRUE;
		break;

	case XS_ENG_NANOSID:
		if (!strcasecmp(pcExt, "zsid"))	return TRUE;
		break;
	}
	}

 return FALSE;
}


/*
 * Main playing thread loop
 */
void *xs_play_loop(void *argPointer)
{
 t_xs_status myStatus;
 t_xs_tune *myTune;
 gboolean audioOpen = FALSE, doPlay = FALSE;
 guint audioGot;
 gint audioFreq, audioChannels, songLength, audioFmt;
 gchar audioBuffer[XS_BUFSIZE];

 /* Initialize */
 pthread_mutex_lock(&xs_mutex);
 XSDEBUG("entering play thread\n");
 memcpy(&myStatus, &xs_status, sizeof(t_xs_status));
 myTune = xs_status.pTune;
 pthread_mutex_unlock(&xs_mutex);

 /* Copy and check audio options here (they might change in config while running) */
#ifdef HAVE_UNSIGNEDPCM
 audioFmt = (xs_cfg.fmtBitsPerSample == XS_RES_16BIT) ? FMT_U16_NE : FMT_U8;
#else
 audioFmt = (xs_cfg.fmtBitsPerSample == XS_RES_16BIT) ? FMT_S16_NE : FMT_S8;
#endif
 audioFreq = xs_cfg.fmtFrequency;
 audioChannels = (xs_cfg.fmtChannels == XS_CHN_MONO) ? 1 : 2;

 /*
  * Main player loop: while not stopped, loop here - play subtunes
  */
 doPlay = TRUE;
 while (xs_status.isPlaying && doPlay)
 {
 pthread_mutex_lock(&xs_mutex);
 myStatus.currSong = xs_status.currSong;
 pthread_mutex_unlock(&xs_mutex);

 XSDEBUG("subtune #%i selected, initializing...\n", myStatus.currSong);

 songLength = myTune->subTunes[myStatus.currSong - 1].tuneLength;

 /* Initialize song */
 if (!xs_player->plrInitSong(&myStatus))
	{
	XSERR("Couldn't initialize SID-tune '%s' (sub-tune #%i)!\n",
		myTune->tuneFilename, myStatus.currSong);
	goto err_exit;
	}


 /* Get song information for current subtune */
 xs_plugin_ip.set_info(
 	myTune->subTunes[myStatus.currSong - 1].tuneTitle,
 	(songLength > 0) ? (songLength * 1000) : -1,
 	(myTune->subTunes[myStatus.currSong - 1].tuneSpeed > 0) ? (myTune->subTunes[myStatus.currSong - 1].tuneSpeed * 1000) : -1,
	audioFreq,
	audioChannels);


 /* Open the audio output */
 if (!xs_plugin_ip.output->open_audio(audioFmt, audioFreq, audioChannels))
	{
	XSERR("Couldn't open XMMS audio output!\n");
	pthread_mutex_lock(&xs_mutex);
	xs_status.isError = TRUE;
	pthread_mutex_unlock(&xs_mutex);
	goto err_exit;
	}

 audioOpen = TRUE;

 /*
  * Play the subtune
  */
 while (xs_status.isPlaying && myStatus.isPlaying && (xs_status.currSong == myStatus.currSong))
	{
	/* Render audio data */
	audioGot = xs_player->plrFillBuffer(&myStatus, audioBuffer, XS_BUFSIZE);

	/* I <3 visualice/haujobb */
	xs_plugin_ip.add_vis_pcm(
		xs_plugin_ip.output->written_time(),
		audioFmt, audioChannels, audioGot, audioBuffer);

	/* Wait a little */
	while (xs_status.isPlaying &&
		(xs_status.currSong == myStatus.currSong) &&
		((guint) xs_plugin_ip.output->buffer_free() < audioGot))
		xmms_usleep(10000);

	/* Output audio */
	if (xs_status.isPlaying && (xs_status.currSong == myStatus.currSong))
		xs_plugin_ip.output->write_audio(audioBuffer, audioGot);

	/* Check if we have played enough */
	if (xs_cfg.playMaxTimeEnable)
		{
		if (xs_cfg.playMaxTimeUnknown)
			{
			if ((songLength == -1) &&
				(xs_plugin_ip.output->output_time() >= (xs_cfg.playMaxTime * 1000)))
				myStatus.isPlaying = FALSE;
			} else {
			if (xs_plugin_ip.output->output_time() >= (xs_cfg.playMaxTime * 1000))
				myStatus.isPlaying = FALSE;
			}
		}

	if (songLength > 0)
		{
		if (xs_plugin_ip.output->output_time() >= (songLength * 1000))
			myStatus.isPlaying = FALSE;
		}
	}

 XSDEBUG("subtune ended/stopped\n");

 /* Close audio */
 if (audioOpen)
	{
	XSDEBUG("close audio #1\n");
	xs_plugin_ip.output->close_audio();
	audioOpen = FALSE;
	}

 /* Now determine if we continue by selecting other subtune or something */
 if (!myStatus.isPlaying) doPlay = FALSE;
 }

err_exit:
 /* Close audio */
 if (audioOpen)
	{
	XSDEBUG("close audio #2\n");
	xs_plugin_ip.output->close_audio();
	}

 /* Exit the playing thread */
 XSDEBUG("exiting thread, bye.\n");

 pthread_mutex_lock(&xs_mutex);
 xs_status.isPlaying = FALSE;
 pthread_mutex_unlock(&xs_mutex);
 pthread_exit(NULL);
}


/*
 * Start playing the given file
 */
void xs_play_file(gchar *pcFilename)
{
 XSDEBUG("play '%s'\n", pcFilename);
 
 /* Get tune information */
 if ((xs_status.pTune = xs_player->plrGetSIDInfo(pcFilename)) == NULL)
 	return;

 /* Initialize the tune */
 if (!xs_player->plrLoadSID(&xs_status, pcFilename))
 	{
 	xs_tune_free(xs_status.pTune);
 	xs_status.pTune = NULL;
 	return;
 	}

 XSDEBUG("load ok\n");
 
 /* Set general status information */
 xs_status.isPlaying	= TRUE;
 xs_status.isError	= FALSE;
 xs_status.currSong	= xs_status.pTune->startTune;

 /* Start the playing thread! */
 if (pthread_create(&xs_decode_thread, NULL, xs_play_loop, NULL) < 0)
	{
	XSERR("Couldn't start playing thread! Possible reason reported by system: %s\n", strerror(errno));
 	xs_tune_free(xs_status.pTune);
	xs_status.pTune = NULL;
	xs_player->plrDeleteSID(&xs_status);
	}

 XSDEBUG("systems should be up?\n");
}


/*
 * Stop playing
 */
void xs_stop(void)
{
 XSDEBUG("STOP_REQ\n");
 if (xs_status.isPlaying)
	{
	/* Stop playing */
	XSDEBUG("stopping...\n");
	pthread_mutex_lock(&xs_mutex);
	xs_status.isPlaying = FALSE;
	pthread_mutex_unlock(&xs_mutex);
	pthread_join(xs_decode_thread, NULL);
	}

 /* Free tune information */
 xs_player->plrDeleteSID(&xs_status);
 xs_tune_free(xs_status.pTune);
 xs_status.pTune = NULL;
}


/*
 * Pause/unpause the playing
 */
void xs_pause(short pauseState)
{
 xs_plugin_ip.output->pause(pauseState);
}


/*
 * Set the time-seek position
 * (the playing thread will do the "seeking" aka song-change)
 */
void xs_seek(gint iTime)
{
 gint n;
 if (!xs_status.pTune || !xs_status.isPlaying) return;
 
 switch (xs_cfg.subsongControl) {
 case XS_SSC_POPUP:
	pthread_mutex_lock(&xs_mutex);
	
	n = xs_status.pTune->subTunes[xs_status.currSong].tuneLength;
	if ((iTime > 0) && (iTime <= n))
		{
		xs_status.currSong = 1 + ((iTime * xs_status.pTune->nsubTunes) / n);
		}
	
	pthread_mutex_unlock(&xs_mutex);
	break;

 /* If we have song-position patch, check settings */
#ifdef HAVE_SONG_POSITION
 case XS_SSC_PATCH:
	pthread_mutex_lock(&xs_mutex);

	if ((iTime > 0) && (iTime <= xs_status.pTune->nsubTunes))
		xs_status.currSong = iTime;
	
	pthread_mutex_unlock(&xs_mutex);
	break;
#endif

 default:
 	break;
 }
}


/*
 * Return the playing "position/time"
 */
gint xs_get_time(void)
{
 /* If errorflag is set, return -2 to signal it to XMMS's idle callback */
 if (xs_status.isError)
	return -2;

 /* If there is no tune, return -1 */
 if (!xs_status.pTune)
 	return -1;
 
 /* If tune has ended, return -1 */
 if (!xs_status.isPlaying)
	return -1;

 /* Let's see what we do */
#ifdef HAVE_SONG_POSITION
 if (xs_cfg.subsongControl == XS_SSC_PATCH)
 	{
	pthread_mutex_lock(&xs_mutex);
	set_song_position(xs_status.currSong, 1, xs_status.pTune->nsubTunes);
	pthread_mutex_unlock(&xs_mutex);
	}
#endif

 /* Else, return output time reported by audio output plugin */
 return xs_plugin_ip.output->output_time();
}


/*
 * Return song information
 */
void xs_get_song_info(gchar *songFilename, gchar **songTitle, gint *songLength)
{
 t_xs_tune *pInfo;
 gint tmpInt;
 
 pInfo = xs_player->plrGetSIDInfo(songFilename);
 if (!pInfo) return;

 if ((pInfo->startTune >= 0) && (pInfo->startTune <= pInfo->nsubTunes))
 	{
	(*songTitle) = g_strdup(pInfo->subTunes[pInfo->startTune - 1].tuneTitle);

	tmpInt = pInfo->subTunes[pInfo->startTune - 1].tuneLength;
	if (tmpInt < 0)
		(*songLength) = -1;
		else
		(*songLength) = (tmpInt * 1000);
	}
	
 xs_tune_free(pInfo);
}


/*
 * Allocate a new tune structure
 */
t_xs_tune *xs_tune_new(gchar *pcFilename, gint nsubTunes, gint startTune,
	gchar *tuneName, gchar *tuneComposer, gchar *tuneCopyright)
{
 t_xs_tune *pResult;
 
 pResult = (t_xs_tune *) g_malloc0(sizeof(t_xs_tune));
 if (!pResult) return NULL;
 
 pResult->tuneFilename = g_strdup(pcFilename);
 if (!pResult->tuneFilename)
 	{
 	g_free(pResult);
 	return NULL;
 	}
 
 pResult->tuneName	= g_strdup(tuneName);
 pResult->tuneComposer	= g_strdup(tuneComposer);
 pResult->tuneCopyright	= g_strdup(tuneCopyright);
 pResult->nsubTunes	= nsubTunes;
 pResult->startTune	= startTune;
 
 return pResult;
}


/*
 * Free tune information
 */
void xs_tune_free(t_xs_tune *pTune)
{
 gint i;
 if (!pTune) return;

 g_free(pTune->tuneFilename);	pTune->tuneFilename = NULL;
 g_free(pTune->tuneName);	pTune->tuneName = NULL;
 g_free(pTune->tuneComposer);	pTune->tuneComposer = NULL;
 g_free(pTune->tuneCopyright);	pTune->tuneCopyright = NULL;
 
 for (i = 0; i < pTune->nsubTunes; i++)
 	{
 	if (pTune->subTunes[i].tuneTitle)
 		{
 		g_free(pTune->subTunes[i].tuneTitle);
 		pTune->subTunes[i].tuneTitle = NULL;
 		}
 	}
 
 g_free(pTune);
}


/*
 * File-information window
 */
#define LUW(x...)	lookup_widget(xs_fileinfowin, ## x)


void xs_fileinfo_ok(void)
{
 gtk_widget_destroy(xs_fileinfowin);
 xs_fileinfowin = NULL;
}


void xs_fileinfo_subtune(GtkWidget *widget, void *data)
{
#if 0
 T_sid_stil_subtune *a_tune;
 GtkWidget *a_item;
 gint a_index;

 
 /* Get number of subtune */
 a_item  = gtk_menu_get_active(GTK_MENU(fileinfo_sub_tune_menu));
 a_index = g_list_index(GTK_MENU_SHELL(fileinfo_sub_tune_menu)->children, a_item);

 a_tune = &xs_stil_info.subtune[a_index];


 /* Get and set subtune information */
 if (a_tune->artist != NULL)
	gtk_entry_set_text (GTK_ENTRY (fileinfo_sub_artist), a_tune->artist);

 if (a_tune->title != NULL)
	gtk_entry_set_text (GTK_ENTRY (fileinfo_sub_title), a_tune->title);

 if (a_tune->comment != NULL)
	{
	/* Freeze the widget for update */
	gtk_text_freeze(GTK_TEXT(fileinfo_sub_comment));

	/* Delete the old comment */
	gtk_text_set_point(GTK_TEXT(fileinfo_sub_comment), 0);
	gtk_text_forward_delete(GTK_TEXT(fileinfo_sub_comment),
	gtk_text_get_length(GTK_TEXT(fileinfo_sub_comment)));

	/* Put in the new comment */	
	gtk_text_insert (GTK_TEXT (fileinfo_sub_comment), NULL, NULL, NULL,
	a_tune->comment, strlen(a_tune->comment));

	/* Un-freeze the widget */
	gtk_text_thaw(GTK_TEXT(fileinfo_sub_comment));
	}
#endif
}


void xs_fileinfo(gchar *pcFilename)
{
 t_xs_tune *pInfo;
 GtkWidget *tmpMenuItem, *tmpMenu, *tmpOptionMenu;
 gchar tmpStr[32];
 gint n;
 
 /* Get tune information */
 if ((pInfo = xs_player->plrGetSIDInfo(pcFilename)) == NULL)
 	{
 	if (xs_fileinfowin)
 		{
 		gtk_widget_destroy(xs_fileinfowin);
 		xs_fileinfowin = NULL;
 		}
 	return;
 	}

 /* Check if there already is an open fileinfo window */
 if (xs_fileinfowin)
	{
	gdk_window_raise(xs_fileinfowin->window);
	} else {
	/* If not, create a new one */
	xs_fileinfowin = create_xs_fileinfowin();
	}


 /* Set the song informations */
 gtk_entry_set_text(GTK_ENTRY(LUW("fileinfo_filename")), pcFilename);
 gtk_entry_set_text(GTK_ENTRY(LUW("fileinfo_songname")), pInfo->tuneName);
 gtk_entry_set_text(GTK_ENTRY(LUW("fileinfo_composer")), pInfo->tuneComposer);
 gtk_entry_set_text(GTK_ENTRY(LUW("fileinfo_copyright")), pInfo->tuneCopyright);


 /* Main tune - the pseudo tune */
 tmpOptionMenu = LUW("fileinfo_sub_tune");
 tmpMenu = GTK_OPTION_MENU(tmpOptionMenu)->menu;

 tmpMenuItem = gtk_menu_item_new_with_label ("General info");
 gtk_widget_show (tmpMenuItem);
 gtk_menu_append (GTK_MENU(tmpMenu), tmpMenuItem);
 gtk_signal_connect (GTK_OBJECT (tmpMenuItem), "activate",
		GTK_SIGNAL_FUNC (xs_fileinfo_subtune), tmpMenu);

 /* Other menu items */
 for (n = 1; n <= pInfo->nsubTunes; n++)
	{
	snprintf(tmpStr, sizeof(tmpStr), "Tune #%i", n);

	tmpMenuItem = gtk_menu_item_new_with_label (tmpStr);
	gtk_widget_show (tmpMenuItem);
	gtk_menu_append (GTK_MENU(tmpMenu), tmpMenuItem);

	gtk_signal_connect (GTK_OBJECT(tmpMenuItem), "activate",
			GTK_SIGNAL_FUNC(xs_fileinfo_subtune), tmpMenu);
	}

 /* Set the sub-tune information */
 xs_fileinfo_subtune(NULL, tmpMenu);

 /* Show the window */
 gtk_widget_show(xs_fileinfowin);
}