#include "system.h"

#include "files.h"

#include "prototyp.h"

#include "psndplat.h"

#include "scream.h"

#include <string.h>

#include <ctype.h>

#include <stdlib.h>

struct ScreamSound

{

    SOUNDINDEX sound_number;

    int pitch;

    int volume;    

};

struct ScreamSoundCategory

{

    int num_sounds;

    struct ScreamSound* sounds;

    SOUNDINDEX last_sound;

};

struct ScreamVoiceType

{

    struct ScreamSoundCategory* category;

};

struct CharacterSoundEffects

{

    int num_voice_types;

    int num_voice_cats;

    struct ScreamVoiceType* voice_types;

    SOUNDINDEX global_last_sound;

};

static struct CharacterSoundEffects MarineSounds =    {5, 15, 0, SID_NOSOUND};

static struct CharacterSoundEffects AlienSounds =    {3,  9, 0, SID_NOSOUND};

static struct CharacterSoundEffects PredatorSounds =    {1,  9, 0, SID_NOSOUND};

static struct CharacterSoundEffects QueenSounds =    {1,  3, 0, SID_NOSOUND};

static int load_scream_sounds(const char *path, const char * file_name)

{

    int i = SID_STARTOF_SCREAMSLOTS;

    for (; i < SID_ENDOF_SCREAMSLOTS && GameSounds[i].loaded; i++)

            continue;

    int l = SID_STARTOF_SCREAMSLOTS;

    for (; l < i; l++)

    {

        if (!strcmp(GameSounds[l].wavName, file_name))

            return l;

    }

    if ( i < SID_ENDOF_SCREAMSLOTS)

    {

        if (!GameSounds[i].loaded && LoadWavFile(i, path, file_name))

            return i;

    }

return SID_NOSOUND;

}

static void LoadSounds(struct CharacterSoundEffects *testus, const char *data_file, const char *directory)

{

    if(testus->voice_types)

        return;

    FILE *file = OpenGameFile(data_file, 1, FILETYPE_GAMEDATA);

    if(file == NULL)

    {

        printf("Failed to open %s\n", data_file);

        return;

    }

    fseek(file, 0, SEEK_END);

    int file_size = ftell(file);

    rewind(file);

    char* buffer = malloc(file_size + 1);

    fread(buffer, file_size, 1, file);

    fclose(file);

    if(!strncmp("MARSOUND", buffer, 8))

    {

        int i;

        char* bufpos = buffer + 8;

        //num_voice_types = *(int*)bufpos;

        bufpos += 4;

        //num_voice_cats = *(int*)bufpos;

        bufpos += 4;

        testus->voice_types = malloc(testus->num_voice_types * sizeof(struct ScreamVoiceType));

        for(i=0; i < testus->num_voice_types; i++)    

        {

            testus->voice_types[i].category = malloc(testus->num_voice_cats * sizeof(struct ScreamSoundCategory));

            int j=0;

            for(; j < testus->num_voice_cats; j++)

            {

                struct ScreamSoundCategory* cat = &testus->voice_types[i].category[j];

                cat->last_sound = SID_NOSOUND;

                cat->num_sounds = *(int*)bufpos;

                bufpos += 4;

                cat->sounds = NULL;

                if(cat->num_sounds)

                    cat->sounds = malloc(cat->num_sounds * sizeof(struct ScreamSound));

                int k = 0;

                for(; k < cat->num_sounds;)

                {

                    struct ScreamSound * sound = &cat->sounds[k];

                    char  * file_name = bufpos;

                    size_t i = 0;

                    for (; i < strlen(file_name); i++)

                        file_name[i] = tolower(file_name[i]);

                    bufpos += i+1;

                    sound->pitch = 0; //*(int*)bufpos; is always 0 

                    //bufpos += 4;

                    sound->volume = 127; // *(int*)bufpos; is always 127

                    //bufpos += 4;

                    bufpos += 8;

                    sound->sound_number = (SOUNDINDEX) load_scream_sounds(directory, file_name);

                    if(SID_NOSOUND != sound->sound_number)

                        k++;

                    else

                        cat->num_sounds--;

                }

            }

        }

    }

    free(buffer);

}

void UnloadSounds(struct CharacterSoundEffects * testus)

{

    if(testus->voice_types)

    {

        int i,j;

        for (i=0; i < testus->num_voice_types; i++)

        {

            for (j=0; j < testus->num_voice_cats; j++)

            {

                struct ScreamSoundCategory* cat = &testus->voice_types[i].category[j];

                if (cat->sounds)

                    free(cat->sounds);

            }

            free(testus->voice_types[i].category);

        }

        free(testus->voice_types);

        testus->voice_types = NULL;

        testus->num_voice_types = 0;

        testus->num_voice_cats = 0;

    }

}

static void PlaySound(struct CharacterSoundEffects * testus, int VoiceType, int SoundCategory, int PitchShift, int* ExternalRef, VECTORCH* Location)

{

//    assert(Location);

    if(!testus->voice_types || VoiceType < 0 || VoiceType >= testus->num_voice_types)

        return;

    if(SoundCategory < 0 || SoundCategory >= testus->num_voice_cats)

        return;

    if(ExternalRef && (*ExternalRef != SOUND_NOACTIVEINDEX))

        return; //already playing a sound

    struct ScreamSoundCategory* cat = &testus->voice_types[VoiceType].category[SoundCategory];

    //make sure there are some sound for this category

    if(!cat->num_sounds)

        return;

    int index = FastRandom() % cat->num_sounds;

    int num_checked = 0;

    //pick a sound , trying to avoid the last one picked

    if(cat->num_sounds > 2)

    {

        while(num_checked < cat->num_sounds)

        {

            SOUNDINDEX sound_ind = (SOUNDINDEX)cat->sounds[index].sound_number;

            if(sound_ind != cat->last_sound && sound_ind != testus->global_last_sound)

                    break;

            index++;

            num_checked++;

            if(index == cat->num_sounds)

                index=0;    

        }

    }

    struct ScreamSound* sound = &cat->sounds[index];

    int pitch = sound->pitch+PitchShift;

    if(Location)

        Sound_Play((SOUNDINDEX)sound->sound_number, "dvpe", Location, sound->volume, pitch, ExternalRef);

    else

        Sound_Play((SOUNDINDEX)sound->sound_number, "vpe", sound->volume, pitch, ExternalRef);

    //take note of the last sound played

    testus->global_last_sound = cat->last_sound = (SOUNDINDEX)sound->sound_number;

}

void UnloadScreamSounds()

{

    UnloadSounds(&MarineSounds);

    UnloadSounds(&AlienSounds);

    UnloadSounds(&PredatorSounds);

    UnloadSounds(&QueenSounds);

}

void LoadMarineScreamSounds()

{

    LoadSounds(&MarineSounds, "fastfile/marsound.dat", "npc/marinevoice");

}

void LoadAlienScreamSounds()

{

    LoadSounds(&AlienSounds, "fastfile/aliensound.dat", "npc/alienvoice");

}

void LoadPredatorScreamSounds()

{

    LoadSounds(&PredatorSounds, "fastfile/predsound.dat", "npc/predatorvoice");

}

void LoadQueenScreamSounds()

{

    LoadSounds(&QueenSounds, "fastfile/queensound.dat", "npc/queenvoice");

}

void PlayMarineScream(int VoiceType, int SoundCategory, int PitchShift, int* ExternalRef, VECTORCH* Location)

{

    PlaySound(&MarineSounds, VoiceType, SoundCategory, PitchShift, ExternalRef, Location);

}

void PlayAlienSound(int VoiceType, int SoundCategory, int PitchShift, int* ExternalRef, VECTORCH* Location)

{

    PlaySound(&AlienSounds, VoiceType, SoundCategory, PitchShift, ExternalRef, Location);

}

void PlayPredatorSound(int VoiceType, int SoundCategory, int PitchShift, int* ExternalRef, VECTORCH* Location)

{

    PlaySound(&PredatorSounds, VoiceType, SoundCategory, PitchShift, ExternalRef, Location);

}

void PlayQueenSound(int VoiceType, int SoundCategory, int PitchShift, int* ExternalRef, VECTORCH* Location)

{

    PlaySound(&QueenSounds, VoiceType, SoundCategory, PitchShift, ExternalRef, Location);

}