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

#include "parascan.hpp"
#include "vconnection.hpp"
#include "vnormalize.hpp"
#include "simmodules/simmodules.hpp"
#include "input.hpp"
#include "simloop.hpp"
#include <external/tinyxml/tinyxml.h>
#include "stopwatch.hpp"
#include <sstream>


using namespace std;


ParaScanValues::ParaScanValues(pair<float,float> _Range, int NValues)
{
    mValues = GenerateScanParaValues(_Range.first, _Range.second, NValues);
}

ParaScanValues::ParaScanValues(vector<float> _Values): mValues(_Values)
{
}

const vector<float>& ParaScanValues::Values()
{
    return mValues;
}

void ParaScanValues::print()
{
    ostringstream stream;
    for (vector<float>::iterator it=mValues.begin(); it!=mValues.end(); ++it)
    {
        stream << (*it) << " ";
    }
    Dout(dc::para, stream.str());
}

/** generate a list of parameter values in the range of LowBound to HighBound
 *
 * @param LowBound is the lower boundery
 * @param HighBound is the upper boundery
 * @param NValues is the number of values
 * @return vector of equally spaced parameter values
 */
vector<float> GenerateScanParaValues(float LowBound, float HighBound, int NValues)
{
    vector<float> RetVect;
    RetVect.push_back(LowBound);
    if (NValues <2) {
       return RetVect;
    }
    float StepSize=(HighBound-LowBound)/(NValues-1);
    for (int i=1;i<NValues;++i) {
        RetVect.push_back(LowBound+i*StepSize);
    }
    return RetVect;
}

//////////////////////////////
SingleValuePara::SingleValuePara(string _ParaName, vector<float> _ValueList): 
    ParaName(_ParaName), ValueList(_ValueList)
{
    NValues=ValueList.size();
    CurVal=0;
}

void SingleValuePara::Hello()
{
    Dout(dc::para,  "SingleValuePara, name=" << ParaName);
}

void SingleValuePara::WriteXmlAttribute(TiXmlElement* para) {
    Dout(dc::para,  "SingleValuePara::WriteXmlAttribute(TiXmlElement* para)");
    para->SetDoubleAttribute(ParaName.c_str(), ValueList[CurVal]);
};


bool SingleValuePara::Next()
{
    ++CurVal;
    bool Rewind=false;
    if (CurVal==NValues) {
        CurVal=0;
        Rewind=true;
    }
    return Rewind;
}

//////////////////////////////
TwoValuesPara::TwoValuesPara(string _Para1Name, string _Para2Name, 
                             vector<float> _Value1List, vector<float> _Value2List): 
Para1Name(_Para1Name), Para2Name(_Para2Name),  
Value1List(_Value1List), Value2List(_Value2List)
{
    NValues1=Value1List.size();
    NValues2=Value2List.size();
    CurVal1=0;
    CurVal2=0;
}

void TwoValuesPara::Hello()
{
    Dout(dc::para,  "TwoValuesPara, name1=" << Para1Name << " name2=" << Para2Name);
}

void TwoValuesPara::WriteXmlAttribute(TiXmlElement* para) {
    Dout(dc::para,  "TwoValuesPara::WriteXmlAttribute(TiXmlElement* para)");
    para->SetDoubleAttribute(Para2Name.c_str(), Value2List[CurVal2]);
    para->SetDoubleAttribute(Para1Name.c_str(), Value1List[CurVal1]);
};


bool TwoValuesPara::Next()
{
    bool RewindSecond=false;
    bool RewindFirst=false;
    if (++CurVal2>=NValues2) {
        CurVal2=0;
        RewindSecond=true;
    }
    if (RewindSecond) {
        if (++CurVal1>=NValues1) {
            CurVal1=0;
            RewindFirst=true;
        }
    }
    return RewindFirst;
}


//////////////////////////
SimLoopPara::SimLoopPara(SimLoop* _SimLoop,
                         ParaType _ptype,
                         vector<float> _ValueList,
                         string _ParaName):
MainSimLoop(_SimLoop),
ptype(_ptype),
SingleValuePara(_ParaName, _ValueList)
{
}

void SimLoopPara::SetPara()
{
    MainSimLoop->SetParameter(ptype, ValueList[CurVal]);
}

///////////////////////////////
ContrastInputPara::ContrastInputPara(PictureSequenceInput* _PInput, 
                                     vector<float> _BackgroundStrength, 
                                     vector<float> _StimContrast): 
TwoValuesPara("InputStrength", 
              "StimContrast", 
              _BackgroundStrength, 
              _StimContrast), 
PInput(_PInput)
{
}

void ContrastInputPara::SetPara()
{
    float Contrast=Value2List[CurVal2];
    float Background=Value1List[CurVal1];
    float Strength = Background*Contrast;
    PInput->SetBackgroundStrength(Background);
    PInput->SetInputStrength(Strength);
}


void ContrastInputPara::SetParaBackgroundOnly()
{
    float Contrast=Value2List[CurVal2];
    float Background=Value1List[CurVal1];
    float Strength = Background*Contrast;
    PInput->SetBackgroundStrength(Background);
    PInput->SetInputStrength(0*Strength);
}


void NoiseAmplitudePara::SetPara()
{
    mLayer->SetNoiseAmplitude(ValueList[CurVal]);
}

////////////////////////
GaussConProfilePara::GaussConProfilePara(VecConnection* _con, 
                                         vector<float> Range, 
                                         vector<float> Strength,
                                         float _MinDelay,
                                         float _MaxDelay)
:TwoValuesPara("ExExRange", 
               "ExExStrength", 
               Range, 
               Strength), 
con(_con),
MinDelay(_MinDelay), 
MaxDelay(_MaxDelay)
{   
}

void GaussConProfilePara::SetPara()
{
    int ConNumber=CurVal1*NValues2+CurVal2;
    float NewRangeVal = Value1List[CurVal1];
    float NewStrengthVal = Value2List[CurVal2];
    if (NewRangeVal != OldRangeVal || NewStrengthVal != OldStrengthVal) {
        con->DeleteSynapseArrays();
        con->ConnectGaussian(NewRangeVal,
                             NewStrengthVal,
                             MaxDelay,
                             MinDelay,
                             true);
        // con->Save(ConNumber);
        OldRangeVal=NewRangeVal;
        OldStrengthVal=NewStrengthVal;
    }
}

////////////////////////
ChangableTwoValuePara::ChangableTwoValuePara(const string& NameVal1,
                                             const string& NameVal2,
                                             vector<float> Values1,
                                             vector<float> Values2,
                                             Changable* ObjectToBeChanged)
:TwoValuesPara(NameVal1, NameVal2, Values1, Values2), mParaChangeTarget(ObjectToBeChanged), mOldValue1(0), mOldValue2(0)
{
}

void ChangableTwoValuePara::SetPara()
{    
    float NewValue1 = Value1List[CurVal1];
    float NewValue2 = Value2List[CurVal2];
    if (NewValue1 != mOldValue1 || NewValue2 != mOldValue2) {
        TwoParameters<float,float> Val1Val2  =  TwoParameters<float,float>(NewValue1, NewValue2);
        mParaChangeTarget->changeParameter(&Val1Val2);
        mOldValue1 = NewValue1;
        mOldValue2 = NewValue2;
    }
}


////////////////////////

void InhExStrengthPara::SetPara()
{
    Dout(dc::para,  "InhExStrengthPara::SetPara(): SetInhExWeightStrength"); 
    CompInh->SetInhExWeightStrength(ValueList[CurVal]);
}

///////////////////////

void ParameterCollection::AddContrastInputPara(PictureSequenceInput* _PInput,
                                               vector<float> _BackgroundStrength,
                                               vector<float> _StimContrast)
{
    ContrastInputPara* StimContrastInput = new ContrastInputPara(
        _PInput,
        _BackgroundStrength,
        _StimContrast);
    AddPara(StimContrastInput);
}


/** set next parameter combination
 * @return true if all parameters were rewinded (after last parameter in parameter space)
 */
bool ParameterCollection::NextPara()
{
    size_t NParas=ScanParaList.size();
    bool RewindAll=false;
    bool IncNextPara=true;
    size_t ParaNum=0;
    while (ScanParaList[ParaNum]->Next()) { 
    // next returns true if para was rewinded --> then the next para has to be    increased.
        ++ParaNum;
        if (ParaNum==NParas) {
            RewindAll=true;
            break;
        }
    }
    return RewindAll;
}


/** set all parameters according to current values
 */
void ParameterCollection::SetPara()
{
    for (ScanParaIter it=ScanParaList.begin();it!=ScanParaList.end();++it) {
        (*it)->SetPara();
    }
}

/** write xml attributes for all current parameters
 */
void ParameterCollection::WriteXmlAttributes(TiXmlElement* para)
{
    for (ScanParaIter it=ScanParaList.begin();it!=ScanParaList.end();++it) {
        (*it)->WriteXmlAttribute(para);
    }
}

bool TestParameterCollection()
{
    
    
}


void ParameterCollection::testNetwork(const pair<float,float>& InputIntervalInSec,
                                      const float& SecondsPerParameter,
                                      input* TestInput )
{
    Interval InputInterval(InputIntervalInSec);
    int LoopCount=0;
    int step=0;
    int sec =0;
    int t=0;
    StopWatch TestStopWatch;

    
    SimLoop* MainSimLoop = TestInput->getSimLoop();
    float dt = MainSimLoop->GetDeltaT();
    int MacroTimeStep = MainSimLoop->GetMacroTimeStep();
    int NSteps = 1000*(SecondsPerParameter/dt)/MacroTimeStep;
    
    bool UseInputInterval = InputInterval.isValid();
    int InputStartStep = static_cast<int>(InputInterval.LowBound()/dt);
    int InputStopStep  = static_cast<int>(InputInterval.HighBound()/dt);        

    
    TiXmlDocument XmlDoc((MainSimLoop->GetDataDirectory()
            +"/parameter.xml").c_str());
    
    TiXmlElement XmlRoot("ScanTagsAndParameters");
    XmlDoc.InsertEndChild(XmlRoot);
    TiXmlNode* xroot=XmlDoc.FirstChild();
    
    TestStopWatch.start();
    do {
        SetPara();
        MainSimLoop->showMemoryConsumption();
        MainSimLoop->SaveSimInfo();
        string SimTag = string("TEST")+stringify(LoopCount);
        MainSimLoop->SetSimTag(SimTag.c_str());
        
        TiXmlElement p("Para");
        p.SetAttribute("SimTag", SimTag.c_str());
        WriteXmlAttributes(&p);
        
        xroot->InsertEndChild(p);
        XmlDoc.SaveFile();
        MainSimLoop->reset(0);
        
        if (UseInputInterval) {
            TestInput->setSilent(true);
            Dout(dc::para, "Turn Input off.");
        }
                
        int TotalTimeStep;
        for (step=0;step<NSteps;++step) {
            int TotalStep = (step+LoopCount*NSteps);
            
            cout << "Loop" << LoopCount << "  Step=" << step
                    << " sec= " << dt*(sec++) << "\n";
            
            // simulation of one MacroTimeStep            
            for (t=0;t<MacroTimeStep;t++) {
                TotalTimeStep=MacroTimeStep*step+t;
                
                if (UseInputInterval) {
                    if (TotalTimeStep==InputStartStep) {
                        Dout(dc::para, "Turn Input on. TotalTimeStep=" << TotalTimeStep);
                        TestInput->setSilent(false);
                    }
                    if (TotalTimeStep==InputStopStep) {
                        Dout(dc::para, "Turn Input off. TotalTimeStep=" << TotalTimeStep);
                        TestInput->setSilent(true);
                    }
                }
                
                MainSimLoop->proceede(TotalTimeStep);
            }
            
            Dout(dc::para, "prepare(step)");
            
            TestStopWatch.stopRound();
            
            MainSimLoop->prepare(step);
            Dout(dc::para, "prepared"); 
        }
        
        ++LoopCount;
    } while (!NextPara());
    
    XmlDoc.SaveFile();
}