#include "sys.hpp"   // for libcwd
#include "debug.hpp" // for libcwd

#include "stimulussequence.hpp"

#include <iostream>

using namespace std;

StimulusSequence::StimulusSequence(): SeqPointer(0), Length(0)
{
}


StimulusSequence::StimulusSequence(
    const char* _SequenceFileName): SequenceFileName(_SequenceFileName), SeqPointer(0), Length(0)
{
    Load(SequenceFileName.c_str());
}

bool StimulusSequence::Load(const char* _SequenceFileName)
{
    int StrLen;
    Dout(dc::input,  "open sequence file: " << _SequenceFileName <<  "");
    fflush(stdout);

    //! \todo check if file exists, check length of header
    FILE* fw = fopen(_SequenceFileName, "r");
    fread(&StrLen, sizeof(StrLen), 1, fw);
    char FileTypeString[StrLen];
    fread(&FileTypeString, StrLen, 1, fw);
    fread(&StrLen, sizeof(StrLen), 1, fw);
    char VersionString[StrLen];
    fread(&VersionString, StrLen, 1, fw);
    Dout(dc::input,  "finfo=" << FileTypeString << "");
    Dout(dc::input,  "Version=" << VersionString << "");
    fflush(stdout);

    char StimBytes;
    //! \todo check if file size is consistant with Length and StimBytes
    fread(&StimBytes, sizeof(StimBytes), 1, fw);
    int MinStim, MaxStim;
    fread(&Length, sizeof(Length), 1, fw);
    fread(&MinStim, sizeof(MinStim), 1, fw);
    fread(&MaxStim, sizeof(MaxStim),1,fw);

    switch (StimBytes) {

        case 1: {
            char* sequence = new char [Length];
            fread(sequence, sizeof(*sequence), Length, fw);
            CurStimSequence = vector<int>(Length);

            for (int i=0; i<Length;++i) CurStimSequence[i] = int(sequence[i]);

            delete [] sequence;

//   for (int i=0; i<Length;++i)  Dout(dc::input,  char(GetNextSeqElement()));
            if (CurStimSequence.size() != Length) cerr << "ERROR!!!!!!!!!!!!!!\n\n";

            cout << "StimBytes == 1\n";
        }

        break;

        case 4: {
            int* sequence = new int [Length];
            fread(sequence, sizeof(*sequence), Length, fw);
            CurStimSequence = vector<int>(sequence, sequence+Length);
            delete [] sequence;
//   for (int i=0; i<Length;++i)  Dout(dc::input,  int(GetNextSeqElement()));

            if (CurStimSequence.size() != Length) cerr << "ERROR!!!!!!!!!!!!!!\n\n";

            cout << "Sequence loaded. Length = " <<  CurStimSequence.size() << " StimBytes == 4\n";
        }

        break;

        default:
            cerr << "ERROR, libcsim.cpp: StimulusSequence::StimulusSequence, StimBytes don't fit \n\n";
    }


    Dout(dc::input,  "StimBytes=" << int(StimBytes) << "Length=" << Length << " MinStim=" << MinStim << " MaxStim=" << MaxStim << "");

    fclose(fw);
    return true;
}




StimulusSequence::~StimulusSequence()
{
}


void StimulusSequence::GenerateRandomSequence(int NStim, int NWdh, const gsl_rng* gslr)
{

    int Length = NStim*NWdh;
    CurStimSequence = vector<int>(Length);
    int CurNr=0;
    // create sorted list

    for (int i=0; i<NStim;++i) {
        for (int j=0;j<NWdh;++j) {
            CurStimSequence[CurNr] = i+1;
            ++CurNr;
        }
    }

    // shuffle list
    int TempStim;

    int ChangeNr=0;

    for (CurNr=0;CurNr<Length;++CurNr) {
        ChangeNr = Length - gsl_rng_uniform_int(gslr, Length - CurNr)-1;
        TempStim = CurStimSequence[ChangeNr];
        CurStimSequence[ChangeNr] = CurStimSequence[CurNr];
        CurStimSequence[CurNr] = TempStim;
    }
}


int StimulusSequence::GetNextSeqElement()
{
    if (Length > 0) {
        ++SeqPointer;

        if (SeqPointer>=Length) SeqPointer=0;

        return int(CurStimSequence[SeqPointer]);

    } else {
        cerr << "ERROR: Stimulus sequence has zero length.\n";
        return 0;
    }
}

int StimulusSequence::GetNextRandomElement(const gsl_rng* gslr)
{
    if (Length > 0) {
        SeqPointer = gsl_rng_uniform_int(gslr, Length);
        return int(CurStimSequence[SeqPointer]);

    } else return 0;
}