/*
 *	special dedikass Pink Lady
 */

#include  <stdio.h>
#include  <unistd.h>
#include  <string.h>
#include  <fcntl.h>
#include  <linux/joystick.h>

#include <ao/ao.h>
#include <sndfile.h>


/* --------------------------------------------------------------- */
#define   T_BUFF_WAVES          (8192*8)
#define   NB_WAVES		12
#define   T_FNAME		1000
/* --------------------------------------------------------------- */
typedef struct
	{
	char		*name;
	long		size;		/* number of samples */
	int		volume;
	} A_Wave;

char	waves_names[NB_WAVES][T_FNAME+1];
int16_t	*waves_data[NB_WAVES];
/* --------------------------------------------------------------- */
/* WARNING :
 	dont reuse this func when you got an error : fd leak happen */

static int lireconfig(char *fname)
{
FILE		*fp;
char		ligne[T_FNAME+1], *cptr;
int		foo, lg, numid;

if (NULL==(fp=fopen(fname, "r")))
	{
	perror(fname);
	return -1;
	}
/* cleanup the datasore */

for (foo=0; foo<NB_WAVES; foo++)
	waves_names[foo][0] = '\0';

while (NULL != fgets(ligne, T_FNAME, fp))
	{
	lg = strlen(ligne)		/* strip EOL */;
	if (lg && ligne[lg-1]=='\n')
				ligne[lg-1]='\0';

#if DEBUG_LEVEL
	fprintf(stderr, "[%s]\n", ligne);
#endif

	/* first, we ge the numid of the sample */
	if (1 != sscanf(ligne, "%d", &numid))
		{
		/* XXX */
		fprintf(stderr, "err scanf, to be patched...\n");
		return -2;
		}
#if DEBUG_LEVEL
	fprintf(stderr, "numid = %d\n", numid);
#endif

	/* are we in the authorized range on our datastore ? */
	if ( numid<0 || numid>=NB_WAVES)
		{
		fprintf(stderr, "numid %d out of trolley\n", numid);
		return -5;
		}

	/* after that, we grab the holly filename */
	cptr = strtok(ligne, " \t");
	cptr = strtok(NULL, " \t");		/* headshoot ! */
	if (NULL==cptr)
		{
		fprintf(stderr, "err strtok\n");
		return -3;
		}
#if DEBUG_LEVEL
	fprintf(stderr, "fname = %s\n", cptr);
#endif

	/* insert all the big dataz in memory linear databaze */
	strncpy(waves_names[numid], cptr, T_FNAME);
	}

fclose(fp);

return 0;
}
/* --------------------------------------------------------------- */
static void list_waves(void)
{
int		foo;

for (foo=0; foo<NB_WAVES; foo++)
	fprintf(stderr, "%4d  |   %s\n", foo, waves_names[foo]);
}
/* --------------------------------------------------------------- */
int load_sound_in_core(void)
{
int	foo, indx;

return -1;
}

/* --------------------------------------------------------------- */
static int playfile(char *fname)
{
SNDFILE         	*sndf;
SF_INFO         	sfinfo;
int             	foo, lus;
long			total;
static int16_t  	buffer[T_BUFF_WAVES];

int                     default_driver;
ao_sample_format        format;
ao_device        	*device;

if ('\0' == fname[0])
	{
	fprintf(stderr, "Don't play anything\n");
	return -7;
	}

fprintf(stderr, "\nPlaying file %s\n", fname);
sndf = sf_open(fname, SFM_READ, &sfinfo);
if (NULL==sndf)
        {
        perror("sf_open");
        abort();
        }

printf(" samplerate : %d\n", sfinfo.samplerate);

ao_initialize();

default_driver = ao_default_driver_id();
#if DEBUG_LEVEL
fprintf(stderr, "ao default driver is #%d\n", default_driver);
#endif

memset(&format, 0, sizeof(format));
format.bits = 16;
format.channels = 2;
format.rate = sfinfo.samplerate;
format.byte_format = AO_FMT_LITTLE;

device = ao_open_live(default_driver, &format, NULL);
if (device == NULL) {
        fprintf(stderr, "Error opening AO device.\n");
	sf_close(sndf);
        return 1;
        }

/* push all the soundbits to the output */
total = 0;              
while ((lus = sf_read_short(sndf, buffer, T_BUFF_WAVES)))
        {
#if DEBUG_LEVEL      
        fprintf(stderr, "%s : %d bytes read\n", fname, lus);
#else
	putc('.', stderr);
#endif
        total += lus;
        /* send all the bits to the audio output  */
	foo = ao_play(device, buffer, lus*2);

	/* XXX maintenant, il fat se soucier si c'est pas
	   le moment de passer sur le sample suivant ? */

        }

#if DEBUG_LEVEL      
fprintf(stderr, "total -> %ld\n", total);
#else
putc('\n', stderr);
#endif

/* do some cleanup */
sf_close(sndf);
ao_close(device);
ao_shutdown();

return 0;
}
/* --------------------------------------------------------------- */
int grande_boucle(char *joydevice)
{
struct js_event		evn;
int			foo, fd;
int			nombre;

fd = open(joydevice, O_RDONLY | O_NONBLOCK);
if (fd < 0)
	{
	perror(joydevice);
	exit(1);
	}
nombre = 0;
for (;;)
	{
	foo = read(fd, &evn, sizeof(evn));
	if (0 == foo) {
		fprintf(stderr, "nothing...\n");
		}
	else if (sizeof(evn) == foo) {
		/* skip calibration datas */
		if (evn.type > 127)	continue;

		printf("%12d       %3u    %3u      %6d\n",
			evn.time, evn.type, evn.number, evn.value);
		/* got an event, blast the sound */
		}
	else	{
		// perror("joy read");
		sleep(1);
		}

	if (evn.number==8 && evn.value==1)	/* DEBUG */
		{
		list_waves();
		continue;
		}
	if (evn.number==9 && evn.value==1)	/* DEBUG */
		{
		fprintf(stderr, "Quit command\n");
		break;
		}
		
	if (evn.value == 1 &&			/* button down */
		evn.number >= 0 && evn.number < NB_WAVES)
		{
		/* action */	
		playfile(waves_names[evn.number]);
		printf("%d waves played\n", nombre++);
		sleep(1);
		}
	}
return 0;
}
/* --------------------------------------------------------------- */
int main(int argc, char *argv[])
{
int		foo;

fprintf(stderr, "  **************  pling !\n");

foo = lireconfig("madphoenix.conf");
if (foo < 0)
	exit(1);

grande_boucle("/dev/input/js0");

return 0;
}
/* --------------------------------------------------------------- */