#pragma once

#ifndef TCG_POLYLINE_OPS
#define TCG_POLYLINE_OPS

// tcg includes
#include "traits.h"
#include "containers_reader.h"
#include "point.h"
#include "point_ops.h"

namespace tcg {
namespace polyline_ops {

//**************************************************************************************
//    Polyline Basic Operations
//**************************************************************************************

/*!
  Computes the length of the polyline between the specified point iterators.
  \return   The input polyline's length
*/

template <typename ForIt>
double length(ForIt begin, ForIt end) {
  typedef typename std::iterator_traits<ForIt>::value_type point_type;

  double result = 0.0;

  for (ForIt jt = begin, it = ++jt; jt != end; it = jt, ++jt)
    result += tcg::point_ops::dist(*it, *jt);

  return result;
}

//-----------------------------------------------------------------------------

/*!
  Computes the area enclosed by the input polyline's \a closure.

  \note    The input polyline is implicitly \a connected at the endpoints
           with a straight segment. This has obviously makes no difference
           if the supplied polyline already had coincident endpoints.

  \return  The area enclosed by the polyline's \a closure.
*/

template <typename ForIt>
double area(ForIt begin, ForIt end) {
  typedef typename std::iterator_traits<ForIt>::value_type point_type;

  double result = 0.0;

  if (begin != end) {
    ForIt jt = begin, it = jt++;

    for (; jt != end; it = jt++)
      result += 0.5 * (tcg::point_traits<point_type>::y(*jt) +
                       tcg::point_traits<point_type>::y(*it)) *
                (tcg::point_traits<point_type>::x(*jt) -
                 tcg::point_traits<point_type>::x(*it));

    result += 0.5 * (tcg::point_traits<point_type>::y(*begin) +
                     tcg::point_traits<point_type>::y(*it)) *
              (tcg::point_traits<point_type>::x(*begin) -
               tcg::point_traits<point_type>::x(*it));
  }

  return result;
}

//**************************************************************************************
//    Quadratic Conversions
//**************************************************************************************

/*!
  Standard direct conversion function used in polyline-to-quadratics conversion.

  Point a has already been inserted in the output; this function must add the
  remaining part of a sequence of quadratics approximating the triplet (a, *bt,
  c).
*/

// Note: typename iter_type::value_type == point_type
template <typename point_type, typename iter_type>
void tripletToQuadratics(
    const point_type &a, const iter_type &bt, const point_type &c,
    tcg::sequential_reader<std::vector<point_type>> &output) {
  // Direct conversion
  output.addElement(*bt);
  output.addElement(c);
}

/*!
  Performs a conversion of the specified polyline into a sequence of quadratics,
then
  applies a quadratics sub-sequence optimal merging algorithm.

  A user-made local triplet-to-quadratics conversion can be supplied to
recognize corners
  or supply a tight starting approximation.

\warning Passed polylines with equal endpoints are interpreted as closed
(circular) polylines;
         in this case, the resulting endpoints of the quadratic sequence will be
displaced to
         the first segment mid-point.
*/

template <typename iter_type, typename containers_reader, typename toQuadsFunc>
void toQuadratics(
    iter_type begin, iter_type end, containers_reader &output,
    toQuadsFunc &toQuads =
        &tripletToQuadratics<typename iter_type::value_type, iter_type>,
    double mergeTol = 1.0);

//**************************************************************************************
//    Standard Polyline Evaluators
//**************************************************************************************

/*!
  Calculates the (weighted) standard deviation of a polyline's sub-paths with
  respect
  to the segment connecting the endpoints.

  \warning For efficiency reasons, the returned value is the actual standard
  deviation, times the endpoints-segment length.
*/

template <typename RanIt>
class StandardDeviationEvaluator {
public:
  typedef RanIt iterator_type;
  typedef typename std::iterator_traits<RanIt>::difference_type diff_type;
  typedef typename std::iterator_traits<RanIt>::value_type point_type;
  typedef typename tcg::point_traits<point_type>::value_type value_type;
  typedef double penalty_type;

protected:
  iterator_type m_begin, m_end;

  std::vector<double> m_sums_x, m_sums_y;  //!< Sums of the points coordinates
  std::vector<double> m_sums2_x,
      m_sums2_y;                  //!< Sums of the points coordinates' squares
  std::vector<double> m_sums_xy;  //!< Sums of the coordinates products

public:
  StandardDeviationEvaluator(const iterator_type &begin,
                             const iterator_type &end);

  penalty_type penalty(const iterator_type &a, const iterator_type &b);

  const iterator_type &begin() const { return m_begin; }
  const iterator_type &end() const { return m_end; }

  const std::vector<double> &sums_x() const { return m_sums_x; }
  const std::vector<double> &sums_y() const { return m_sums_y; }
  const std::vector<double> &sums2_x() const { return m_sums2_x; }
  const std::vector<double> &sums2_y() const { return m_sums2_y; }
  const std::vector<double> &sums_xy() const { return m_sums_xy; }
};
}
}  // namespace tcg::polyline_ops

#ifdef INCLUDE_HPP
#include "hpp/polyline_ops.hpp"
#endif

#endif  // TCG_POLYLINE_OPS