// LayerXYPlane_t.cpp

#include "BSurfXYPlane.h"
#include "LayerXYPlane.h"
#include "trflayer/ClusterFindAll.h"
#include "HitXYPlane1.h"
#include "HitXYPlane2.h"
#include "trfbase/ETrack.h"
#include "PropXYXY.h"
#include "trflayer/LayerStat.h"
#include "trfutil/TRFMath.h"
#include "trfutil/trfstream.h"
#include <cassert>
#include <string>
#include <sstream>
#include "objstream/StdObjStream.hpp"
#include "trflayer/ClusterContainer.h"

#ifndef DEFECT_NO_STDLIB_NAMESPACES
using std::cout;
using std::cerr;
using std::endl;
using std::string;
using std::ostringstream;
using std::istringstream;
#endif

using namespace trf;

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

int main( ) {

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

  //********************************************************************
  cout << trf_format;

  cout << ok_prefix << "Test constructor." << endl;
  double dist1 = 20.;
  double dist2 = 40.;
  double phi1  = PI/3.;
  double phi2  = PI/5.;
  MutableClusterFindManagerPtr pfind1 = MutableClusterFindManagerPtr(
    new ClusterFindAll( SurfacePtr(new SurfXYPlane(dist1,phi1)) ));
  MutableClusterFindManagerPtr pfind2 = MutableClusterFindManagerPtr(
    new ClusterFindAll( SurfacePtr(new SurfXYPlane(dist2,phi2)) ));
  MutableClusterFindManagerPtr pfind3 = MutableClusterFindManagerPtr(
    new ClusterFindAll( SurfacePtr(new SurfXYPlane(dist1,phi1)) ));
  LayerXYPlane lxy_1( SurfXYPlanePtr(new SurfXYPlane(dist1, phi1 )), pfind1 );
  LayerXYPlane lxy2( SurfXYPlanePtr(new SurfXYPlane(dist2, phi2 )), pfind2 );
  LayerXYPlane lxy1(lxy2);
  lxy1=lxy_1;
  LayerXYPlane lxy3( SurfXYPlanePtr(new BSurfXYPlane(dist1, phi1 , -50.0, 50.0, -60.0 , 60.0)), pfind3 );
  cout << lxy2 << endl;

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

  cout << ok_prefix << "Test type." << endl;
  cout << lxy1.get_type() << endl;
  cout << lxy2.get_type() << endl;
  assert( lxy1.get_type() != 0 );
  assert( lxy1.get_type() == lxy2.get_type() );

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

  cout << ok_prefix << "Define a surface and track." << endl;
  SurfXYPlane sxy0(dist1,phi1);
  SurfXYPlane sxy1(dist1-15.,PI/3.);
  TrackVector vec;
  vec(0) = 1.0;    // v
  vec(1) = 5.0;    // z
  vec(2) = 0.1;    // dv/du
  vec(3) = -0.2;   // dz/du
  vec(4) = 0.002;  // q/p
  TrackError err,err1;
  err.fill(0.0);
  err1.fill(0.0);
  err1(0,0)=err1(1,1)=err1(2,2)=err1(3,3)=err1(4,4)=1000.;
  err(0,0)=err(1,1)=err(2,2)=err(3,3)=err(4,4)=0.01;
  ETrack tre0(SurfacePtr(sxy0.new_pure_surface()),vec,err);
  tre0.set_forward();
  ETrack tre(SurfacePtr(sxy1.new_pure_surface()),vec,err);
  tre.set_forward();
  cout << tre << endl;

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

  cout << ok_prefix << "Check cluster access" << endl;
  assert( lxy1.has_clusters() );
  lxy1.add_cluster(ClusterPtr(new ClusXYPlane1(dist1,phi1,1.,1.,1.0,0.1)) );
  lxy1.add_cluster(ClusterPtr(new ClusXYPlane1(dist1,phi1,1.,1.,2.0,0.1)) );
  lxy1.add_cluster(ClusterPtr(new ClusXYPlane1(dist1,phi1,1.,1.,3.0,0.1)) );
  const LayerXYPlane& lxy1c = lxy1;
  cout << lxy1c.get_clusters().size() << endl;
  assert( lxy1c.get_clusters().size() == 3 );

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

  cout << ok_prefix << "Propagate from inside." << endl;
  PropXYXY prop(ObjDoublePtr(new ObjDouble(-2.0)));
  LTrackList ltracks ;
  lxy1.propagate(tre,prop,ltracks);
  assert( ltracks.size() == 1 );
  // save a copy of the propagated track
  const LTrack trl1 = ltracks.front();
  const ETrack& tre1 = trl1.get_track();
  const LayerStat& lstat1 = trl1.get_status();
  cout << trl1 << endl;
  assert( lstat1.at_exit() );
  assert( lstat1.get_state() == 1 );
  ltracks.clear();
  lxy1.propagate(trl1,prop,ltracks);
  assert( ltracks.size() == 0 );
  ltracks.clear();

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

  cout << ok_prefix << "Check returned miss." << endl;
  assert( ! lstat1.get_miss() );

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

  cout << ok_prefix << "Check returned clusters." << endl;
  assert( lstat1.has_clusters() );
  assert( lstat1.get_clusters().size() == 3 );
  assert( lstat1.get_clusters(tre,0,0).get_clusters().size() == 3 );

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

  cout << ok_prefix << "Propagate from outside." << endl;
  SurfXYPlane sxy2(dist1+30.,5.*PI/3.);
  tre.set_surface(SurfacePtr(sxy2.new_pure_surface()));
  tre.set_backward();
  cout << tre << endl;
  lxy1.propagate(tre,prop,ltracks);
  assert( ltracks.size() == 1 );
  // save a copy of the propagated track
  const LTrack trl2 = ltracks.front();
  const ETrack& tre2 = trl2.get_track();
  const LayerStat& lstat2 = trl2.get_status();
  cout << trl2 << endl;
  assert( lstat2.at_exit() );
  assert( lstat2.get_state() == 1 );
  ltracks.clear();
  lxy1.propagate(trl2,prop,ltracks);
  assert( ltracks.size() == 0 );
  ltracks.clear();

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

  cout << ok_prefix << "Propagate backward from outside." << endl;
  TrackVector vec2 = vec;
  ETrack tre30(SurfacePtr(sxy2.new_pure_surface()),vec2,err1);
  tre30.set_forward();
  cout << tre30 << endl;
  lxy1.propagate(tre30,prop,ltracks);
  assert( ltracks.size() == 1 );
  // save a copy of the propagated track
  const LTrack trl3 = ltracks.front();
  const ETrack& tre3 = trl3.get_track();
  const LayerStat& lstat3 = trl3.get_status();
  cout << trl3 << endl;
  assert( lstat3.at_exit() );
  assert( lstat3.get_state() == 1 );
  ltracks.clear();
  lxy1.propagate(trl3,prop,ltracks);
  assert( ltracks.size() == 0 );
  ltracks.clear();

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

  cout << ok_prefix << "Propagate from layer surface." << endl;
  tre.set_surface(SurfacePtr(sxy0.new_pure_surface()));
  tre.set_forward();
  cout << tre << endl;
  lxy1.propagate(tre,prop,ltracks);
  assert( ltracks.size() == 1 );
  // save a copy of the propagated track
  const LTrack trl4 = ltracks.front();
  const ETrack& tre4 = trl4.get_track();
  const LayerStat& lstat4 = trl4.get_status();
  cout << trl4 << endl;
  assert( lstat4.at_exit() );
  assert( lstat4.get_state() == 1 );
  ltracks.clear();

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

  cout << ok_prefix << "Propagate out of bounds." << endl;
  tre.set_surface(SurfacePtr(sxy1.new_pure_surface()));
  vec(1) = 300.0;
  tre.set_vector(vec);
  tre.set_forward();
  cout << tre << endl;
  lxy3.propagate(tre,prop,ltracks);
  assert( ltracks.size() == 1 );
  assert(ltracks.front().get_status().get_state() == 3 );
  ltracks.clear();
  lxy1.propagate(tre,prop,ltracks);
  assert( ltracks.size() == 1 );
  ltracks.clear();

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

   cout << ok_prefix << "Propagate in  bounds." << endl;
  vec(1)= 5.;
  ETrack tre5(SurfacePtr(sxy0.new_pure_surface()),vec,err1); 
  tre5.set_forward();
  cout << tre5 << endl;
  lxy3.propagate(tre5,prop,ltracks);
  assert( ltracks.size() == 1 );
  const LTrack trl5 = ltracks.front();
  assert(trl5.get_status().get_state()==1);
  ETrack tre6(SurfacePtr(sxy0.new_pure_surface()),vec,err); 
  tre6.set_forward();
  cout << tre6 << endl;
  ltracks.clear();
  lxy3.propagate(tre6,prop,ltracks);
  assert( ltracks.size() == 1 );
  const LTrack trl6 = ltracks.front();
  assert(trl6.get_status().get_state()==2);
  ltracks.clear();

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

  cout << ok_prefix << "Drop clusters." << endl;
  cout << "Before drop: " << lxy1.get_clusters().size() << endl;
  assert ( lxy1.get_clusters().size() == 3 );
  lxy1.drop_clusters();
  cout << "After drop: " << lxy1.get_clusters().size() << endl;
  assert ( lxy1.get_clusters().size() == 0 );

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

  ObjTable::register_type<LayerXYPlane>();

  cout << ok_prefix << "Write object data." << endl;
  Ptr<SurfXYPlane,LocalSharedDeletePolicy> 
    pxyp( new SurfXYPlane(12.3,0.1) );
  MutableClusterFindManagerPtr pfindt( new ClusterFindAll(pxyp) );
  {
    ObjPtr pobj( new LayerXYPlane(pxyp,pfindt) );
    ostringstream mystream;
    StdObjStream objstream(mystream);
    objstream.write_object("xyp",pxyp);
    objstream.write_object("findall",pfindt);
    objstream.write_object("obj1",pobj);
    cout << mystream.str() << endl;
    assert( ObjTable::has_object_name("obj1") );
    string::size_type pos = 0;
    assert( (pos=mystream.str().find( "obj1 ",pos)) != string::npos );
    assert( (pos=mystream.str().find( "LayerXYPlane ",pos)) != string::npos );
    assert( (pos=mystream.str().find( "surface",pos)) != string::npos );
    assert( (pos=mystream.str().find( "xyp ",pos)) != string::npos );
    assert( (pos=mystream.str().find( "finder",pos)) != string::npos );
    assert( (pos=mystream.str().find( "findall ",pos)) != string::npos );
  }

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

  cout << ok_prefix << "Read object data." << endl;
  {
    string istring = "[ obj2 LayerXYPlane surface=@xyp finder=@findall ]";
    istringstream isstrm(istring);
    {
      StdObjStream obstr(isstrm);
      string name = obstr.read_object();
      assert( name == "obj2" );
      const LayerXYPlane* pobj;
      ObjTable::get_object(name,pobj);
      assert( pobj != 0 );
      assert( pobj->get_type() == LayerXYPlane::get_static_type() );
      assert( pobj->get_surface() == pxyp );
      assert( pobj->get_finder() == pfindt );
    }
  }

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


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

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

}