// VTrack.cpp

#include "VTrack.h"
#include "spacegeom/SpacePath.h"
#include "trfutil/trfstream.h"
#include "Surface.h"
#include "VTrackData.h"

using trf::TrackVector;
using trf::Surface;
using trf::SurfacePtr;
using trf::VTrackData;
using trf::VTrack;

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

// default constructor

VTrack::VTrack()
: RefCounter(), _psrf(0), _dir(TSD_UNDEFINED), _pdata(0) { }

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

// constructor from surface alone or nothing

VTrack::VTrack(const SurfacePtr& psrf) 
: RefCounter(), _psrf(psrf), _dir(TSD_UNDEFINED), _pdata(0) { }

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

// constructor from surface and vector

VTrack::VTrack(const SurfacePtr& psrf, const TrackVector& vec)
: RefCounter(),
  _psrf(psrf), _vec(vec), _dir(TSD_UNDEFINED), _pdata(0) { }

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

// constructor from surface, vector and direction

VTrack::VTrack(const SurfacePtr& psrf, const TrackVector& vec,
               TrackSurfaceDirection dir)
: RefCounter(), _psrf(psrf), _vec(vec), _dir(dir), _pdata(0) { }

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

// copy constructor

VTrack::VTrack(const VTrack& trv)
: RefCounter(), _psrf(trv._psrf), _vec(trv._vec), _dir(trv._dir), _pdata(0) {
  if ( trv.has_data() ) {
    _pdata = trv.get_data()->clone();
  }
}

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

// assignment operator

VTrack& VTrack::operator=(const VTrack& trv) {
  if ( &trv == this ) return *this;
  set_surface( trv.get_surface() );
  _vec = trv._vec;
  _dir = trv._dir;
  drop_data();
  if ( trv.has_data() ) {
    _pdata = trv.get_data()->clone();
  } else {
    _pdata = 0;
  }
  return *this;
}

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

// destructor

VTrack::~VTrack( ) { 
  delete _pdata;
}

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

// Is track valid?

bool VTrack::is_valid() const {
  // check surface is defined
  if ( ! _psrf ) return false;
  // check direction is defined
  if ( _psrf->get_direction(_vec) == TSD_UNDEFINED  &&
       _dir ==  TSD_UNDEFINED ) return false;
  return true;
}

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

// set surface from clone
// undefined local direction

void VTrack::set_surface_from_clone(const Surface& srf) { 
  _psrf = srf.new_pure_surface();
}

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

// set surface
// undefine local direction

void VTrack::set_surface(const SurfacePtr& psrf) { 
  _psrf = psrf;
  _dir = TSD_UNDEFINED;
}

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

// set vector
// undefine local direction

void VTrack::set_vector(const TrackVector& vec) {
  _vec = vec;
  _dir = TSD_UNDEFINED;
}

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

// set vector and keep direction

void VTrack::set_vector_and_keep_direction(const TrackVector& vec) {
  _vec = vec;
}

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

// is track direction same as surface?
// surface direction takes priority over local value

bool VTrack::is_forward() const {
  switch ( _psrf->get_direction(_vec) ) {
  case TSD_FORWARD:
    return true;
  case TSD_BACKWARD:
    return false;
  case TSD_UNDEFINED:
    return _dir == TSD_FORWARD;
  default:
    assert(false);
    return false;
  }
}


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

// is track direction ooposite that of surface?
// surface direction takes priority over local value

bool VTrack::is_backward() const {
  switch ( _psrf->get_direction(_vec) ) {
  case TSD_FORWARD:
    return false;
  case TSD_BACKWARD:
    return true;
  case TSD_UNDEFINED:
    return _dir == TSD_BACKWARD;
  default:
    assert(false);
    return false;
  }
}


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

// Get current spacepoint (using surface).

SpacePoint VTrack::space_point() const {
  return get_surface()->space_point(get_vector());
}

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

// Get current space vector (using surface).

SpacePath VTrack::space_vector() const {
  return get_surface()->space_vector(get_vector(),_dir);
}

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

// Return q/p in 1/GeV/c.

double VTrack::qoverp() const {
  return get_surface()->qoverp(get_vector());
}

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

// Does the track have extra data?

bool VTrack::has_data() const {
  return _pdata;
}

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

// Return the extra data.

VTrackData* VTrack::get_data() {
  return _pdata;
}

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

// Return the extra data.

const VTrackData* VTrack::get_data() const {
  return _pdata;
}

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

// Drop extra data.

void VTrack::drop_data() {
  delete _pdata;
  _pdata = 0;
}

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

// Add extra data.

void VTrack::set_data(VTrackData* pdata) {
  delete _pdata;
  _pdata = pdata;
}

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

// output
void VTrack::ostr(ostream& stream, bool call_from_subclass) const {
  if ( ! call_from_subclass ) stream << begin_object;
  if ( ! is_valid() ) {
    stream << "Invalid track.";
    if ( ! call_from_subclass ) stream << end_object;
    return;
  }
  if ( ! call_from_subclass ) stream << "VTrack ";
  stream << "at " << *get_surface() <<  " moving ";
  if ( is_forward() ) {
    stream << "forward";
  } else {
    if ( is_backward() ) {
      stream << "backward";
    } else {
      stream << "in undefined direction";
    }
  }
  stream << new_line;
  stream << _vec;
  if ( ! call_from_subclass ) stream << end_object;
}

//**********************************************************************
// friends
//**********************************************************************

// output stream
ostream& operator<<(ostream& stream, const VTrack& trv) {
  trv.ostr( stream );
  return stream;
}

//**********************************************************************
// Other functions.
//**********************************************************************

// equality
bool operator==(const VTrack& trv1, const VTrack& trv2) {
  if ( *trv1.get_surface() != *trv2.get_surface() ) return false;
  if ( trv1.get_vector() != trv2.get_vector() ) return false;
  if ( trv1.is_forward() && trv2.is_forward() ) return true;
  if ( trv1.is_backward() && trv2.is_backward() ) return true;
  return false;
}

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

// inequality
bool operator!=(const VTrack& trv1, const VTrack& trv2) {
  return ! ( trv1 == trv2 );
}

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