// GTrackTest.hpp

#ifndef GTrackTest_H
#define GTrackTest_H

// Create a Gtrck for testing.

#include "GTrackPropagator.hpp"
#include "identifiers/ChunkID.hpp"
#include "trfbase/MissTest.h"
#include "trfcyl/SurfCylinder.h"
#include "d0cluster/TestCluster.hpp"
#include "FitStatus.hpp"
#include "GtrTrfPropagator.hpp"

namespace edm {
  class Event;
}

using edm::ChunkID;
using edm::Event;

class GTrackTest {
private:
  EventPtr _pevt;
  ChunkID _chkid;
public:
  int nclus;
  std::vector<ChunkClusterIndex> clusters;
  std::vector<trf::SurfacePtr> surfs;
  std::vector<trf::ETrack> etracks;
  std::vector<double> chsqs;
  std::vector<double> ss;
  std::vector<FitStatus> statii;
  GTrack::StateList stateset;
  std::vector<GTrackState> states;
  int nmiss;
  std::vector<trf::MissPtr> misses;
  std::vector<trf::SurfacePtr> miss_surfs;
  std::vector<trf::ETrack> miss_etracks;
  std::vector<double> miss_chsqs;
  std::vector<double> miss_ss;
  std::vector<FitStatus> miss_statii;
  std::vector<trf::SurfacePtr> all_surfs;
  GTrack gtr;
public:
  GTrackTest(std::string ok_prefix, const EventPtr& pevt =EventPtr(0),
             const edm::ChunkID& chkid =edm::ChunkID(), double vec0 =1.1 )
  : _pevt(pevt), _chkid(chkid) {
    //******************************************************************
    std::cout << ok_prefix << "Build clusters." << std::endl;
    clusters.push_back( ChunkClusterIndex(_pevt,_chkid,0) );
    clusters.push_back( ChunkClusterIndex(_pevt,_chkid,2) );
    clusters.push_back( ChunkClusterIndex(_pevt,_chkid,4) );
    clusters.push_back( ChunkClusterIndex(_pevt,_chkid,6) );
    clusters.push_back( ChunkClusterIndex(_pevt,_chkid,8) );
    nclus = clusters.size();
    //******************************************************************
    std::cout << ok_prefix << "Build tracks." << std::endl;
    surfs.push_back( trf::SurfacePtr( new trf::SurfCylinder(10.0) ) );
    surfs.push_back( trf::SurfacePtr( new trf::SurfCylinder(20.0) ) );
    surfs.push_back( trf::SurfacePtr( new trf::SurfCylinder(30.0) ) );
    surfs.push_back( trf::SurfacePtr( new trf::SurfCylinder(40.0) ) );
    surfs.push_back( trf::SurfacePtr( new trf::SurfCylinder(50.0) ) );
    miss_surfs.push_back( trf::SurfacePtr( new trf::SurfCylinder(15.0) ) );
    miss_surfs.push_back( trf::SurfacePtr( new trf::SurfCylinder(25.0) ) );
    miss_surfs.push_back( trf::SurfacePtr( new trf::SurfCylinder(35.0) ) );
    miss_surfs.push_back( trf::SurfacePtr( new trf::SurfCylinder(45.0) ) );
    all_surfs.push_back( surfs[0] );
    all_surfs.push_back( miss_surfs[0] );
    all_surfs.push_back( surfs[1] );
    all_surfs.push_back( miss_surfs[1] );
    all_surfs.push_back( surfs[2] );
    all_surfs.push_back( miss_surfs[2] );
    all_surfs.push_back( surfs[3] );
    all_surfs.push_back( miss_surfs[3] );
    all_surfs.push_back( surfs[4] );
    trf::TrackVector vec;
    trf::TrackError err;
    for ( int i=0; i<5; ++i ) {
      vec(i) = 0.011*double(i);
      err(i,i) = .001*double(i);
    }
    vec(0) = vec0;
    etracks.push_back( trf::ETrack(surfs[0],vec,err) );
    vec(0) += 1.1;
    etracks.push_back( trf::ETrack(surfs[1],vec,err) );
    vec(0) += 1.1;
    etracks.push_back( trf::ETrack(surfs[2],vec,err) );
    vec(0) += 1.1;
    etracks.push_back( trf::ETrack(surfs[3],vec,err) );
    vec(0) += 1.1;
    etracks.push_back( trf::ETrack(surfs[4],vec,err) );
    miss_etracks.push_back( trf::ETrack(miss_surfs[0],vec,err) );
    miss_etracks.push_back( trf::ETrack(miss_surfs[1],vec,err) );
    miss_etracks.push_back( trf::ETrack(miss_surfs[2],vec,err) );
    miss_etracks.push_back( trf::ETrack(miss_surfs[3],vec,err) );
    //******************************************************************
    std::cout << ok_prefix << "Build chi-squares." << std::endl;
    chsqs.push_back(12.3);
    chsqs.push_back(23.4);
    chsqs.push_back(34.5);
    chsqs.push_back(45.6);
    chsqs.push_back(56.7);
    miss_chsqs.push_back(1.1);
    miss_chsqs.push_back(2.1);
    miss_chsqs.push_back(3.1);
    miss_chsqs.push_back(4.1);
    //******************************************************************
    std::cout << ok_prefix << "Build ss" << std::endl;
    ss.push_back(10.0);
    ss.push_back(20.0);
    ss.push_back(30.0);
    ss.push_back(40.0);
    ss.push_back(50.0);
    miss_ss.push_back(15.0);
    miss_ss.push_back(25.0);
    miss_ss.push_back(35.0);
    miss_ss.push_back(45.0);
    //******************************************************************
    std::cout << ok_prefix << "Build fit statii" << std::endl;
    statii.push_back(OPTIMAL);
    statii.push_back(COMPLETE);
    statii.push_back(COMPLETE);
    statii.push_back(COMPLETE);
    statii.push_back(OPTIMAL);
    miss_statii.push_back(COMPLETE);
    miss_statii.push_back(COMPLETE);
    miss_statii.push_back(COMPLETE);
    miss_statii.push_back(COMPLETE);
    //******************************************************************
    std::cout << ok_prefix << "Build misses" << std::endl;
    misses.push_back( trf::MissPtr(new MissTest(15.0, 0.1)) );
    misses.push_back( trf::MissPtr(new MissTest(25.0, 0.2)) );
    misses.push_back( trf::MissPtr(new MissTest(35.0, 0.4)) );
    misses.push_back( trf::MissPtr(new MissTest(45.0, 0.8)) );
    nmiss = misses.size();
    //******************************************************************
    std::cout << ok_prefix << "Build global track cluster states." << std::endl;
    assert( nclus == clusters.size() );
    assert( nclus == ss.size() );
    assert( nclus == etracks.size() );
    assert( nclus == chsqs.size() );
    assert( nclus == statii.size() );
    for ( int i=0; i<nclus; ++i ) {
      GTrackState
        state(ss[i], etracks[i], statii[i], chsqs[i], clusters[i] );
      if ( ! state.cluster().is_valid() ) {
        std::cout << state.cluster() << std::endl;
      }
      stateset.insert(state);
    }
    //******************************************************************
    std::cout << ok_prefix << "Build global track miss track states." << std::endl;
    assert( nmiss == misses.size() );
    assert( nmiss == miss_ss.size() );
    assert( nmiss == miss_etracks.size() );
    assert( nmiss == miss_chsqs.size() );
    assert( nmiss == miss_statii.size() );
    for ( int i=0; i<nmiss; ++i ) {
      GTrackState state( miss_ss[i], miss_etracks[i], miss_statii[i],
                         miss_chsqs[i], misses[i] );
      assert( state.miss() != 0 );
      stateset.insert( state );
    }
    assert( stateset.size() == nclus+nmiss );
    //******************************************************************
    {
      GTrack::StateList::const_iterator ista;
      for ( ista=stateset.begin(); ista!=stateset.end(); ++ista ) {
        states.push_back(*ista);
      }
    }
    assert( states.size() == nclus+nmiss );
    //******************************************************************
    std::cout << ok_prefix << "Build global track." << std::endl;
    gtr = GTrack(stateset);
    std::cout << gtr << std::endl;
    assert( gtr.is_valid() );
    assert( gtr.get_states().size() == nclus+nmiss );
    //******************************************************************
  }
};

#endif