#include <RAT/Grid.hh>
#include <RAT/OptimisedComponent.hh>
#include <iostream>
#include <math.h>
#include <sstream>
using namespace RAT::Optimisers;
using namespace std;

void Grid::Initialise( const std::string& param )
{
  // Convert input string to fDiv, else make fDiv take default val
  if ( param.empty() ){
    fDiv=40;
  } else {
    stringstream strStream(param);
    strStream >> fDiv;
  }

}

double
Grid::Minimise()
{
  fMinFactor = 1.0;
  return fMinFactor*Evaluate();
}

double
Grid::Maximise()
{
  fMinFactor = -1.0;
  return fMinFactor*Evaluate();
}

double Grid::Evaluate()
{
  // Get initial seed parameters
  fParams = fComponent->GetParams();
  fPositiveErrors = fComponent->GetPositiveErrors();
  fNegativeErrors = fComponent->GetNegativeErrors();
  fTotalDim=fParams.size();

  // Initialise starting point of mixed space grid and increments
  fStartPos = fParams;
  fIncrements = fParams;
  // Range to be evaluated is from (seed-NegativeError) to (seed+PositiveError)
  for (int ii=0; ii<fTotalDim; ii++) {
    fStartPos[ii] -=fNegativeErrors[ii];
    fIncrements[ii] = ( fPositiveErrors[ii]+fNegativeErrors[ii] ) / (double) fDiv ;
  }

  fOptimalFom = fMinFactor * (*fComponent)(fStartPos);
  Scan( fParams, 0 );

  fValid = true;
  return fOptimalFom;
}

void Grid::Scan( std::vector<double> coords, int dimension )
{
  for( int spacePosition=0 ; spacePosition<fDiv; spacePosition++  )
  {
    coords[dimension] = fStartPos[dimension] + (spacePosition * fIncrements[dimension]);
    if( dimension != fTotalDim - 1 )
    {
      Scan( coords, dimension + 1 );
    }
    else
    {
      double fomHere = fMinFactor * (*fComponent)( coords );
      if ( fomHere <= fOptimalFom)
      {
        fOptimalFom = fomHere;
        fParams = coords;
      }
    }
  }
}