/******************************************************************************
 *
 *    Configuration Manager for AudioEditor
 *
 *****************************************************************************/
#include <stdio.h>     
#include <stdlib.h>
#include <string.h>

#include "AudioApp.h"
#include "CnfgMgr.h"
#include "Mgrs.h"

extern char   *bankFileName;
extern int    verbose;

#if 0
#define ms2smp(a)  (((int)((float)a * (float)OUTPUT_RATE/1000))&~0x7)
#endif

#define SECTION_SIZE  8


#define DEF_NUMBER_DMA_BUFFS              80
#define DEF_DMA_BUFF_SIZE               1024
#define DEF_DMA_FRAME_LAG                  4
#define DEF_NUMBER_SYNTH_VIRTUAL_VOICES   32
#define DEF_NUMBER_SYNTH_PHYSICAL_VOICES  32
#define DEF_NUMBER_SEQP_VOICES            32
#define DEF_DMA_QUEUE_SIZE                50
#define DEF_NUMBER_SYNTH_UPDATES         128
#define DEF_NUMBER_SEQP_EVENTS           128
#define DEF_CMD_LIST_SIZE               5000
#define DEF_SAMPLES_PER_FRAME            640 /* Best if a multiple of 160 */
#define DEF_OUTPUT_RATE                44100

#define SAMPLES_PER_FRAME                0
#define CMD_LIST_SIZE                    1
#define NUMBER_DMA_BUFFERS               2
#define DMA_BUFF_SIZE                    3
#define DMA_FRAME_LAG                    4
#define DMA_QUEUE_SIZE                   5
#define NUMBER_SYNTH_VIRTUAL_VOICES      6
#define NUMBER_SYNTH_PHYSICAL_VOICES     7
#define NUMBER_SYNTH_UPDATES             8
#define SYNTH_OUTPUT_RATE                9
#define NUMBER_SEQP_VOICES              10
#define NUMBER_SEQP_EVENTS              11
#define FX_TYPE                         12
#define BANK_FILE_NAME                  13
#define REVERB_PARAMS                   14

#define MAX_PARAM_STRINGS     15
#define NO_MATCH              -1

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_VOICES",
    "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"
};


CnfgMgr::CnfgMgr()
{
    customFXOK = 0;
    reverbAsset = 0;

}


int CnfgMgr::SetAudConfig(AudioConfig *audCnfg, char *fName)
{
    audCnfg->audioHeap = 0;                           // should be set by giomgr
    audCnfg->heapSize = 0;                            // should be set by giomgr
    audCnfg->frameSize = DEF_SAMPLES_PER_FRAME;
    audCnfg->maxCmdListSize = DEF_CMD_LIST_SIZE;
    audCnfg->numDMABuffs = DEF_NUMBER_DMA_BUFFS;
    audCnfg->dmaBufSize = DEF_DMA_BUFF_SIZE;
    audCnfg->frameLag = DEF_DMA_FRAME_LAG;
    audCnfg->dmaQSize = DEF_DMA_QUEUE_SIZE;
    audCnfg->synConfig.maxVVoices = DEF_NUMBER_SYNTH_VIRTUAL_VOICES;
    audCnfg->synConfig.maxPVoices = DEF_NUMBER_SYNTH_PHYSICAL_VOICES;
    audCnfg->synConfig.maxUpdates = DEF_NUMBER_SYNTH_UPDATES;
    audCnfg->synConfig.maxFXbusses = 1;
    audCnfg->synConfig.outputRate = DEF_OUTPUT_RATE;
    audCnfg->synConfig.fxType = 0;
    audCnfg->synConfig.params = 0;
    audCnfg->synConfig.heap = 0;                      // set by AudioApp
    audCnfg->synConfig.dmaproc = 0;                   // set by AudioApp 
    audCnfg->seqpConfig.maxVoices = DEF_NUMBER_SEQP_VOICES;
    audCnfg->seqpConfig.maxEvents = DEF_NUMBER_SEQP_EVENTS;
    audCnfg->seqpConfig.maxChannels = 16;
    audCnfg->seqpConfig.debugFlags = 0;
    audCnfg->seqpConfig.heap = 0;                     // set by AudioApp
    audCnfg->seqpConfig.initOsc = 0;
    audCnfg->seqpConfig.updateOsc = 0;
    audCnfg->seqpConfig.stopOsc = 0;
    
    /* fx_params = &default_fx_params[0]; */

    ConfigFromFile(audCnfg,fName);
    return (0);
}


int CnfgMgr::ConfigFromFile(AudioConfig *audCnfg, char *fName)
{
    int       param,value;
    int       len;
    char      *fdata;

    fdata = theFileMgr->GetFile(fName, &len);
    if((int)fdata == FILE_FAILURE)
	return -1;
    dataCur = fdata;
    dataEnd = fdata + len;

    while(1)
    {
	if(GetToken(NULL,&param) != TOKEN_PARAM_VALUE)
	{
	    free(fdata);	
	    return 0;
	}

	switch(param)
	{
	    case SAMPLES_PER_FRAME:
		if(GetToken(NULL,&value) != TOKEN_VALUE)
		    printf("Failure getting samples per frame\n"); 
		else 
		{
		    audCnfg->frameSize = value;
		    if(verbose)
			printf("%s = %d\n",paramStrs[param], value);
		}
		break;
	    case CMD_LIST_SIZE:
		if(GetToken(NULL,&value) != TOKEN_VALUE)
		    printf("Failure getting command list size\n");
		else
		{
		    audCnfg->maxCmdListSize = value;
		    if(verbose)
			printf("%s = %d\n",paramStrs[param], value);
		}
		break;                 
	    case NUMBER_DMA_BUFFERS:
		if(GetToken(NULL,&value) != TOKEN_VALUE)
		    printf("Failure getting number dma buffers\n");
		else
		{
		    audCnfg->numDMABuffs = value;
		    if(verbose)
			printf("%s = %d\n",paramStrs[param], value);
		}
		break;
	    case DMA_BUFF_SIZE:
		if(GetToken(NULL,&value) != TOKEN_VALUE)
		    printf("Failure getting dma buffer size\n");
		else
		{
		    audCnfg->dmaBufSize = value;
		    if(verbose)
			printf("%s = %d\n",paramStrs[param], value);
		}
		break;
	    case DMA_FRAME_LAG:
		if(GetToken(NULL,&value) != TOKEN_VALUE)
		    printf("Failure getting dma frame lag\n");
		else
		{
		    audCnfg->frameLag = value;
		    if(verbose)
			printf("%s = %d\n",paramStrs[param], value);
		}
		break;
	    case DMA_QUEUE_SIZE:
		if(GetToken(NULL,&value) != TOKEN_VALUE)
		    printf("Failure getting dma queue size\n");
		else
		{
		    audCnfg->dmaQSize = value;
		    if(verbose)
			printf("%s = %d\n",paramStrs[param], value);
		}
		break; 
	    case NUMBER_SYNTH_VIRTUAL_VOICES:
		if(GetToken(NULL,&value) != TOKEN_VALUE)
		    printf("Failure getting number synth virtual voices\n");
		else
		{
		    audCnfg->synConfig.maxVVoices = value;
		    if(verbose)
			printf("%s = %d\n",paramStrs[param], value);
		}
		break;
	    case NUMBER_SYNTH_PHYSICAL_VOICES:
		if(GetToken(NULL,&value) != TOKEN_VALUE)
		    printf("Failure getting number synth physical voices\n");
		else
		{
		    audCnfg->synConfig.maxPVoices = value;
		    if(verbose)
			printf("%s = %d\n",paramStrs[param], value);
		}
		break;
	    case NUMBER_SYNTH_UPDATES:
		if(GetToken(NULL,&value) != TOKEN_VALUE)
		    printf("Failure getting number synth updates\n");
		else
		{
		    audCnfg->synConfig.maxUpdates = value;
		    if(verbose)
			printf("%s = %d\n",paramStrs[param], value);
		}
		break;
	    case SYNTH_OUTPUT_RATE:
		if(GetToken(NULL,&value) != TOKEN_VALUE)
		    printf("Failure getting synth output rate\n");
		else
		{
		    audCnfg->synConfig.outputRate = value;
		    if(verbose)
			printf("%s = %d\n",paramStrs[param], value);
		}
		break;
	    case NUMBER_SEQP_VOICES:
		if(GetToken(NULL,&value) != TOKEN_VALUE)
		    printf("Failure getting number seqp voices\n");
		else
		{
		    audCnfg->seqpConfig.maxVoices = value;
		    if(verbose)
			printf("%s = %d\n",paramStrs[param], value);
		}
		break;
	    case NUMBER_SEQP_EVENTS:
		if(GetToken(NULL,&value) != TOKEN_VALUE)
		    printf("Failure getting number seqp events\n");
		else
		{
		    audCnfg->seqpConfig.maxEvents = value;
		    if(verbose)
			printf("%s = %d\n",paramStrs[param], value);
		}
		break;
	    case FX_TYPE:
		if(GetToken(NULL,&value) != TOKEN_FX_VALUE)
		    printf("Failure getting fx type\n");
		else
		{
		    if(value == AL_FX_CUSTOM)
			customFXOK = 1;

		    audCnfg->synConfig.fxType = value;

		    reverbAsset = theAssetMgr->CreateReverb();
		    if(!reverbAsset)
		    {
			customFXOK = 0;
			printf("Failure creating reverb asset\n");
			break;
		    }
		    reverbAsset->SetType(value);

		    if(verbose)
			printf("%s = %s\n",paramStrs[param],fxStrs[value]);
		}
		break;
	    case BANK_FILE_NAME:
		if(GetToken(&bankFileName,NULL) != TOKEN_STRING)
		    printf("Failure getting bank file name\n");
		else if(verbose)
		    printf("%s = %s\n",paramStrs[param], bankFileName);
		break;
	    case REVERB_PARAMS:
		if(!customFXOK)
		    printf("Encountered reverb params, before FX_TYPE set to AL_FX_CUSTOM\n");
		if(GetToken(NULL,&value) != TOKEN_VALUE)
		    printf("Failure getting number of fx sections\n");
		else
		{
		    int  i,max;
		    
		    if(customFXOK)
		    {
			if(reverbAsset)
			    reverbAsset->AllocParamBuf(value);
		    }
		    max = (value * PARAMS_PER_SECTION) + 2;
		    for(i = 1; i < max; i++)
		    {
			if(GetToken(NULL,&value) != TOKEN_VALUE)
			    printf("Failure getting reverb parameter %d\n",i);
			else
			{
			    if(verbose)
				printf("\t%d",value);
			    if(customFXOK)
				reverbAsset->SetParam(i,value);
			}
			
			if(verbose && ((i%8) == 1))
			    printf("\n");
		    }
		    if(verbose)
			printf("\n");
		}
		break;
	    default:
		printf("Found a param %s, with a value %d\n",paramStrs[param],value);
		break;
	} 
    }
}

int CnfgMgr::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))
		{
		    sLen = 1;
		    while((dataCur[sLen] >= 33 && dataCur[sLen] <= 60) || 
			  (dataCur[sLen] >= 62 && dataCur[sLen] <= 122))
			sLen++;
		    tStr = (char*)malloc(sLen+1);
		    if(tStr)
		    {
			for(i = 0; i < sLen; i++)
			    tStr[i] = *dataCur++;
			tStr[i] = 0;
			*tHdl = tStr;
			return (TOKEN_STRING);
		    }
		    else
			return (TOKEN_FAIL);
		}
	    }
	}
	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 CnfgMgr::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 CnfgMgr::ParamCmp(char *s1, char *s2)
{
    while(*s1 != 0)
    {
	if(*s1 == *s2)
	{
	    s1++;
	    s2++;
	}
	else
	    return (-1);
    }
    return (0);
}