// SurfZPlane.cpp

#include "SurfZPlane.h"
#include "trfutil/TRFMath.h"
#include "trfbase/CrossStat.h"
#include "trfbase/VTrack.h"
#include "spacegeom/SpacePath.h"
#include "trfutil/trfstream.h"
#include "objstream/ObjData.hpp"
#include "objstream/ObjTable.hpp"
#include <cassert>

#ifndef DEFECT_NO_STDLIB_NAMESPACES
using std::fabs;
#endif

using namespace trf;

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

namespace {

// Creator.

ObjPtr create(const ObjData& data) {
  assert( data.get_object_type() == "SurfZPlane" );
  double z = data.get_double("z");
  return ObjPtr( new SurfZPlane(z) );
}

}

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

// Output stream operator.

void SurfZPlane::ostr( ostream& stream ) const {
  stream << begin_object ;
  stream << "Z-plane at z = " << _z;
  stream << end_object;
}

void SurfZPlane::raw_ostr( ostream& stream ) const {
  stream << "Z-plane at z = " << _z;
}

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

// Equality.

bool SurfZPlane::safe_pure_equal( const Surface& srf ) const {
  return ( ((SurfZPlane *)&srf)->_z == _z );
}

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

// Comparison

bool SurfZPlane::safe_pure_less_than(const Surface& srf) const {
 double z_n = ((const SurfZPlane&)srf)._z ;
 return _z < z_n   ;
}

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

// Constructor.

SurfZPlane::SurfZPlane(double z)
{
 _z = z;
}
//**********************************************************************

// Destructor.

SurfZPlane::~SurfZPlane() { }

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

// Virtual constructor.

SurfZPlane* SurfZPlane::new_pure_surface( ) const {
  return new SurfZPlane(_z);
}

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

// Return the crossing status for a track vector without error.

CrossStat SurfZPlane::pure_status( const VTrack& trv ) const {

  // If the track surface is the same as this, return at
  const SurfacePtr& psrf = trv.get_surface();
  if ( psrf==this || pure_equal(*psrf) ) return CrossStat(CrossStat::AT);
  // Otherwise extract the space point and set flags using z.
  double ztrk = trv.space_point().z();
  double zsrf = _z;
  double prec = CrossStat::get_static_precision();
  if ( abs(ztrk-zsrf) < prec ) return CrossStat(CrossStat::ON);
  if ( ztrk > zsrf ) return CrossStat(CrossStat::OUTSIDE);
  return CrossStat(CrossStat::INSIDE);
}

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

// Return the surface parameter.
double SurfZPlane::get_parameter(int ipar) const {
  if ( ipar == ZPOS ) return _z;
  return 0.0;
}

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

// Return the difference between two track vectors.

TrackVector SurfZPlane::vec_diff( const TrackVector& vec1, 
                                     const TrackVector& vec2 ) const {
 TrackVector diff = vec1;
 diff -= vec2;
 return diff;
} 

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

// Return the space point for a track.

SpacePoint SurfZPlane::space_point( const TrackVector& vec ) const {
  return CartesianPoint( vec(IX) , vec(IY), _z );
}

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

// Return the space vector for a track. (x,y,dx/dz,dy/dz,q/p)
// dz/ds = 1/sqrt(1+dx/dz**2+dy/dz**2)
// dy/ds = dy/dz*dz/ds
// dx/ds = dx/dz*dz/ds

SpacePath SurfZPlane::space_vector(const TrackVector& vec,
                                   TrackSurfaceDirection dir) const {
  double x     = vec(IX);
  double y     = vec(IY);
  double z     = _z;
  double dx_dz = vec(IDXDZ);
  double dy_dz = vec(IDYDZ);

  double dz_ds = 1./sqrt(1.+dx_dz*dx_dz+dy_dz*dy_dz);
  if ( dir == TSD_BACKWARD ) dz_ds *= -1.0;
  else assert( dir == TSD_FORWARD );
  double dy_ds = dy_dz*dz_ds;
  double dx_ds = dx_dz*dz_ds;

  return CartesianPath(x, y, z, dx_ds, dy_ds, dz_ds);
}

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

// Return the creator.

ObjCreator SurfZPlane::get_creator() {
  return create;
}

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

// Write the object data.

ObjData SurfZPlane::write_data() const {
  ObjData data( get_type_name() );
  data.add_double( "z", get_z() );
  return data;
}

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