#include "system.h"

#include "stratdef.h"

#include "psndplat.h"

#include "userprofile.h"

#include <assert.h>

int MasterVolumeFadeLevel = ONE_FIXED;

static enum {FADE_STATUS_READY, FADE_STATUS_UP, FADE_STATUS_DOWN, FADE_STATUS_DOWN_FAST} MasterVolumeFadeStatus = FADE_STATUS_READY;

static unsigned int Sound_MaxActive_HW = SOUND_MAXACTIVE_SW + 32;

void Sound_Stop(int activeSoundNumber)

{

    if((activeSoundNumber < 0) || (activeSoundNumber >= SOUND_MAXACTIVE))

        return;

    if(SID_NOSOUND != ActiveSounds[activeSoundNumber].soundIndex)

    {

        /* update game sound instances, and external reference */

        SOUNDINDEX soundNo = ActiveSounds[activeSoundNumber].soundIndex;

        GameSounds[soundNo].activeInstances--;

        assert((GameSounds[soundNo].activeInstances >= 0) && (GameSounds[soundNo].activeInstances < SOUND_MAXINSTANCES));

        if(ActiveSounds[activeSoundNumber].externalRef)

            *(ActiveSounds[activeSoundNumber].externalRef) = SOUND_NOACTIVEINDEX;

        /* stop the sound: it may have already stopped, of course, but never mind */

        PlatStopSound(activeSoundNumber);

        //fprintf(stderr, "PSND: Stop: %d %d %s\n", activeSoundNumber, soundNo, GameSounds[soundNo].wavName);

        ActiveSounds[activeSoundNumber].soundIndex = SID_NOSOUND;

    }

}

void SoundSys_StopAll()

{

    int i;

    for(i=0; i < SOUND_MAXACTIVE; i++)

        Sound_Stop(i);

}

void SoundSys_ChangeVolume(int volume)

{

    static int GlobalVolume = VOLUME_DEFAULT;

    if (GlobalVolume != volume)

    {

        int newVolume = (volume > VOLUME_MAX) ? VOLUME_MAX : (volume < VOLUME_MIN) ? VOLUME_MIN : volume;

        if (newVolume != GlobalVolume)

        {

            GlobalVolume = newVolume;

            /* call the platform function: if we get back an error, ignore it */

            PlatChangeGlobalVolume(newVolume);

        }

    }

}

static void HandleFadingLevel()

{

    switch(MasterVolumeFadeStatus)

    {

        default:

        case FADE_STATUS_READY:

        break;

        case FADE_STATUS_UP:

        {

            MasterVolumeFadeLevel += NormalFrameTime/2;

            if (MasterVolumeFadeLevel > ONE_FIXED)

            {

                MasterVolumeFadeLevel = ONE_FIXED;

                MasterVolumeFadeStatus = FADE_STATUS_READY;

            }

        }

        break;

        case FADE_STATUS_DOWN:

        {

            MasterVolumeFadeLevel -= NormalFrameTime/8;

            if (MasterVolumeFadeLevel < 0)

            {

                MasterVolumeFadeLevel = 0;

                MasterVolumeFadeStatus = FADE_STATUS_READY;

            }

        }

        break;

        case FADE_STATUS_DOWN_FAST:

        {

            MasterVolumeFadeLevel -= NormalFrameTime;

            if (MasterVolumeFadeLevel < 0)

            {

                MasterVolumeFadeLevel = 0;

                MasterVolumeFadeStatus = FADE_STATUS_READY;

            }

        }

    }

}

void SoundSys_Management()

{

    int i;

    for(i=0; i < SOUND_MAXACTIVE; i++)

    {

        if(SID_NOSOUND != ActiveSounds[i].soundIndex)

        {

            if(SoundHasStopped(i))

            {

                Sound_Stop(i);

            }

            else if(ActiveSounds[i].threedee) 

            {

                PlatDo3dSound(i);

            }        

        }

    }

    HandleFadingLevel();

    PlatUpdatePlayer();

#if DEBUG_SOUNDS

    {

        int i = Sound_MaxActive_HW;

        int num_active = 0;

        while(i-- > 0)

        {

            if(ActiveSounds[i].soundIndex != SID_NOSOUND)

                num_active++;

        }

        printf("Number of Active Sounds %u \n", num_active);

        i = Sound_MaxActive_HW;

        while(i-- > 0)

        {

            if(ActiveSounds[i].soundIndex != SID_NOSOUND)

                printf("%s\n", GameSounds[ActiveSounds[i].soundIndex].wavName);

        }

    }

#endif

    switch(UserProfile.active_bonus)

    {

        case CHEATMODE_WARPSPEED:

        case CHEATMODE_JOHNWOO:

            UpdateSoundFrequencies();

        default:

        break;

    }

}

void SoundSys_ResetFadeLevel()

{

    MasterVolumeFadeLevel = ONE_FIXED;

    MasterVolumeFadeStatus = FADE_STATUS_READY;    

}

void SoundSys_FadeIn()

{

    /* always fade in from silence ? */

    MasterVolumeFadeLevel = ONE_FIXED/2;

    MasterVolumeFadeStatus = FADE_STATUS_UP;    

}

void SoundSys_FadeOut()

{

    MasterVolumeFadeLevel = ONE_FIXED;

    MasterVolumeFadeStatus = FADE_STATUS_DOWN;    

}

void SoundSys_FadeOutFast()

{

    MasterVolumeFadeLevel = ONE_FIXED;

    MasterVolumeFadeStatus = FADE_STATUS_DOWN_FAST;    

}

static int FindFreeActiveSound(unsigned int min, unsigned int max)

{

    unsigned int i = min;

    for(; i < max; i++) 

    {

        if(ActiveSounds[i].soundIndex == SID_NOSOUND)

                return i;

    }

return SOUND_NOACTIVEINDEX;

}

static int FindLowerPriorityActiveSound(ACTIVESOUNDPRIORITY testPriority, unsigned int min, unsigned int max)

{

    unsigned int i = min;

    for(; i < max; i++) 

    {

        if((ActiveSounds[i].soundIndex != SID_NOSOUND) && (ActiveSounds[i].priority < testPriority))

                return i;

    }

return SOUND_NOACTIVEINDEX;

}

/* Patrick 5/6/97 -------------------------------------------------------------

  Functions for playing and controlling individual sounds

  ----------------------------------------------------------------------------*/

void Sound_Play(SOUNDINDEX soundNumber, const char *format, ...)

{

    /* check soundIndex for bounds, whether it has been loaded, and number of instances */

    if((soundNumber < 0) || (soundNumber >= SID_MAXIMUM) || !GameSounds[soundNumber].loaded || !(GameSounds[soundNumber].activeInstances <
SOUND_MAXINSTANCES))

        return;

    int loop = 0;

    int *externalRef = NULL;

    ACTIVESOUNDPRIORITY priority = ASP_Minimum;

    SOUND3DDATA * p_3ddata = NULL;

    VECTORCH * worldPosn = NULL;

    int reverb_off = 0;

    int soundStartPosition = 0;

    int species = -1;

    int species_category = -1;

    //printf("About to play sound %i %s\n", soundNumber, GameSounds[soundNumber].wavName);

    int volume = GameSounds[soundNumber].volume;

    int pitch = GameSounds[soundNumber].pitch;

    int marine_ignore = 0;

    /* examine the format string: if it is null, ignore it */

    if(format)

    {

        const char *nextChar = format;

        va_list argPtr;

        va_start(argPtr, format);

        while(*nextChar != '\0')

        {

            switch(*nextChar)

            {

                case 'd':

                    worldPosn = va_arg(argPtr, VECTORCH*);

                break;

                case 'n':

                    p_3ddata = va_arg(argPtr, SOUND3DDATA*);

                break;

                case 'e':

                    externalRef = va_arg(argPtr, int*);

                break;

                case 'l':

                    loop = 1;

                //no break;

                case 'h':

                    priority = ASP_Maximum;

                break;

                case 'v':

                {

                    volume = va_arg(argPtr, int);

                    if(volume > VOLUME_MAX)

                        volume = VOLUME_MAX;

                    else if(volume < VOLUME_MIN)

                        volume = VOLUME_MIN;

                }        

                break;

                case 'p':

                {                    

                    pitch = va_arg(argPtr, int);

                    if(pitch > PITCH_MAX)

                        pitch = PITCH_MAX;

                    else if(pitch < PITCH_MIN)

                        pitch = PITCH_MIN;

                }

                break;

                case 'm':

                    marine_ignore = 1;

                break;

                case 'r':

                    reverb_off = 1;

                break;

                case 'P':

                    soundStartPosition = va_arg(argPtr,int);

                break;

                case 's':

                    species = va_arg(argPtr, int);

                break;

                case 'c':

                    species_category = va_arg(argPtr, int);

                default:

                break;

            }

            nextChar++;

        }

        va_end(argPtr);    

    }

    /* check for invalid parameter combinations */

    if(loop && (externalRef == NULL))

    {

        printf("SoundPlay bad params.\n");

        return;

    }

    /* Deal with resource allocation. */

    /* Range of active buffers to search. */

    unsigned int min, max;

    GameSounds[soundNumber].flags |= SAMPLE_IN_SW;

    if(GameSounds[soundNumber].flags & SAMPLE_IN_SW)

    {

        min = 0;

        max = SOUND_MAXACTIVE_SW;

    }

    else

    {

        min = SOUND_MAXACTIVE_SW + 1;

        max = Sound_MaxActive_HW;

    }

    int newIndex = FindFreeActiveSound(min, max);

    if((newIndex == SOUND_NOACTIVEINDEX) && !(GameSounds[soundNumber].flags & SAMPLE_IN_SW))

    {

        //failed to find a free hardware slot , so try software slot instead.

        //mainly to cope with cards that can load sounds into hardware , but can't play them there

        newIndex = FindFreeActiveSound(0, SOUND_MAXACTIVE_SW);

    }

    if(newIndex == SOUND_NOACTIVEINDEX)

    {

        printf("Having to stop another sound.\n");

        /* try to find an existing sound with a lower priority */

        newIndex = FindLowerPriorityActiveSound(priority, min, max);

        if(newIndex == SOUND_NOACTIVEINDEX && !(GameSounds[soundNumber].flags & SAMPLE_IN_SW))

        {

            //failed to find a free hardware slot , so try software slot instead.

            //mainly to cope with cards that can load sounds into hardware , but can't play them there

            newIndex = FindLowerPriorityActiveSound(priority, 0, SOUND_MAXACTIVE_SW);

        }

        if(newIndex == SOUND_NOACTIVEINDEX)

        {

            printf("Failed to find a lower priority sound.\n");

            return; /* give up */

        }

        /* remove it, and use it's slot */

        printf("Stopping a lower priority sound.\n");

        Sound_Stop(newIndex);

    }

    //else printf("Found a free slot.\n");

    if (GameSounds[soundNumber].loaded)

    {

        ActiveSounds[newIndex].soundIndex = soundNumber;

        ActiveSounds[newIndex].priority = priority;

        ActiveSounds[newIndex].volume = volume;

        ActiveSounds[newIndex].pitch = pitch;

        ActiveSounds[newIndex].externalRef = externalRef;

        ActiveSounds[newIndex].species = species;

        ActiveSounds[newIndex].species_category = species_category;

        ActiveSounds[newIndex].loop = loop;

        ActiveSounds[newIndex].threedee = 0;

        ActiveSounds[newIndex].paused = 0;

        ActiveSounds[newIndex].marine_ignore = marine_ignore;

        ActiveSounds[newIndex].reverb_off = reverb_off;

        if(worldPosn) 

        {

            ActiveSounds[newIndex].threedeedata.position = *worldPosn;

            ActiveSounds[newIndex].threedeedata.outer_range = 32000;

            ActiveSounds[newIndex].threedee = 1;

        }

        else if(p_3ddata)

        {

            ActiveSounds[newIndex].threedeedata = *p_3ddata;

            ActiveSounds[newIndex].threedee = 1;

        }

        if(PlatPlaySound(newIndex))

        {

            GameSounds[soundNumber].activeInstances++;

            if(externalRef)

                *externalRef = newIndex;

        }

        else

        {

            /* the sound failed to play: any platform cleanups should have been done, so just bank the sound slot */

            ActiveSounds[newIndex].soundIndex = SID_NOSOUND;

            printf("Error: PlatPlaySound failed for %d.\n", soundNumber);

        }

    }

    else

    {

        printf("GameSound %d not loaded \n", soundNumber);

    }

}

void Sound_ChangeVolume(int activeSoundNumber, int volume)

{

    if((activeSoundNumber < 0) || (activeSoundNumber >= SOUND_MAXACTIVE))

        return;

    if(SID_NOSOUND != ActiveSounds[activeSoundNumber].soundIndex)

    {

        /* check the new volume is different from the old one */

        if(volume != ActiveSounds[activeSoundNumber].volume)

        {

            ActiveSounds[activeSoundNumber].volume = (volume > VOLUME_MAX) ? VOLUME_MAX : (volume < VOLUME_MIN) ? VOLUME_MIN : volume;

            /* if we're a 2d sound, just change the volume, but if we're 3d then call 3d update instead */

            if(ActiveSounds[activeSoundNumber].threedee)

                PlatDo3dSound(activeSoundNumber);

            else

                PlatChangeSoundVolume(activeSoundNumber,ActiveSounds[activeSoundNumber].volume);    

        }

    }

}

void Sound_ChangePitch(int activeSoundNumber, int pitch)

{

    if((activeSoundNumber < 0) || (activeSoundNumber >= SOUND_MAXACTIVE))

        return;

    if(SID_NOSOUND != ActiveSounds[activeSoundNumber].soundIndex)

    {

        if(pitch != ActiveSounds[activeSoundNumber].pitch)

        {

            ActiveSounds[activeSoundNumber].pitch = (pitch > PITCH_MAX) ? PITCH_MAX : (pitch < PITCH_MIN) ? PITCH_MIN : pitch;

            PlatChangeSoundPitch(activeSoundNumber,ActiveSounds[activeSoundNumber].pitch);    

        }

    }

}

void Sound_Update3d(int activeSoundNumber, VECTORCH* posn)

{

    if((activeSoundNumber < 0) || (activeSoundNumber >= SOUND_MAXACTIVE))

        return;

    /* Check there's a sound in this slot */

    if(ActiveSounds[activeSoundNumber].soundIndex != SID_NOSOUND)

        ActiveSounds[activeSoundNumber].threedeedata.position = *posn;

}

void Sound_UpdateNew3d(int activeSoundNumber, SOUND3DDATA * s3d)

{

    if((activeSoundNumber < 0) || (activeSoundNumber >= SOUND_MAXACTIVE))

        return;

    /* Check there's a sound in this slot */

    if(ActiveSounds[activeSoundNumber].soundIndex != SID_NOSOUND)

        ActiveSounds[activeSoundNumber].threedeedata = *s3d;

}

static SOUNDINDEX GetSoundIndexFromNameAndIndex(const char* name, SOUNDINDEX index)

{

    int i = 0;

    if(index >= 0 && index < SID_MAXIMUM)

    {

        if(GameSounds[index].loaded)

        {

            if(!strcmp(GameSounds[index].wavName, name))

                return index;

        }

    }

    for(; i < SID_MAXIMUM; i++)

    {

        if(GameSounds[i].loaded)

        {

            if(!strcmp(GameSounds[i].wavName, name))

                return (SOUNDINDEX) i;

        }

    }

return SID_NOSOUND;

}

#include "savegame.h"

typedef struct sound_save_block

{

    SAVE_BLOCK_HEADER header;

    int fileNameLength;

    SOUNDINDEX soundIndex;

    ACTIVESOUNDPRIORITY priority;    

    int volume;

    int pitch;

    unsigned int loop :1;        

    unsigned int threedee :1;

    unsigned int marine_ignore :1;

    unsigned int reverb_off :1;

    unsigned int externalRef :1;

    SOUND3DDATA threedeedata;

    int position;

} SOUND_SAVE_BLOCK;

//defines for load/save macros

#define SAVELOAD_BLOCK block

#define SAVELOAD_BEHAV sound

void Load_SoundState(int* soundHandle)

{

    if(!soundHandle)

        return;

    SOUND_SAVE_BLOCK* block = (SOUND_SAVE_BLOCK*)GetNextBlockIfOfType(SaveBlock_SoundState);

    if(!block)

        return;

    const char* name = (const char*)(block+1);

    //stop the current sound

    if(*soundHandle == SOUND_NOACTIVEINDEX)

        Sound_Stop(*soundHandle);

    //check the size

    if(block->header.size != sizeof(*block) + block->fileNameLength)

        return;

    SOUNDINDEX soundIndex = GetSoundIndexFromNameAndIndex(name,block->soundIndex);

    if(soundIndex == SID_NOSOUND)

        return;

    char playOptions[20] = "evpP";

    if(block->loop)

        strcat(playOptions,"l");

    if(block->marine_ignore)

        strcat(playOptions,"m");

    if(block->reverb_off)

        strcat(playOptions,"r");

    if(block->priority == ASP_Maximum)

        strcat(playOptions,"h");

    if(block->threedee)

    {

        strcat(playOptions,"n");

        Sound_Play(soundIndex, playOptions, soundHandle, block->volume, block->pitch, block->position, &block->threedeedata);

    }

    else

    {

        Sound_Play(soundIndex, playOptions, soundHandle, block->volume, block->pitch, block->position);

    }

}

void Save_SoundState(int* soundHandle)

{

    if(!soundHandle)

        return;

    if(*soundHandle == SOUND_NOACTIVEINDEX)

    {

        SAVE_BLOCK_HEADER* header;

        GET_SAVE_BLOCK_POINTER(header);

        //fill in the header

        header->size = sizeof(*header);

        header->type = SaveBlock_SoundState;

    }

    else

    {

        ACTIVESOUNDSAMPLE* sound = &ActiveSounds[*soundHandle];

        const char* name = GameSounds[sound->soundIndex].wavName;

        int name_length = strlen(name) + 1;

        SOUND_SAVE_BLOCK* block = GetPointerForSaveBlock(sizeof(*block)+name_length);

        //fill in the header

        block->header.size = sizeof(*block) + name_length;

        block->header.type = SaveBlock_SoundState;

        COPYELEMENT_SAVE(soundIndex)

        COPYELEMENT_SAVE(priority)    

        COPYELEMENT_SAVE(volume)

        COPYELEMENT_SAVE(pitch)

        COPYELEMENT_SAVE(loop)        

        COPYELEMENT_SAVE(threedee)

        COPYELEMENT_SAVE(marine_ignore)

        COPYELEMENT_SAVE(reverb_off)

        COPYELEMENT_SAVE(threedeedata)

        block->externalRef = 1;

        block->position = 0;

           block->fileNameLength = name_length;

        //the volume in the active sound list is scaled differently from the volume used

        //by Sound_Play

        block->volume <<= 7;

        block->volume /= VOLUME_PLAT2DSCALE;

        block->position = 0;

        //fprintf(stderr, "Save_SoundState: GetCurrentPosition!\n");

        strcpy((char*)(block+1),name);

    }    

}

void Load_SoundState_NoRef(SAVE_BLOCK_HEADER* header)

{

    SOUND_SAVE_BLOCK* block = (SOUND_SAVE_BLOCK*) header;

    const char* name = (const char*)(block+1);

    //check the size

    if(block->header.size != sizeof(*block) + block->fileNameLength)

        return;

    //only load if the sound doesn't require an external reference

    if(block->externalRef)

        return;

    SOUNDINDEX soundIndex = GetSoundIndexFromNameAndIndex(name,block->soundIndex);

    if(soundIndex != SID_NOSOUND)

    {

        char playOptions[20] = "vpP";

        if(block->marine_ignore)

            strcat(playOptions, "m");

        if(block->reverb_off)

            strcat(playOptions, "r");

        if(block->priority == ASP_Maximum)

            strcat(playOptions, "h");

        if(block->threedee)

        {

            strcat(playOptions, "n");

            Sound_Play(soundIndex, playOptions, block->volume, block->pitch, block->position, &block->threedeedata);

        }

        else

        {

            Sound_Play(soundIndex, playOptions, block->volume, block->pitch, block->position);

        }

    }

}

void Save_SoundsWithNoReference()

{

    int i = 0;

    for(; i < SOUND_MAXACTIVE; i++)

    {

        if(ActiveSounds[i].soundIndex != SID_NOSOUND)

        {

            if(!ActiveSounds[i].externalRef)

            {

                ACTIVESOUNDSAMPLE* sound = &ActiveSounds[i];

                SOUND_SAVE_BLOCK* block;

                const char* name = GameSounds[sound->soundIndex].wavName;

                int name_length = strlen(name) + 1;

                block = GetPointerForSaveBlock(sizeof(*block)+name_length);

                //fill in the header

                block->header.size = sizeof(*block) + name_length;

                block->header.type = SaveBlock_SoundState;

                COPYELEMENT_SAVE(soundIndex)

                COPYELEMENT_SAVE(priority)    

                COPYELEMENT_SAVE(volume)

                COPYELEMENT_SAVE(pitch)

                COPYELEMENT_SAVE(loop)        

                COPYELEMENT_SAVE(threedee)

                COPYELEMENT_SAVE(marine_ignore)

                COPYELEMENT_SAVE(reverb_off)

                COPYELEMENT_SAVE(threedeedata)

                block->externalRef = 0;

                block->position = 0;

                block->fileNameLength = name_length;

                //the volume in the active sound list is scaled differently from the volume used by Sound_Play

                block->volume <<= 7;

                block->volume /= VOLUME_PLAT2DSCALE;

                block->position = 0;

                strcpy((char*)(block+1),name);

            }

        }

    }

}