#include <stdio.h>     
#include <stdlib.h>
#include <string.h>
#include <iostream.h>
#include <fstream.h>

#include "n64.h"
#include "AeConfig.h"
#include "AeN64ConfigFile.h"
#include "AeN64Driver.h"
#include "GioMgr.h"
#include "AeErr.h"


#define MAX_PARAM_LENGTH      32

extern char    verbose;

enum
{
    kAeNoFx = -1000,
    kAeNoCustomFx = -1001
};


enum 
{
    TOKEN_FAIL = 0,
    TOKEN_PARAM_VALUE,
    TOKEN_FX_VALUE,
    TOKEN_STRING,
    TOKEN_VALUE
};

enum
{
    NO_MATCH = -1,
    SAMPLES_PER_FRAME,
    CMD_LIST_SIZE,
    NUMBER_DMA_BUFFERS,
    DMA_BUFF_SIZE,
    DMA_FRAME_LAG,
    DMA_QUEUE_SIZE,
    NUMBER_SYNTH_VIRTUAL_VOICES,
    NUMBER_SYNTH_PHYSICAL_VOICES,
    NUMBER_SYNTH_UPDATES,
    SYNTH_OUTPUT_RATE,
    NUMBER_SEQP_CHANNELS,
    NUMBER_SEQP_EVENTS,
    FX_TYPE,
    BANK_FILE_NAME,
    REVERB_PARAMS,
    MAX_PARAM_STRINGS
};


char paramStrs[MAX_PARAM_STRINGS][MAX_PARAM_LENGTH] = {
    "SAMPLES_PER_FRAME",
    "CMD_LIST_SIZE",
    "NUMBER_DMA_BUFFERS",
    "DMA_BUFF_SIZE",
    "DMA_FRAME_LAG",
    "DMA_QUEUE_SIZE",
    "NUMBER_SYNTH_VIRTUAL_VOICES",
    "NUMBER_SYNTH_PHYSICAL_VOICES",
    "NUMBER_SYNTH_UPDATES",
    "SYNTH_OUTPUT_RATE",
    "NUMBER_SEQP_CHANNELS",
    "NUMBER_SEQP_EVENTS",
    "FX_TYPE",
    "BANK_FILE_NAME",
    "REVERB_PARAMS"
};

#define MAX_REVERB_STRINGS   7

char fxStrs[MAX_REVERB_STRINGS][MAX_PARAM_LENGTH] = {
    "AL_FX_NONE",
    "AL_FX_SMALLROOM",
    "AL_FX_BIGROOM",
    "AL_FX_CHORUS",
    "AL_FX_FLANGE",
    "AL_FX_ECHO",
    "AL_FX_CUSTOM"
};



AeN64ConfigFile::AeN64ConfigFile (const char * name) : AeFile (name)
{
    dataCur = NULL;
    dataEnd = NULL;
}


AeN64ConfigFile::~AeN64ConfigFile (void)
{
}


AeErr
AeN64ConfigFile::Write (AeN64Config * config)
{
    ofstream 	fOut;
    AeErr	err = kAeNoErr;

    fOut.open (fFullName);

    if (fOut)
    {
	fOut << "/* N64 Audio Configuration File */\n\n";

	fOut << "SYNTH_OUTPUT_RATE = " 		  << config->c.synConfig.outputRate << '\n';
	fOut << "SAMPLES_PER_FRAME = " 		  << config->c.frameSize << '\n';
	fOut << "CMD_LIST_SIZE = "     		  << config->c.maxCmdListSize << '\n';
	fOut << "NUMBER_DMA_BUFFERS = "		  << config->c.numDMABuffs << '\n';
	fOut << "DMA_BUFF_SIZE = " 		  << config->c.dmaBufSize << '\n';
	fOut << "DMA_QUEUE_SIZE = "		  << config->c.dmaQSize << '\n';
	fOut << "DMA_FRAME_LAG = "		  << config->c.frameLag << '\n';
	fOut << "NUMBER_SYNTH_VIRTUAL_VOICES = "  << config->c.synConfig.maxVVoices << '\n';
	fOut << "NUMBER_SYNTH_PHYSICAL_VOICES = " << config->c.synConfig.maxPVoices << '\n';
	fOut << "NUMBER_SYNTH_UPDATES = " 	  << config->c.synConfig.maxUpdates << '\n';
	fOut << "NUMBER_SEQP_CHANNELS = "	  << (int)config->c.seqpConfig.maxChannels << '\n';
	fOut << "NUMBER_SEQP_EVENTS = " 	  << config->c.seqpConfig.maxEvents << '\n';

	if (!fOut)
	    err = kAeFileBadWrite;

	fOut.close ();
    }

    if (err)
	ReportError (err);

    return err;    
}


AeErr
AeN64ConfigFile::Read (AeN64Config * config)
{
    int       	param, value;
    int       	len;
    char *	fdata;
    int	      	tokenID;
    AeErr     	err;

    if (err = getFileData ((char *)fFullName, fdata, len))
	return err;

    dataCur = fdata;
    dataEnd = fdata + len;

    while (getToken (NULL,&param) == TOKEN_PARAM_VALUE)
    {
	tokenID = getToken (NULL, &value);

#ifndef NDEBUG
	if (verbose)
	    printf("debug: n64: %s = %d\n",paramStrs[param], value);
#endif

	switch(param)
	{
	    case SAMPLES_PER_FRAME:
		if (tokenID == TOKEN_VALUE)
		    config->c.frameSize = value;
		break;

	    case CMD_LIST_SIZE:
		if (tokenID == TOKEN_VALUE)
		    config->c.maxCmdListSize = value;
		break;
                 
	    case NUMBER_DMA_BUFFERS:
		if (tokenID == TOKEN_VALUE)
		    config->c.numDMABuffs = value;
		break;

	    case DMA_BUFF_SIZE:
		if (tokenID == TOKEN_VALUE)
		    config->c.dmaBufSize = value;
		break;

	    case DMA_FRAME_LAG:
		if (tokenID == TOKEN_VALUE)
		    config->c.frameLag = value;
		break;

	    case DMA_QUEUE_SIZE:
		if (tokenID == TOKEN_VALUE)
		    config->c.dmaQSize = value;
		break;
 
	    case NUMBER_SYNTH_VIRTUAL_VOICES:
		if (tokenID == TOKEN_VALUE)
		{
		    config->c.synConfig.maxVVoices = value;
		    config->c.seqpConfig.maxVoices = value;
		}
		break;

	    case NUMBER_SYNTH_PHYSICAL_VOICES:
		if (tokenID == TOKEN_VALUE)
		    config->c.synConfig.maxPVoices = value;
		break;

	    case NUMBER_SYNTH_UPDATES:
		if (tokenID == TOKEN_VALUE)
		    config->c.synConfig.maxUpdates = value;
		break;

	    case SYNTH_OUTPUT_RATE:
		if (tokenID == TOKEN_VALUE)
		    config->c.synConfig.outputRate = value;
		break;

	    case NUMBER_SEQP_CHANNELS:
		if (tokenID == TOKEN_VALUE)
		    config->c.seqpConfig.maxChannels = value;
		break;

	    case NUMBER_SEQP_EVENTS:
		if (tokenID == TOKEN_VALUE)
		    config->c.seqpConfig.maxEvents = value;
		break;

	    case FX_TYPE:
		// no longer necessary since built-in effects
		// are automatically created for editing
		break;

	    case REVERB_PARAMS:
		readFxParams (config, value);
		break;

	    default:
		cout << "warning: " << fFileName << ": found unknown param ";
		cout << paramStrs[param] << "with value " << value << '\n';
		cout.flush ();
		break;
	} 
    }

    free (fdata);	
    return kAeNoErr;
}


void
AeN64ConfigFile::readFxParams (AeN64Config * config, int nSections)
{
    AeFxAsset *		fxAsset;
    AeFxSxnAsset *	sxnAsset;
    int			value;
    int			i;
		    
    if (fxAsset = new AeFxAsset ("custom"))
    {		    
	if (getToken (NULL, &value) == TOKEN_VALUE)
	    fxAsset->SetLength (value);

	for (i=0; i<nSections; i++)
	{
	    sxnAsset = new AeFxSxnAsset ("");
	    fxAsset->AppendChild (sxnAsset);

	    if (getToken(NULL, &value) == TOKEN_VALUE)
		sxnAsset->SetInput (value);

	    if (getToken(NULL, &value) == TOKEN_VALUE)
		sxnAsset->SetOutput (value);

	    if (getToken(NULL, &value) == TOKEN_VALUE)
		sxnAsset->SetFBCoef (value);

	    if (getToken(NULL, &value) == TOKEN_VALUE)
		sxnAsset->SetFFCoef (value);

	    if (getToken(NULL, &value) == TOKEN_VALUE)
		sxnAsset->SetGain (value);

	    if (getToken(NULL, &value) == TOKEN_VALUE)
		sxnAsset->SetChorusRate (value);

	    if (getToken(NULL, &value) == TOKEN_VALUE)
		sxnAsset->SetChorusDepth (value);

	    if (getToken(NULL, &value) == TOKEN_VALUE)
		sxnAsset->SetFilterCoef (value);
	}

	config->SetFxAsset (fxAsset);
    }
}



int AeN64ConfigFile::getToken(char **tHdl, int *val)
{
#define  NO_MODE          0
#define  COMMENT_MODE     1
#define  DEC_VALUE_MODE   3
#define  HEX_VALUE_MODE   4

    char  c, *tStr;
    int   oldMode,mode = NO_MODE;
    int   value = 0;
    int   sign = 1;
    int   hexV,sLen,i;

    while(1)
    {
	if(dataCur >= dataEnd)
	    return TOKEN_FAIL;

	c = *dataCur;

	if(c == '/' && dataCur[1] == '*') /* start a comment */
	{
	    oldMode = mode;
	    mode = COMMENT_MODE;
	}
	else if(mode == COMMENT_MODE && c == '*' && dataCur[1] == '/' )
	{
	    dataCur++; /* set past end of comment */
	    mode = oldMode;
	}
	else if(mode == NO_MODE)
	{
	    if(c == '-')
		sign = -1;
	    else if(c == '0' && ( dataCur[1] == 'x' || dataCur[1] == 'X'))
	    {
		mode = HEX_VALUE_MODE;
		dataCur++;
	    }
	    else if(c >= '0' && c <= '9')
	    {
		mode = DEC_VALUE_MODE;
		value = c - '0';
	    }
	    else
	    {
		for(i = 0; i < MAX_PARAM_STRINGS; i++)
		{
		    if(paramCmp(paramStrs[i], dataCur) == 0)
		    {
			dataCur += strlen(paramStrs[i]);
			if(val)
			{
			    *val = i;
			    return(TOKEN_PARAM_VALUE);
			}
			else
			    return(TOKEN_FAIL);
		    }
		}
		for(i = 0; i < MAX_REVERB_STRINGS; i++)
		{
		    if(paramCmp(fxStrs[i], dataCur) == 0)
		    {
			dataCur += strlen(fxStrs[i]);
			if(val)
			{
			    *val = i;
			    return(TOKEN_FX_VALUE);
			}
			else
			    return(TOKEN_FAIL);
		    }
		}

		if((c >= 33 && c <= 60) || (c >= 62 && c <= 122))
		{
		    if (tHdl)
		    {
			sLen = 1;
			while((dataCur[sLen] >= 33 && dataCur[sLen] <= 60) || 
			      (dataCur[sLen] >= 62 && dataCur[sLen] <= 122))
			    sLen++;

			tStr = (char*)malloc(sLen+1);
			FailNIL (tStr);

			for(i = 0; i < sLen; i++)
			    tStr[i] = *dataCur++;
			tStr[i] = 0;
			*tHdl = tStr;
		    }
		    return (TOKEN_STRING);
		}
	    }
	}
	else if(mode == HEX_VALUE_MODE)
	{
	    hexV = hexValue(c);
	    if(hexV >= 0)
	    {
		value *= 16;
		value += hexV;
	    }
	    else /* ended */
	    {
		dataCur++;
		if(val)
		{
		    *val = sign * value;
		    return (TOKEN_VALUE);
		}
		else
		    return (TOKEN_FAIL);
	    }
	}
	else if(mode == DEC_VALUE_MODE)
	{
	    if(c >= '0' && c <= '9')
	    {
		value *= 10;
		value += c - '0';
	    }
	    else
	    {
		dataCur++;
		if(val)
		{
		    *val = sign * value;
		    return (TOKEN_VALUE);
		}
		else
		    return (TOKEN_FAIL);
	    }
	}
	    
	dataCur++;
    }
}

int AeN64ConfigFile::hexValue(char c)
{
    if(c >= '0' && c <= '9')
	return(c - '0');

    if(c >= 'a' && c <= 'f')
	return(c - 'a' + 10);

    if(c >= 'A' && c <= 'F')
	return(c - 'A' + 10);

    return(-1);
}

int AeN64ConfigFile::paramCmp(char *s1, char *s2)
{
    while(*s1 != 0)
    {
	if(*s1 == *s2)
	{
	    s1++;
	    s2++;
	}
	else
	    return (-1);
    }
    return (0);
}


void
AeN64ConfigFile::ReportError (AeErr err)
{
    switch (err)
    {
	case kAeNoFx:
	    cout <<  "error: failure creating effect\n";
	    break;

	case kAeNoCustomFx:
	    cout << "warning: " << fFileName;
	    cout << ": encountered effects params before FX_TYPE set to AL_FX_CUSTOM\n";
	    break;

	default:
	    AeFile::ReportError (err);
	    break;
    }

    cout.flush ();
}