#pragma once

#ifndef CONTROLPOINT_SELECTION_INCLUDED

#define CONTROLPOINT_SELECTION_INCLUDED

#include "toonzqt/selection.h"

#include "tool.h"

#include "tstroke.h"

#include "tcurves.h"

//=============================================================================

// ControlPointEditorStroke

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

/*!La classe ControlPointEditorStroke effettua tutte le operazioni matematiche sullo Stroke */

class ControlPointEditorStroke

{

private:

	//!Punti di controllo comprensivi di SpeedIn e SpeenOut

	class ControlPoint

	{

	public:

		int m_indexPoint;

		TPointD m_speedIn;

		TPointD m_speedOut;

		bool m_isCusp;

		ControlPoint(int i, TPointD speedIn, TPointD speedOut, bool isCusp = true)

			: m_indexPoint(i), m_speedIn(speedIn), m_speedOut(speedOut), m_isCusp(isCusp) {}

		ControlPoint()

		{

		}

	};

	vector<controlpoint> m_controlPoints;</controlpoint>

	TStroke *m_stroke;

	int m_strokeIndex;

	/*! Viene riempito il vettore \b m_controlPoints scegliendo da \b m_stroke soltanto 

	i punti di controllo nelle posizioni pari. 

	*/

	void updateControlPoints();

	//! Viene settato il valore \b p.m_isCusp osservando lo SpeedIn e SpeedOut del punto.

	void setCusp(ControlPoint &p);

	void setSpeedIn(ControlPoint &cp, const TPointD &p)

	{

		cp.m_speedIn = m_stroke->getControlPoint(cp.m_indexPoint) - p;

	}

	void setSpeedOut(ControlPoint &cp, const TPointD &p)

	{

		cp.m_speedOut = p - m_stroke->getControlPoint(cp.m_indexPoint);

	}

	/*! Inserisce un punto nel chunk di lunghezza maggiore selezionato tra quelli compresi

		tra il chunk \b indexA e \b indexB.

	*/

	void insertPoint(int indexA, int indexB);

	/*! Verifica che in \b m_stroke tra due cuspidi sia sempre presente un numero pari

	di Chunk: in caso contrario richiama la \b insertPoint;

	*/

	void adjustChunkParity();

	//! Sposta il punto di controllo \b index di un fattore delta

	void moveSingleControlPoint(int indexPoint, const TPointD &delta);

	/*! Sposta i punti di controllo precedenti al punto \b index di un fattore delta.

      Se \b moveSpeed==true e' usato per movimento degli speed, altrimenti per 

		  movimento dei punti di controllo.

	*/

	void movePrecControlPoints(int indexPoint, const TPointD &delta, bool moveSpeed);

	/*! Sposta i punti di controllo successivi al punto \b index di un fattore delta.

      Se \b moveSpeed==true e' usato per movimento degli speed, altrimenti per 

		  movimento dei punti di controllo.

	*/

	void moveNextControlPoints(int indexPoint, const TPointD &delta, bool moveSpeed);

public:

	ControlPointEditorStroke()

		: m_stroke(0), m_strokeIndex(-1) {}

	/*!Viene modificato lo stroke in modo tale che tra due cuspidi esista sempre un 

	numero pari di chunk.

	ATTENZIONE: poiche' puo' aggiungere punti di controllo allo stroke, e' bene richiamare 

	tale funzione solo quando e' necessario.

	*/

	void setStroke(TStroke *stroke, int strokeIndex);

	void setStrokeIndex(int strokeIndex) { m_strokeIndex = strokeIndex; }

	int getStrokeIndex() { return m_strokeIndex; }

	TThickPoint getControlPoint(int index) const

	{

		assert(m_stroke && 0 <= index && index < (int)m_controlPoints.size());

		return m_stroke->getControlPoint(m_controlPoints[index].m_indexPoint);

	}

	TThickPoint getSpeedIn(int index) const

	{

		assert(m_stroke && 0 <= index && index < (int)m_controlPoints.size());

		return m_controlPoints[index].m_speedIn;

	}

	TThickPoint getSpeedOut(int index) const

	{

		assert(m_stroke && 0 <= index && index < (int)m_controlPoints.size());

		return m_controlPoints[index].m_speedOut;

	}

	int getControlPointCount() const

	{

		return m_controlPoints.size();

	}

	//! Ritorna \b true se il punto index e' una cuspide.

	bool getIsCusp(int index) const

	{

		assert(m_stroke && 0 <= index && index < (int)getControlPointCount());

		return m_controlPoints[index].m_isCusp;

	}

	//!Viene settato il valore \b m_isCusp del punto index-esimo a \b isCusp.

	void linkUnlinkSpeeds(int index, bool isCusp)

	{

		m_controlPoints[index].m_isCusp = isCusp;

	}

	/*! Sposta il ControlPoint \b index di un fattore delta con continuita',

		  cioe' spostando anche i punti di controllo adiacenti se necessario.*/

	void moveControlPoint(int index, const TPointD &delta);

	//! Cancella il punto di controllo \b point.

	void deleteControlPoint(int index);

	/*! Aggiunge il punto di controllo \b point.

			Ritorna l'indice del punto di controllo appena inserito.*/

	int addControlPoint(const TPointD &pos);

	/*! Ritorna l'indice del cp piu' vicino al punto pos.

		  distance2 riceve il valore del quadrato della distanza

		  se la ControlPointEditorStroke e' vuota ritorna -1.*/

	int getClosestControlPoint(const TPointD &pos, double &distance2) const;

	//! Ritorna true sse e' definita una curva e se pos e' abbastanza vicino alla curva

	bool isCloseTo(const TPointD &pos, double pixelSize) const;

	/*! Ritorna l'indice del cp il cui bilancino e' piu' vicino al punto pos.

			\b minDistance2 riceve il valore del quadrato della distanza

		  se la ControlPointEditorStroke e' vuota ritorna -1. \b isIn e' true se il bilancino cliccato 

		  corrisponde allo SpeedIn.*/

	int getClosestSpeed(const TPointD &pos, double &minDistance2, bool &isIn) const;

	/*! Sposta il bilancino del punto \b index di un fattore delta. \b isIn deve essere

			true se si vuole spostare lo SpeedIn.*/

	void moveSpeed(int index, const TPointD &delta, bool isIn, double pixelSize);

	/*! Se isLinear e' true setta a "0" il valore dello speedIn e il valore dello speedOut;

			altrimenti li setta ad un valore di default. Ritorna vero se almeno un punto e' ststo modificato.*/

	bool setLinear(int index, bool isLinear);

	void setLinearSpeedIn(int index);

	void setLinearSpeedOut(int index);

	bool isSpeedInLinear(int index);

	bool isSpeedOutLinear(int index);

	bool isSelfLoop()

	{

		return m_stroke->isSelfLoop();

	}

};

//=============================================================================

// ControlPointSelection

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

class ControlPointSelection : public QObject, public TSelection

{

	Q_OBJECT

private:

	std::set<int> m_selectedPoints;</int>

	ControlPointEditorStroke *m_controlPointEditorStroke;

public:

	ControlPointSelection() : m_controlPointEditorStroke(0) {}

	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