#pragma once
 
#ifndef CONTROLPOINT_SELECTION_INCLUDED
#define CONTROLPOINT_SELECTION_INCLUDED
 
#include "toonzqt/selection.h"
#include "tools/tool.h"
#include "tstroke.h"
#include "tvectorimage.h"
#include "tcurves.h"
 
//=============================================================================
// ControlPointEditorStroke
//-----------------------------------------------------------------------------
 
class ControlPointEditorStroke
{
private:
	class ControlPoint
	{
	public:
		int m_pointIndex;
		TThickPoint m_speedIn;
		TThickPoint m_speedOut;
		bool m_isCusp;
 
		ControlPoint(int i, TThickPoint speedIn, TThickPoint speedOut, bool isCusp = true)
			: m_pointIndex(i), m_speedIn(speedIn), m_speedOut(speedOut), m_isCusp(isCusp)
		{
		}
		ControlPoint()
		{
		}
	};
 
	QList<ControlPoint> m_controlPoints;
	TVectorImageP m_vi;
	int m_strokeIndex;
 
	void adjustChunkParity();
 
	/*! Reset m_controlPoints. */
	void resetControlPoints();
 
	TThickPoint getPureDependentPoint(int index) const;
	void getDependentPoints(int index, std::vector<std::pair<int, TThickPoint>> &points) const;
	void updatePoints();
	void updateDependentPoint(int index);
 
	inline int nextIndex(int index) const;
	inline int prevIndex(int index) const;
 
	void moveSpeedIn(int index, const TPointD &delta, double minDistance);
	void moveSpeedOut(int index, const TPointD &delta, double minDistance);
 
	void moveSingleControlPoint(int index, const TPointD &delta);
 
public:
	enum PointType {
		CONTROL_POINT,
		SPEED_IN,
		SPEED_OUT,
		SEGMENT,
		NONE
	};
 
	ControlPointEditorStroke()
		: m_vi() {}
 
	~ControlPointEditorStroke()
	{
		m_controlPoints.clear();
	}
 
	ControlPointEditorStroke *clone() const;
 
	/*! Modify stroke: between two linear or cusp point must be a pair chunk number.
      PAY ATTENTION: Can add control point in the stroke. */
	void setStroke(const TVectorImageP &vi, int strokeIndex);
	TStroke *getStroke() const { return m_vi ? m_vi->getStroke(m_strokeIndex) : 0; }
 
	void setStrokeIndex(int strokeIndex) { m_strokeIndex = strokeIndex; }
	int getStrokeIndex() const { return m_strokeIndex; }
 
	int getControlPointCount() const { return m_controlPoints.size(); }
 
	TThickPoint getControlPoint(int index) const;
	/*! From index point in \b ControlPointEditorStroke to index point in \b TStroke. */
	int getIndexPointInStroke(int index) const;
	TThickPoint getSpeedInPoint(int index) const;
	TThickPoint getSpeedOutPoint(int index) const;
 
	//! Return true if index point is a cusp.
	bool isCusp(int index) const;
	//! Set \b m_isCusp of \b index point to \b isCusp.
	/*! If isCusp == false check \b setSpeedIn and modify speed. */
	void setCusp(int index, bool isCusp, bool setSpeedIn);
 
	bool isSpeedInLinear(int index) const;
	bool isSpeedOutLinear(int index) const;
	void setLinearSpeedIn(int index, bool linear = true, bool updatePoints = true);
	void setLinearSpeedOut(int index, bool linear = true, bool updatePoints = true);
 
	/*! If isLinear==true set to "0" the speedIn and speedOut value of index point; otherwise set to default value.
      Return true if speedIn or speedOut is modified.
      If updatePoints is true update dependent point after.*/
	bool setLinear(int index, bool isLinear, bool updatePoints = true);
	bool setControlPointsLinear(std::set<int> points, bool isLinear);
 
	/*! Move \b index ControlPoint of \b delta. */
	void moveControlPoint(int index, const TPointD &delta);
 
	/*! Add a ControlPoint in \b point. Return added ControlPoint index. */
	int addControlPoint(const TPointD &pos);
 
	void deleteControlPoint(int index);
 
	/*! Move speed in \b index of \b delta. */
	void moveSpeed(int index, const TPointD &delta, bool isIn, double minDistance);
 
	/*! Move segment between \b beforeIndex and \b nextIndex of \b delta. */
	void moveSegment(int beforeIndex, int nextIndex, const TPointD &delta, const TPointD &pos);
 
	/*!Return NONE if \b pos is far from stroke.*/
	PointType getPointTypeAt(const TPointD &pos, double &distance2, int &index) const;
 
	bool isSelfLoop() const
	{
		TStroke *stroke = getStroke();
		return stroke && stroke->isSelfLoop();
	}
};
 
//=============================================================================
// ControlPointSelection
//-----------------------------------------------------------------------------
 
class ControlPointSelection : public QObject, public TSelection
{
	Q_OBJECT
 
private:
	std::set<int> m_selectedPoints;
	int m_strokeIndex;
	ControlPointEditorStroke *m_controlPointEditorStroke;
 
public:
	ControlPointSelection() : m_controlPointEditorStroke(0), m_strokeIndex(-1)
	{
	}
 
	void setControlPointEditorStroke(ControlPointEditorStroke *controlPointEditorStroke)
	{
		m_controlPointEditorStroke = controlPointEditorStroke;
	}
 
	bool isEmpty() const { return m_selectedPoints.empty(); }
 
	void selectNone() { m_selectedPoints.clear(); }
	bool isSelected(int index) const;
	void select(int index);
	void unselect(int index);
 
	void deleteControlPoints();
 
	void addMenuItems(QMenu *menu);
 
	void enableCommands();
 
protected slots:
	void setLinear();
	void setUnlinear();
};
 
#endif //CONTROLPOINT_SELECTION_INCLUDED