#pragma once

#ifndef PLASTICTOOL_H
#define PLASTICTOOL_H

// TnzCore includes
#include "tproperty.h"
#include "tmeshimage.h"

// TnzBase includes
#include "tparamchange.h"
#include "tdoubleparamrelayproperty.h"

// TnzExt includes
#include "ext/plasticskeleton.h"
#include "ext/plasticskeletondeformation.h"
#include "ext/plasticvisualsettings.h"

// TnzQt includes
#include "toonzqt/plasticvertexselection.h"

// TnzTools includes
#include "tools/tool.h"
#include "tools/cursors.h"
#include "tools/tooloptions.h"

// STD includes
#include <memory>

// tcg includes
#include "tcg/tcg_base.h"
#include "tcg/tcg_controlled_access.h"

// Qt includes
#include <QObject>

//****************************************************************************************
//    Metric defines
//****************************************************************************************

// Skeleton primitives

#define HIGHLIGHT_DISTANCE 8						 // Pixels distance to highlight
#define HANDLE_SIZE 4								 // Size of vertex handles
#define HIGHLIGHTED_HANDLE_SIZE HIGHLIGHT_DISTANCE   // Size of handle highlights
#define SELECTED_HANDLE_SIZE HIGHLIGHTED_HANDLE_SIZE // Size of handle selections

// Mesh primitives

#define MESH_HIGHLIGHT_DISTANCE 8
#define MESH_HIGHLIGHTED_HANDLE_SIZE 4
#define MESH_SELECTED_HANDLE_SIZE 2

//****************************************************************************************
//    PlasticTool  declaration
//****************************************************************************************

class PlasticTool : public QObject, public TTool, public TParamObserver, public TSelection::View
{
	Q_OBJECT

	friend class PlasticToolOptionsBox;

public:
	class TemporaryActivation
	{
		bool m_activate;

	public:
		TemporaryActivation(int row, int col);
		~TemporaryActivation();
	};

	struct MeshIndex : public tcg::safe_bool<MeshIndex> {
		int m_meshIdx, //!< Mesh index in a TMeshImage
			m_idx;	 //!< Index in the referenced mesh

		explicit MeshIndex(int meshIdx = -1, int idx = -1)
			: m_meshIdx(meshIdx), m_idx(idx) {}

		bool operator_bool() const { return (m_meshIdx >= 0) && (m_idx >= 0); }

		bool operator<(const MeshIndex &other) const
		{
			return (m_meshIdx == other.m_meshIdx) ? (m_idx < other.m_idx)
												  : (m_meshIdx < other.m_meshIdx);
		}
	};

	typedef MultipleSelection<MeshIndex> MeshSelection;

private:
	PlasticSkeletonDeformationP m_sd;					  //!< Current column's skeleton deformation
	int m_skelId;										  //!< Current m_sd's skeleton id
	tcg::invalidable<PlasticSkeleton> m_deformedSkeleton; //!< The interactively-deformed \a animation-mode skeleton

	TMeshImageP m_mi; //!< Current mesh image

	// Property-related vars  (ie, tool options)

	TPropertyGroup *m_propGroup; //!< Tool properties groups (needed for toolbar-building)

	TEnumProperty m_mode;		  //!< Editing mode (BUILD, ANIMATE, etc..)
	TStringProperty m_vertexName; //!< Vertex name property

	TBoolProperty m_interpolate; //!< Strict vertex interpolation property
	TBoolProperty m_snapToMesh;  //!< Snap to Mesh vertexes during skeleton build

	TDoubleProperty m_thickness; //!< Brush radius, from 1 to 100
	TEnumProperty m_rigidValue;  //!< Rigidity drawing value (ie draw rigidity/flexibility)
								 //!< put a keyframe at current frame

	TBoolProperty m_globalKey;	//!< Whether animating a vertex will cause EVERY vertex to
	TBoolProperty m_keepDistance; //!< Whether animation editing can alter vertex distances

	TStringProperty m_minAngle, m_maxAngle; //!< Minimum and maximum angle values allowed

	TPropertyGroup m_relayGroup; //!< Group for each vertex parameter relay

	TDoubleParamRelayProperty m_distanceRelay; //!< Relay property for vertex distance
	TDoubleParamRelayProperty m_angleRelay;	//!< Relay property for vertex angle
	TDoubleParamRelayProperty m_soRelay;	   //!< Relay property for vertex so

	TDoubleParamRelayProperty m_skelIdRelay; //!< Relay property for m_sd's skeleton id

	// Mouse-related vars

	TPointD m_pos;		  //!< Last known mouse position
	TPointD m_pressedPos; //!< Last mouse press position
	bool m_dragged;		  //!< Whether dragging occurred between a press/release

	std::vector<TPointD> m_pressedVxsPos; //!< Position of selected vertices at mouse press
	SkDKey m_pressedSkDF;				  //!< Skeleton deformation keyframes at mouse press

	// Selection/Highlighting-related vars

	int m_svHigh,					//!< Highlighted skeleton vertexes
		m_seHigh;					//!< Highlighted skeleton edges
	PlasticVertexSelection m_svSel; //!< Selected skeleton vertexes

	MeshIndex m_mvHigh,	//!< Highlighted mesh vertexes
		m_meHigh;		   //!< Highlighted mesh edges
	MeshSelection m_mvSel, //!< Selected mesh vertexes
		m_meSel;		   //!< Selected mesh edges

	// Drawing-related vars

	PlasticVisualSettings m_pvs; //!< Visual options for plastic painting

	// Editing-related vars

	std::auto_ptr<tcg::polymorphic> m_rigidityPainter; //!< Delegate class to deal with (undoable) rigidity painting
	bool m_showSkeletonOS;							   //!< Whether onion-skinned skeletons must be shown

	// Deformation-related vars

	bool m_recompileOnMouseRelease; //!< Whether skeleton recompilation should happen on mouse release

public:
	enum Modes { MESH_IDX = 0,
				 RIGIDITY_IDX,
				 BUILD_IDX,
				 ANIMATE_IDX,
				 MODES_COUNT };

public:
	PlasticTool();
	~PlasticTool();

	ToolType getToolType() const;
	int getCursorId() const { return ToolCursor::SplineEditorCursor; }

	ToolOptionsBox *createOptionsBox();

	TPropertyGroup *getProperties(int idx) { return &m_propGroup[idx]; }

	void updateTranslation();

	void onSetViewer();

	void onActivate();
	void onDeactivate();

	void onEnter();
	void onLeave();

	void addContextMenuItems(QMenu *menu);

	void reset();

	bool onPropertyChanged(std::string propertyName);

public:
	// Methods reimplemented in each interaction mode
	void mouseMove(const TPointD &pos, const TMouseEvent &me);
	void leftButtonDown(const TPointD &pos, const TMouseEvent &me);
	void leftButtonDrag(const TPointD &pos, const TMouseEvent &me);
	void leftButtonUp(const TPointD &pos, const TMouseEvent &me);

	void draw();

public:
	// Skeleton methods

	void setSkeletonSelection(const PlasticVertexSelection &vSel);
	void toggleSkeletonSelection(const PlasticVertexSelection &vSel);
	void clearSkeletonSelections();

	const PlasticVertexSelection &skeletonVertexSelection() const { return m_svSel; }
	PlasticVertexSelection branchSelection(int vIdx) const;

	void moveVertex_build(const std::vector<TPointD> &originalVxsPos, const TPointD &posShift);
	void addVertex(const PlasticSkeletonVertex &vx);
	void insertVertex(const PlasticSkeletonVertex &vx, int e);
	void insertVertex(const PlasticSkeletonVertex &vx, int parent, const std::vector<int> &children);
	void removeVertex();
	void setVertexName(QString &name);

	int addSkeleton(const PlasticSkeletonP &skeleton);
	void addSkeleton(int skelId, const PlasticSkeletonP &skeleton);
	void removeSkeleton(int skelId);

	PlasticSkeletonP skeleton() const;
	void touchSkeleton();

	PlasticSkeletonDeformationP deformation() const { return m_sd; }
	void touchDeformation();

	void storeDeformation(); //!< Stores deformation of current column (copying its reference)
	void storeSkeletonId();  //!< Stores current skeleton id associated to current deformation

	void onChange(); //!< Updates the tool after a deformation parameter change.
	//!< It can be used to refresh the tool in ANIMATION mode.
public:
	// Mesh methods

	const MeshSelection &meshVertexesSelection() const { return m_mvSel; }
	const MeshSelection &meshEdgesSelection() const { return m_meSel; }

	void setMeshVertexesSelection(const MeshSelection &vSel);
	void toggleMeshVertexesSelection(const MeshSelection &vSel);

	void setMeshEdgesSelection(const MeshSelection &eSel);
	void toggleMeshEdgesSelection(const MeshSelection &eSel);

	void clearMeshSelections();

	void storeMeshImage();

	void moveVertex_mesh(const std::vector<TPointD> &originalVxsPos, const TPointD &posShift);

public:
	// Actions with associated undo
	int addSkeleton_undo(const PlasticSkeletonP &skeleton);
	void addSkeleton_undo(int skelId, const PlasticSkeletonP &skeleton);

	void removeSkeleton_undo(int skelId);
	void removeSkeleton_withKeyframes_undo(int skelId);

	void editSkelId_undo(int skelId);

public slots:

	void swapEdge_mesh_undo();
	void collapseEdge_mesh_undo();
	void splitEdge_mesh_undo();
	void cutEdges_mesh_undo();

	void deleteSelectedVertex_undo();

	void setKey_undo();
	void setGlobalKey_undo();
	void setRestKey_undo();
	void setGlobalRestKey_undo();

	void copySkeleton();
	void pasteSkeleton_undo();
	void copyDeformation();
	void pasteDeformation_undo();

signals: // privates

	void skelIdsListChanged();
	void skelIdChanged();

protected:
	void mouseMove_mesh(const TPointD &pos, const TMouseEvent &me);
	void leftButtonDown_mesh(const TPointD &pos, const TMouseEvent &me);
	void leftButtonDrag_mesh(const TPointD &pos, const TMouseEvent &me);
	void leftButtonUp_mesh(const TPointD &pos, const TMouseEvent &me);
	void addContextMenuActions_mesh(QMenu *menu);

	void mouseMove_build(const TPointD &pos, const TMouseEvent &me);
	void leftButtonDown_build(const TPointD &pos, const TMouseEvent &me);
	void leftButtonDrag_build(const TPointD &pos, const TMouseEvent &me);
	void leftButtonUp_build(const TPointD &pos, const TMouseEvent &me);
	void addContextMenuActions_build(QMenu *menu);

	void mouseMove_rigidity(const TPointD &pos, const TMouseEvent &me);
	void leftButtonDown_rigidity(const TPointD &pos, const TMouseEvent &me);
	void leftButtonDrag_rigidity(const TPointD &pos, const TMouseEvent &me);
	void leftButtonUp_rigidity(const TPointD &pos, const TMouseEvent &me);
	void addContextMenuActions_rigidity(QMenu *menu);

	void mouseMove_animate(const TPointD &pos, const TMouseEvent &me);
	void leftButtonDown_animate(const TPointD &pos, const TMouseEvent &me);
	void leftButtonDrag_animate(const TPointD &pos, const TMouseEvent &me);
	void leftButtonUp_animate(const TPointD &pos, const TMouseEvent &me);
	void addContextMenuActions_animate(QMenu *menu);

	void draw_mesh();
	void draw_build();
	void draw_rigidity();
	void draw_animate();

private:
	// Skeleton methods

	PlasticSkeleton &deformedSkeleton();
	void updateDeformedSkeleton(PlasticSkeleton &deformedSkeleton);

	// Keyframe methods

	void keyFunc_undo(void (PlasticTool::*keyFunc)());

	void setKey();
	void setGlobalKey();
	void setRestKey();
	void setGlobalRestKey();

	// Rigidity methods
	static std::auto_ptr<tcg::polymorphic> createRigidityPainter();

	// Drawing methods

	void drawSkeleton(const PlasticSkeleton &skel, double pixelSize, UCHAR alpha = 255);
	void drawOnionSkinSkeletons_build(double pixelSize);
	void drawOnionSkinSkeletons_animate(double pixelSize);

	void drawHighlights(const SkDP &sd, const PlasticSkeleton *skel, double pixelSize);
	void drawSelections(const SkDP &sd, const PlasticSkeleton &skel, double pixelSize);

	void drawAngleLimits(const SkDP &sd, int skeId, int v, double pixelSize);

	// Selection methods

	void setMeshSelection(MeshSelection &target, const MeshSelection &newSel);
	void toggleMeshSelection(MeshSelection &target, const MeshSelection &addedSel);

	void onSelectionChanged();
	void enableCommands();

	// Parameter Observation methods

	void onChange(const TParamChange &);

private slots:

	void onFrameSwitched();
	void onColumnSwitched();
	void onXsheetChanged();

	void onShowMeshToggled(bool on);
	void onShowSOToggled(bool on);
	void onShowRigidityToggled(bool on);
	void onShowSkelOSToggled(bool on);
};

//****************************************************************************************
//    PlasticToolOptionsBox  declaration
//****************************************************************************************

class PlasticToolOptionsBox : public GenericToolOptionsBox, public TProperty::Listener
{
	Q_OBJECT

public:
	PlasticToolOptionsBox(QWidget *parent, TTool *tool, TPaletteHandle *pltHandle);

private:
	class SkelIdsComboBox;

private:
	TTool *m_tool;
	GenericToolOptionsBox **m_subToolbars;

	SkelIdsComboBox *m_skelIdComboBox;
	QPushButton *m_addSkelButton, *m_removeSkelButton;

private:
	void showEvent(QShowEvent *se);
	void hideEvent(QHideEvent *he);

	void onPropertyChanged();

private slots:

	void onSkelIdsListChanged();
	void onSkelIdChanged();
	void onSkelIdEdited();

	void onAddSkeleton();
	void onRemoveSkeleton();
};

//****************************************************************************************
//    PlasticTool  local functions
//****************************************************************************************

namespace PlasticToolLocals
{

extern PlasticTool l_plasticTool;		//!< Tool instance.
extern bool l_suspendParamsObservation; //!< Used to join multiple param change notifications.

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

// Generic functions

TPointD projection(const PlasticSkeleton &skeleton,
				   int e, const TPointD &pos); //!< Projects specified position an a skeleton edge.

// Global getters

double frame(); //!< Returns current global xsheet frame.
int row();		//!< Returns current global xsheet row.

int column();				 //!< Returns current global xsheet column index.
TXshColumn *xshColumn();	 //!< Returns current xsheet column object.
TStageObject *stageObject(); //!< Returns current stage object.

const TXshCell &xshCell();		//!< Returns current xsheet cell.
void setCell(int row, int col); //!< Moves current xsheet cell to the specified position.

int skeletonId(); //!< Returns current skeleton id.
double sdFrame(); //!< Returns current stage object's <I>parameters time</I>
				  //!  (ie the frame value to be used with function editor curves,
				  //!  which takes cyclicity into consideration).

// Keyframe functions

void setKeyframe(TDoubleParamP &param, double frame);				   //!< Sets a keyframe to the specified parameter curve.
void setKeyframe(SkVD *vd, double frame);							   //!< Sets a keyframe to the specified vertex deformation.
void setKeyframe(const PlasticSkeletonDeformationP &sd, double frame); //!< Sets a keyframe to an entire skeleton deformation.

void invalidateXsheet(); //!< Refreshes xsheet content.

// Draw functions

void drawSquare(const TPointD &pos, double radius);		//!< Draws the outline of a square
void drawFullSquare(const TPointD &pos, double radius); //!< Draws a filled square

// Mesh functions

std::pair<double, PlasticTool::MeshIndex> closestVertex(const TMeshImage &mi, const TPointD &pos);
std::pair<double, PlasticTool::MeshIndex> closestEdge(const TMeshImage &mi, const TPointD &pos);

} // namespace PlasticToolLocals

#endif // PLASTICTOOL_H