/*
 * Copyright (c) 2008, Willow Garage, Inc.
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Willow Garage, Inc. nor the names of its
 *       contributors may be used to endorse or promote products derived from
 *       this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/** \author Tully Foote */

#include "tf3/time_cache.h"
#include "tf3/exceptions.h"

#include <tf3/LinearMath/Vector3.h>
#include <tf3/LinearMath/Quaternion.h>
#include <tf3/LinearMath/Transform.h>
#include "tf3/compat.h"
#include <assert.h>

namespace tf3 {

TransformStorage::TransformStorage()
{
}

TransformStorage::TransformStorage(const tf3::TransformStampedMsg& data, CompactFrameID frame_id,
                                   CompactFrameID child_frame_id)
: stamp_(data.header.stamp)
, frame_id_(frame_id)
, child_frame_id_(child_frame_id)
{
  const tf3::QuaternionMsg& o = data.transform.rotation;
  rotation_ = tf3::Quaternion(o.x, o.y, o.z, o.w);
  const tf3::Vector3Msg& v = data.transform.translation;
  translation_ = tf3::Vector3(v.x, v.y, v.z);
}

TimeCache::TimeCache(tf3::Duration max_storage_time)
: max_storage_time_(max_storage_time)
{}

namespace cache { // Avoid ODR collisions https://github.com/ros/geometry2/issues/175 
// hoisting these into separate functions causes an ~8% speedup.  Removing calling them altogether adds another ~10%
void createExtrapolationException1(tf3::Time t0, tf3::Time t1, std::string* error_str)
{
  if (error_str)
  {
    char str[117]; // Text without formatting strings has 77, each timestamp has up to 20
    snprintf(str, sizeof(str), "Lookup would require extrapolation at time %.09f, but only time %.09f is in the buffer", t0.toSec(), t1.toSec());
    *error_str = str;
  }
}

void createExtrapolationException2(tf3::Time t0, tf3::Time t1, std::string* error_str)
{
  if (error_str)
  {
    // Want this to come out positive, because this is a future extrapolation problem with t0
    // t0 needs to come first because it will be bigger than t1
  tf3::Duration tdiff = t0 - t1;
    char str[163]; // Text without formatting strings has 102, each timestamp has up to 20
    snprintf(
        str, sizeof(str),
        "Lookup would require extrapolation %.09fs into the future.  Requested time %.09f but the latest data is at time %.09f",
        tdiff.toSec(), t0.toSec(), t1.toSec());
    *error_str = str;
  }
}

void createExtrapolationException3(tf3::Time t0, tf3::Time t1, std::string* error_str)
{
  if (error_str)
  {
  tf3::Duration tdiff = t1 - t0;
    char str[163]; // Text without formatting strings has 102, each timestamp has up to 20
    snprintf(
        str, sizeof(str),
        "Lookup would require extrapolation %.09fs into the past.  Requested time %.09f but the earliest data is at time %.09f",
        tdiff.toSec(), t0.toSec(), t1.toSec());
    *error_str = str;
  }
}
} // namespace cache

bool operator>(const TransformStorage& lhs, const TransformStorage& rhs)
{
  return lhs.stamp_ > rhs.stamp_;
}

uint8_t TimeCache::findClosest(TransformStorage*& one, TransformStorage*& two, tf3::Time target_time, std::string* error_err)
{
  //No values stored
  if (storage_.empty())
  {
    return 0;
  }

  //If time == 0 return the latest
  if (target_time.isZero())
  {
    one = &storage_.front();
    return 1;
  }

  // One value stored
  if (++storage_.begin() == storage_.end())
  {
    TransformStorage& ts = *storage_.begin();
    if (ts.stamp_ == target_time)
    {
      one = &ts;
      return 1;
    }
    else
    {
      cache::createExtrapolationException1(target_time, ts.stamp_, error_err);
      return 0;
    }
  }

  tf3::Time latest_time = (*storage_.begin()).stamp_;
  tf3::Time earliest_time = (*(storage_.rbegin())).stamp_;

  if (target_time == latest_time)
  {
    one = &(*storage_.begin());
    return 1;
  }
  else if (target_time == earliest_time)
  {
    one = &(*storage_.rbegin());
    return 1;
  }
  // Catch cases that would require extrapolation
  else if (target_time > latest_time)
  {
  cache::createExtrapolationException2(target_time, latest_time, error_err);
    return 0;
  }
  else if (target_time < earliest_time)
  {
  cache::createExtrapolationException3(target_time, earliest_time, error_err);
    return 0;
  }

  //At least 2 values stored
  //Find the first value less than the target value
  L_TransformStorage::iterator storage_it;
  TransformStorage storage_target_time;
  storage_target_time.stamp_ = target_time;

  storage_it = std::lower_bound(
      storage_.begin(),
      storage_.end(),
      storage_target_time, std::greater<TransformStorage>());

  //Finally the case were somewhere in the middle  Guarenteed no extrapolation :-)
  one = &*(storage_it); //Older
  two = &*(--storage_it); //Newer
  return 2;


}

void TimeCache::interpolate(const TransformStorage& one, const TransformStorage& two, tf3::Time time, TransformStorage& output)
{
  // Check for zero distance case
  if( two.stamp_ == one.stamp_ )
  {
    output = two;
    return;
  }
  //Calculate the ratio
  tf3Scalar ratio = (time - one.stamp_).toSec() / (two.stamp_ - one.stamp_).toSec();

  //Interpolate translation
  output.translation_.setInterpolate3(one.translation_, two.translation_, ratio);

  //Interpolate rotation
  output.rotation_ = slerp( one.rotation_, two.rotation_, ratio);

  output.stamp_ = time;
  output.frame_id_ = one.frame_id_;
  output.child_frame_id_ = one.child_frame_id_;
}

bool TimeCache::getData(tf3::Time time, TransformStorage & data_out, std::string* error_err) //returns false if data not available
{
  TransformStorage* p_temp_1;
  TransformStorage* p_temp_2;

  int num_nodes = findClosest(p_temp_1, p_temp_2, time, error_err);
  if (num_nodes == 0)
  {
    return false;
  }
  else if (num_nodes == 1)
  {
    data_out = *p_temp_1;
  }
  else if (num_nodes == 2)
  {
    if( p_temp_1->frame_id_ == p_temp_2->frame_id_)
    {
      interpolate(*p_temp_1, *p_temp_2, time, data_out);
    }
    else
    {
      data_out = *p_temp_1;
    }
  }
  else
  {
    assert(0);
  }

  return true;
}

CompactFrameID TimeCache::getParent(tf3::Time time, std::string* error_err)
{
  TransformStorage* p_temp_1;
  TransformStorage* p_temp_2;

  int num_nodes = findClosest(p_temp_1, p_temp_2, time, error_err);
  if (num_nodes == 0)
  {
    return 0;
  }

  return p_temp_1->frame_id_;
}

bool TimeCache::insertData(const TransformStorage& new_data, std::string* error_str)
{
  L_TransformStorage::iterator storage_it = storage_.begin();

  if(storage_it != storage_.end())
  {
    if (storage_it->stamp_ > new_data.stamp_ + max_storage_time_)
    {
      if (error_str)
      {
        *error_str = "TF_OLD_DATA ignoring data from the past (Possible reasons are listed at http://wiki.ros.org/tf/Errors%%20explained)";
      }
      return false;
    }
  }


  while(storage_it != storage_.end())
  {
    if (storage_it->stamp_ <= new_data.stamp_)
      break;
    storage_it++;
  }
  if (storage_it != storage_.end() && storage_it->stamp_ == new_data.stamp_)
  {
    if (error_str)
    {
      *error_str = "TF_REPEATED_DATA ignoring data with redundant timestamp";
    }
    return false;
  }
  else
  {
    storage_.insert(storage_it, new_data);
  }

  pruneList();
  return true;
}

void TimeCache::clearList()
{
  storage_.clear();
}

unsigned int TimeCache::getListLength()
{
  return storage_.size();
}

P_TimeAndFrameID TimeCache::getLatestTimeAndParent()
{
  if (storage_.empty())
  {
    return std::make_pair(tf3::Time(), 0);
  }

  const TransformStorage& ts = storage_.front();
  return std::make_pair(ts.stamp_, ts.frame_id_);
}

tf3::Time TimeCache::getLatestTimestamp() 
{   
  if (storage_.empty()) return tf3::Time(); //empty list case
  return storage_.front().stamp_;
}

tf3::Time TimeCache::getOldestTimestamp() 
{   
  if (storage_.empty()) return tf3::Time(); //empty list case
  return storage_.back().stamp_;
}

void TimeCache::pruneList()
{
  tf3::Time latest_time = storage_.begin()->stamp_;
  
  while(!storage_.empty() && storage_.back().stamp_ + max_storage_time_ < latest_time)
  {
    storage_.pop_back();
  }
  
} // namespace tf3
}