// ETrackGenerator_t.cpp

#include "ETrackGenerator.hpp"

#include <cassert>
#include <string>
#include <iostream>
#include <vector>
#include "ptr/Ptr.h"
#include "ptr/AutoPolicy.h"
#include "trfbase/SurfTest.h"
#include "trfbase/SurfacePtr.h"
#include "trfbase/ETrack.h"

using std::cout;
using std::cerr;
using std::endl;
using std::string;
using std::vector;

using namespace trf;

typedef Ptr<ETrack,AutoPolicy> ETPtr;

//**********************************************************************

int main( ) {

  string component = "ETrackGenerator";
  string ok_prefix = component + " (I): ";
  string error_prefix = component + " test (E): ";

  cout << ok_prefix
       << "---------- Testing component " + component
          + ". ----------" << endl;

  // Make sure assert is enabled.
  bool assert_flag = false;
  assert ( ( assert_flag = true, assert_flag ) );
  if ( ! assert_flag ) {
    cerr << "Assert is disabled" << endl;
    return 1;
  }

  //********************************************************************

  // Verify that each generated track is different and is in range.
  cout << ok_prefix << "Test default sequence." << endl;
  //SurfTest an_stest(1);
  SurfacePtr stest(new SurfTest(1));
  //  SurfacePtr stest;
  //  stest=&an_stest;
  TrackVector min;
  TrackVector max;
  min(0) = 0.0;
  max(0) = 1.0;
  min(1) = 1.0;
  max(1) = 2.0;
  min(2) = -3.0;
  max(2) = -2.0;
  min(3) = 3.0;
  max(3) = 4.0;
  min(4) = -4.0;
  max(4) = 5.0;
  TrackError emin;
  TrackError emax;
  for (int i=0;i<5;++i) {emax(i,i) = abs(max(i)*0.5);}

  ETrackGenerator gen(stest,min,max,emin,emax);
  cout << gen << endl;
  //  assert( stest.pure_equal( gen.get_surface() ) );
  int ntest = 2;
  int itest;
  vector<ETPtr> values;
  vector<ETPtr>::const_iterator ival;
  cout << "-----------" << endl;
  for ( itest=0; itest<ntest; ++itest ) {
    ETPtr ptrk( gen.new_track() );
    cout << *ptrk << endl;
    cout << "************" << endl;
    for ( ival=values.begin(); ival!=values.end(); ++ival ) {
      assert( *ptrk != (**ival) );
    }
    //  assert( stest.pure_equal( *ptrk->get_surface() ) );
    for ( int i=0; i<5; ++i ) {
      assert( ptrk->get_vector()(i) >= min(i) );
      assert( ptrk->get_vector()(i) <= max(i) );
    }
    values.push_back(ptrk);
  }

  //********************************************************************

  // Verify that two generators starting with the same seed give the
  // same values.
  cout << ok_prefix << "Test sequence with seed." << endl;
  long seed = 246813579L;
  gen.set_seed(seed);
  ETrackGenerator gen2(stest,min,max,emin,emax);
  gen2.set_seed(seed);
  for ( itest=0; itest<ntest; ++itest ) {
    ETPtr ptrk( gen.new_track() );
    ETPtr ptrk2( gen2.new_track() );
    cout << *ptrk << endl;
    cout << "*" << endl;
    cout << *ptrk2 << endl;
    cout << "************" << endl;
    assert( *ptrk == *ptrk2 );
  }

  //********************************************************************

  //********************************************************************

  cout<< "Make a generator with the automatic limits"<<endl;
  ETrackGeneratorLimits myLimits;
  ETrackGenerator gen3(stest,myLimits);
  ETPtr ptrk( gen3.new_track() );
  cout << *ptrk << endl << "***xx***"<<endl<<endl;

  cout << ok_prefix << "Test copy constructor." << endl;
  ETrackGenerator gen4(gen);
  for ( itest=0; itest<ntest; ++itest ) {
    ETPtr ptrk( gen.new_track() );
    ETPtr ptrk2( gen4.new_track() );
    cout << *ptrk << endl;
    cout << "*" << endl;
    cout << *ptrk2 << endl;
    cout << "************" << endl;
    assert( *ptrk == *ptrk2 );
  }

  //********************************************************************

  cout << ok_prefix
       << "------------- All tests passed. -------------" << endl;
  return 0;

  //********************************************************************

}