#include <tools/track.h>

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

//    Static fields

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

TTrack::Id TTrack::m_lastId = 0;

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

//    TTrackIntrOrig implemantation

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

TTrackPoint

TTrackIntrOrig::interpolate(double index) {

  return track.original ? track.calcPointFromOriginal(track.originalIndexByIndex(index))

                        : track.interpolateLinear(index);

}

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

//    TTrack implemantation

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

TTrack::TTrack(

  TInputState::DeviceId deviceId,

  TInputState::TouchId touchId,

  const TInputState::KeyHistory::Holder &keyHistory,

  const TInputState::ButtonHistory::Holder &buttonHistory,

  bool hasPressure,

  bool hasTilt,

  double timeOffset

):

  id(++m_lastId),

  deviceId(deviceId),

  touchId(touchId),

  keyHistory(keyHistory),

  buttonHistory(buttonHistory),

  hasPressure(hasPressure),

  hasTilt(hasTilt),

  original(),

  timeOffset(timeOffset),

  rootTimeOffset(timeOffset),

  pointsRemoved(),

  pointsAdded(),

  fixedPointsAdded(),

  m_pointsFixed()

  { }

TTrack::TTrack(const TTrack &original, double timeOffset):

  id(++m_lastId),

  deviceId(original.deviceId),

  touchId(original.touchId),

  keyHistory(original.keyHistory),

  buttonHistory(original.buttonHistory),

  hasPressure(original.hasPressure),

  hasTilt(original.hasTilt),

  original(&original),

  timeOffset(timeOffset),

  rootTimeOffset(original.rootTimeOffset + timeOffset),

  pointsRemoved(),

  pointsAdded(),

  fixedPointsAdded(),

  m_pointsFixed()

  { }

const TTrack*

TTrack::root() const

  { return original ? original->root() : this; }

int

TTrack::level() const

  { return original ? original->level() + 1 : 0; }

int

TTrack::floorIndex(double index, double *outFrac) const {

  int i = floorIndexNoClamp(index);

  if (i > size() - 1) {

    if (outFrac) *outFrac = 0.0;

    return size() - 1;

  }

  if (i < 0) {

    if (outFrac) *outFrac = 0.0;

    return 0;

  }

  if (outFrac) *outFrac = std::max(0.0, index - (double)i);

  return i;

}

void

TTrack::push_back(const TTrackPoint &point, bool fixed) {

  assert(m_points.empty() || !m_points.back().final);

  m_points.push_back(point);

  TTrackPoint &p = m_points.back();

  if (m_points.size() <= 1) {

    p.length = 0;

  } else {

    const TTrackPoint &prev = *(m_points.rbegin() + 1);

    // fix originalIndex

    if (p.originalIndex < prev.originalIndex)

        p.originalIndex = prev.originalIndex;

    // fix time

    p.time = std::max(p.time, prev.time + TToolTimer::step);

    // calculate length

    p.length = prev.length + tdistance(p.position, prev.position);

  }

  ++pointsAdded;

  if (fixed) fix_all();

}

void

TTrack::pop_back(int count) {

  if (count > size()) count = size();

  if (count <= 0) return;

  assert(size() - count >= m_pointsFixed);

  m_points.resize(size() - count);

  if (pointsAdded > count)

    { pointsAdded -= count; return; }

  if (pointsAdded > 0)

    { count -= pointsAdded; pointsAdded = 0; }

  pointsRemoved += count;

}

void

TTrack::fix_points(int count) {

  count = std::min(count, previewSize());

  assert(count >= 0);

  if (count <= 0) return;

  m_pointsFixed += count;

  fixedPointsAdded += count;

}

TPointD

TTrack::calcTangent(double index, double distance) const {

  double minDistance = 10.0*TConsts::epsilon;

  if (distance < minDistance) distance = minDistance;

  TTrackPoint p = calcPoint(index);

  TTrackPoint pp = calcPoint(indexByLength(p.length - distance));

  TPointD dp = p.position - pp.position;

  double lenSqr = dp.x*dp.x + dp.y*dp.y;

  return lenSqr > TConsts::epsilon*TConsts::epsilon ? dp*(1.0/sqrt(lenSqr)) : TPointD();

}

double

TTrack::rootIndexByIndex(double index) const {

  return original

       ? original->rootIndexByIndex( originalIndexByIndex(index) )

       : index;

}

TTrackPoint

TTrack::calcRootPoint(double index) const {

  return original

       ? original->calcRootPoint( originalIndexByIndex(index) )

       : calcPoint(index);

}