#pragma once

#ifndef T_SEGMENTADJUSTER_H
#define T_SEGMENTADJUSTER_H

#include "tgeometry.h"
#include "tstroke.h"

#undef DVAPI
#undef DVVAR
#ifdef TVECTORIMAGE_EXPORTS
#define DVAPI DV_EXPORT_API
#define DVVAR DV_EXPORT_VAR
#else
#define DVAPI DV_IMPORT_API
#define DVVAR DV_IMPORT_VAR
#endif

#ifdef _WIN32
#pragma warning(disable : 4251)
#endif

/*!
  The TSegmentAdjuster minimizes the distance between

     stroke0->getPoint(w0) and stroke1->getPoint(w1)

  changing the values of w0 and w1 (in a defined range).

  Usage:

  TSegmentAdjuster::End p0(stroke0, w0, 0, 1);
  TSegmentAdjuster::End p1(stroke1, w1, 0, 1);
  TSegmentAdjuster adjuster;
  adjuster.compute(p0,p1);

  // the adjusted segment is p0.getPoint(), p1.getPoint()

  if you want to adjust the segment only in the w-growing-direction:

  TSegmentAdjuster::End p0(stroke0, w0, w0, 1);
  TSegmentAdjuster::End p1(stroke1, w1, w1, 1);
  TSegmentAdjuster adjuster;
  adjuster.compute(p0,p1);


 */

class DVAPI TSegmentAdjuster
{
public:
	class End
	{
	public:
		TStroke *m_stroke;
		double m_w;
		double m_wmin, m_wmax;
		End() : m_stroke(0), m_w(0), m_wmin(0), m_wmax(1) {}
		End(TStroke *stroke, double w) : m_stroke(stroke), m_w(w), m_wmin(0), m_wmax(1) {}
		End(TStroke *stroke, double w, double wmin, double wmax)
			: m_stroke(stroke), m_w(w), m_wmin(wmin), m_wmax(wmax) {}
		TPointD getPoint() const { return m_stroke->getPoint(m_w); }
		TPointD getSpeed() const { return m_stroke->getSpeed(m_w); }
	};

	TSegmentAdjuster();

	// debug
	void enableTrace(bool enabled) { m_traceEnabled = enabled; }
	void draw();
	void clear() { m_links.clear(); }

	void compute(End &a, End &b);

private:
	End m_a, m_b, m_c, m_d;
	std::vector<std::pair<TPointD, TPointD>> m_links;
	bool m_traceEnabled;

	inline double fun(double u, double v) const
	{
		return norm2(m_a.m_stroke->getPoint(u) - m_b.m_stroke->getPoint(v));
	}

	inline void gradient(double &dfdu, double &dfdv, double u, double v)
	{
		const double h = 0.0001;
		dfdu = (fun(u + h, v) - fun(u - h, v)) / (2 * h);
		dfdv = (fun(u, v + h) - fun(u, v - h)) / (2 * h);
	}

	inline static double dsda(TStroke *stroke, double w, double dwda)
	{
		const double h = 0.0001;
		return norm(stroke->getPoint(w + dwda * h) - stroke->getPoint(w - dwda * h)) / (2 * h);
	}
};
//---------------------------------------------------------------------------------------

#endif // T_SEGMENTADJUSTER_H