#include "species_sound.h"

#include "system.h"

#include "files.h"

#include "psndplat.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 CharacterSoundEffects

{

    int num_voice_types;

    int num_voice_cats;

    struct

    {

        struct ScreamSoundCategory* category;

    } *voice_types;

    SOUNDINDEX global_last_sound;

    const char *data_file;

    const char *directory;

};

static struct CharacterSoundEffects MarineSounds =    {0, 0, NULL, SID_NOSOUND, "marsound.dat", "marinevoice"};

static struct CharacterSoundEffects AlienSounds =    {0, 0, NULL, SID_NOSOUND, "aliensound.dat", "alienvoice"};

static struct CharacterSoundEffects PredatorSounds =    {0, 0, NULL, SID_NOSOUND, "predsound.dat", "predatorvoice"};

static struct CharacterSoundEffects QueenSounds =    {0, 0, NULL, SID_NOSOUND, "queensound.dat", "queenvoice"};

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)

    {

        char full_path[50];

        sprintf(full_path, "npc%c%s", DIR_SEPARATOR, path);

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

            return i;

    }

return SID_NOSOUND;

}

static void LoadSoundData(struct CharacterSoundEffects *testus)

{

    char file_path[50];

    sprintf(file_path, "fastfile%c%s", DIR_SEPARATOR, testus->data_file);

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

    if(file == NULL)

    {

        printf("Failed to open %s\n", testus->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;

        testus->num_voice_types = *(int*)bufpos;

        bufpos += 4;

        testus->num_voice_cats = *(int*)bufpos;

        bufpos += 4;

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

        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(testus->directory, file_name);

                    if(SID_NOSOUND != sound->sound_number)

                        k++;

                    else

                        cat->num_sounds--;

                }

            }

        }

    }

    free(buffer);

}

static void FreeSoundStruct(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;

    }

}

void SpeciesSound(int VoiceType, int SoundCategory, int PitchShift, int *ExternalRef, VECTORCH* Location, enum SPECIES_SOUND species)

{

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

        return; //already playing a sound

    struct CharacterSoundEffects * testus;

    switch(species)

    {

        case ALIEN_SOUND:

            testus = &AlienSounds;

        break;

        case HUMAN_SOUND:

            testus = &MarineSounds;

        break;

        case PREDATOR_SOUND:

            testus = &PredatorSounds;

        break;

        case QUEEN_SOUND:

            testus = &QueenSounds;

    }

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

        return;

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

        return;

    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, "vpescd", sound->volume, pitch, ExternalRef, (int)species, SoundCategory, Location);

    else

        Sound_Play((SOUNDINDEX)sound->sound_number, "vpesc",  sound->volume, pitch, ExternalRef, (int)species, SoundCategory);

    //take note of the last sound played

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

}

void UnloadSpeciesSounds()

{

    FreeSoundStruct(&MarineSounds);

    FreeSoundStruct(&AlienSounds);

    FreeSoundStruct(&PredatorSounds);

    FreeSoundStruct(&QueenSounds);

}

void LoadSpeciesSounds()

{

    LoadSoundData(&MarineSounds);

    LoadSoundData(&AlienSounds);

    LoadSoundData(&PredatorSounds);

    LoadSoundData(&QueenSounds);

}