// GTrack_t.cpp

// Test GTrack.

#include "GTrackTest.hpp"

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

#ifdef GTrack_holds_chunk_id
using edm::ChunkID;
using edm::LinkIndex;
#endif

using namespace trf;

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

int main( ) {

  string component = "GTrack";
  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;
  }

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

  GTrackTest test(ok_prefix);
  int nclus = test.nclus;
  int nmiss = test.nmiss;
  int nstate = nclus + nmiss;
  const vector<double>& clus_ss = test.ss;
  const vector<double>& miss_ss = test.miss_ss;
  const vector<SurfacePtr>& clus_surfs = test.surfs;
  const vector<SurfacePtr>& miss_surfs = test.miss_surfs;
  const GTrack::StateList& states = test.stateset;
  const GTrack& gtr0 = test.gtr;
#ifdef GTrack_holds_chunk_id
  GTrack& mgtr0 = const_cast<GTrack&>(gtr0);
  ChunkID cid(4);
  unsigned int oid(123);
  ChunkID coid(cid.id(), oid);
  mgtr0.set_ids(cid,oid);
  {
    LinkIndex<GTrack> igtr = gtr0.index();
    assert( igtr.getPointer() == &gtr0 );
    cout << coid << endl;
    cout << igtr.id() << endl;
    assert( igtr.id() == coid );
  }
#else
  assert(false);
#endif

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

  cout << ok_prefix << "Build empty track." << endl;
  GTrack gtr2;
  assert( ! gtr2.is_valid() );
  assert( gtr0 != gtr2 );
  assert( ! (gtr0 == gtr2) );

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

  cout << ok_prefix << "Check copy." << endl;
  GTrack gtr1 = gtr0;
  GTrack gtr3 = gtr2;
  assert( gtr1.is_valid() );
  assert( ! gtr3.is_valid() );
  assert( gtr1 == gtr0 );
#ifdef GTrack_holds_chunk_id
  {
    LinkIndex<GTrack> igtr = gtr1.index();
    assert( igtr.getPointer() == &gtr1 );
    assert( igtr.id() == coid );
  }
#endif

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

  cout << ok_prefix << "Check assignment." << endl;
  gtr2 = gtr1;
  assert( gtr2.is_valid() );
  assert( gtr2 == gtr1 );
  gtr2 = gtr3;
  assert( ! gtr2.is_valid() );

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

  cout << ok_prefix << "Fetch states by s." << endl;
  // Every other state is a miss.
  {
    GTrack::StateList::const_iterator ista = states.begin();
    bool cluster = true;
    int iclus = 0;
    int imiss = 0;
    for ( int i=0; i<nstate; ++i ) {
      double s;
      if ( cluster ) {
        s= clus_ss[iclus++];
        cluster = false;
      } else {
        s = miss_ss[imiss++];
        cluster = true;
      }
      const GTrackState& state = gtr0.get_state(s);
      cout << "State " << i << endl;
      cout << state << endl;
      assert( state == *ista );
      ++ista;
    }
  }

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

  cout << ok_prefix << "Fetch states by surface." << endl;
  {
    GTrack::StateList::const_iterator ista = states.begin();
    bool cluster = true;
    int iclus = 0;
    int imiss = 0;
    for ( int i=0; i<nstate; ++i ) {
      SurfacePtr psrf(0);
      if ( cluster ) {
        psrf = clus_surfs[iclus++];
        cluster = false;
      } else {
        psrf = miss_surfs[imiss++];
        cluster = true;
      }
      const GTrackState& state = gtr0.get_state(psrf);
      cout << "State " << i << endl;
      cout << state << endl;
      assert( state == *ista );
      ++ista;
    }
  }

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

  cout << ok_prefix << "Build track with different track parameters." 
       << endl;
  {
    GTrackTest test4(ok_prefix,EventPtr(0),ChunkID(0),4.56);
    GTrack& gtr4 = test4.gtr;
    cout << gtr4 << endl;
    assert( gtr4 != gtr0 );
  }


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

  cout << ok_prefix << "Drop a fit" << endl;
  {
    GTrack gtr = gtr0;
    assert( gtr.get_states().size() > 1 );
    GTrack::StateList::const_iterator ista = gtr.get_states().begin();
    ++ista;
    double s = ista->s();
    cout << "s = " << s << endl;
    cout << gtr << endl;
    assert( gtr.get_state(s).has_valid_fit() );
    gtr.drop_fit(s);
    cout << gtr << endl;
    assert( ! gtr.get_state(s).has_valid_fit() );
  }


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

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

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

}