// TnzCore includes
#include "tundo.h"
#include "tgl.h"
 
// TnzExt includes
#include "ext/plasticdeformerstorage.h"
 
// TnzLib includes
#include "toonz/txshcell.h"
#include "toonz/txshsimplelevel.h"
#include "toonz/tframehandle.h"
 
// tcg includes
#include "tcg/tcg_point_ops.h"
 
// boost includes
#include <boost/noncopyable.hpp>
 
#include "plastictool.h"
 
using namespace PlasticToolLocals;
 
//****************************************************************************************
//    Local namespace  stuff
//****************************************************************************************
 
namespace
{
 
enum { RIGID_IDX = 0,
	   FLEX_IDX };
 
} // namespace
 
//****************************************************************************************
//    Undo  definitions
//****************************************************************************************
 
namespace
{
 
class PaintRigidityUndo : public TUndo
{
	TXshCell m_cell;							   //!< Affected image (cell == level + frame)
	std::vector<std::map<int, double>> m_vertices; //!< Affected vertices
 
	double m_paintValue; //!< Rigidity value the vertices were
						 //!< painted with
public:
	PaintRigidityUndo(const TXshCell &cell,
					  const std::vector<std::map<int, double>> &vertices,
					  double paintValue)
		: m_cell(cell), m_vertices(vertices), m_paintValue(paintValue) {}
 
	int getSize() const { return 1 << 20; }
 
	void redo() const
	{
		TXshSimpleLevel *sl = static_cast<TXshSimpleLevel *>(m_cell.m_level.getPointer());
		sl->setDirtyFlag(true);
 
		TMeshImageP mi(sl->getFrame(m_cell.m_frameId, true));
		if (!mi || mi->meshes().size() != m_vertices.size())
			return;
 
		int m, mCount = int(mi->meshes().size());
		for (m = 0; m != mCount; ++m) {
			TTextureMesh &mesh = *mi->meshes()[m];
 
			std::map<int, double>::const_iterator vt, vEnd(m_vertices[m].end());
			for (vt = m_vertices[m].begin(); vt != vEnd; ++vt)
				mesh.vertex(vt->first).P().rigidity = m_paintValue;
		}
 
		PlasticDeformerStorage::instance()->invalidateMeshImage(
			mi.getPointer(), PlasticDeformerStorage::MESH);
	}
 
	void undo() const
	{
		TXshSimpleLevel *sl = static_cast<TXshSimpleLevel *>(m_cell.m_level.getPointer());
		sl->setDirtyFlag(true);
 
		TMeshImageP mi(sl->getFrame(m_cell.m_frameId, true));
		if (!mi || mi->meshes().size() != m_vertices.size())
			return;
 
		int m, mCount = int(mi->meshes().size());
		for (m = 0; m != mCount; ++m) {
			TTextureMesh &mesh = *mi->meshes()[m];
 
			std::map<int, double>::const_iterator vt, vEnd(m_vertices[m].end());
			for (vt = m_vertices[m].begin(); vt != vEnd; ++vt)
				mesh.vertex(vt->first).P().rigidity = vt->second;
		}
 
		PlasticDeformerStorage::instance()->invalidateMeshImage(
			mi.getPointer(), PlasticDeformerStorage::MESH);
	}
};
 
} // namespace
 
//****************************************************************************************
//    RigidityPainter  definition
//****************************************************************************************
 
namespace
{
 
class RigidityPainter : public tcg::polymorphic
{
	std::vector<std::map<int, double>> m_oldRigidities; //!< The original values of painted vertices
	double m_sqRadius, m_value;							//!< Drawing parameters
 
public:
	RigidityPainter() : m_sqRadius(), m_value() {}
 
	void startPainting(double radius, int rigidIdx);
	void paint(const TPointD &pos);
	void commit();
 
private:
	void reset()
	{
		m_sqRadius = 0.0, m_value = 0.0;
		std::vector<std::map<int, double>>().swap(m_oldRigidities);
	}
};
 
//------------------------------------------------------------------------
 
void RigidityPainter::startPainting(double radius, int rigidIdx)
{
	m_sqRadius = sq(radius);
	m_value = (rigidIdx == RIGID_IDX) ? 1e4 : 1.0;
 
	assert(m_oldRigidities.empty());
}
 
//------------------------------------------------------------------------
 
void RigidityPainter::paint(const TPointD &pos)
{
	const TXshCell &cell = ::xshCell();
 
	TXshSimpleLevel *sl = dynamic_cast<TXshSimpleLevel *>(cell.m_level.getPointer());
	if (!sl)
		return;
 
	TMeshImageP meshImg = TTool::getImage(true);
	if (!meshImg)
		return;
 
	// Soil the level - schedules it for save
	sl->setDirtyFlag(true);
 
	// Paint all mesh vertices inside the circle with center pos and given radius
	const std::vector<TTextureMeshP> &meshes = meshImg->meshes();
	int m, mCount = int(meshImg->meshes().size());
 
	m_oldRigidities.resize(mCount);
 
	for (m = 0; m != mCount; ++m) {
		TTextureMesh &mesh = *meshes[m];
 
		int v, vCount = mesh.verticesCount();
		for (v = 0; v != vCount; ++v) {
			RigidPoint &vxPos = mesh.vertex(v).P();
 
			if (tcg::point_ops::dist2(pos, (const TPointD &)vxPos) < m_sqRadius) {
				if (!m_oldRigidities[m].count(v))
					m_oldRigidities[m][v] = vxPos.rigidity;
 
				vxPos.rigidity = m_value;
			}
		}
	}
 
	PlasticDeformerStorage::instance()->invalidateMeshImage(
		meshImg.getPointer(), PlasticDeformerStorage::MESH);
}
 
//------------------------------------------------------------------------
 
void RigidityPainter::commit()
{
	TUndoManager::manager()->add(new PaintRigidityUndo(::xshCell(), m_oldRigidities, m_value));
	reset();
}
 
} // namespace
 
//****************************************************************************************
//    PlasticTool  functions
//****************************************************************************************
 
std::auto_ptr<tcg::polymorphic> PlasticTool::createRigidityPainter()
{
	return std::auto_ptr<tcg::polymorphic>(new RigidityPainter);
}
 
//------------------------------------------------------------------------
 
void PlasticTool::mouseMove_rigidity(const TPointD &pos, const TMouseEvent &e)
{
	// Track mouse position
	m_pos = pos; // Needs to be done now - ensures m_pos is valid
 
	invalidate();
}
 
//------------------------------------------------------------------------
 
void PlasticTool::leftButtonDown_rigidity(const TPointD &pos, const TMouseEvent &)
{
	// Track mouse position
	m_pressedPos = m_pos = pos;
 
	RigidityPainter *painter = static_cast<RigidityPainter *>(m_rigidityPainter.get());
 
	painter->startPainting(m_thickness.getValue(), m_rigidValue.getIndex());
	painter->paint(m_pos);
 
	invalidate();
}
 
//------------------------------------------------------------------------
 
void PlasticTool::leftButtonDrag_rigidity(const TPointD &pos, const TMouseEvent &)
{
	// Track mouse position
	m_pos = pos;
 
	RigidityPainter *painter = static_cast<RigidityPainter *>(m_rigidityPainter.get());
 
	painter->paint(m_pos);
	invalidate();
}
 
//------------------------------------------------------------------------
 
void PlasticTool::leftButtonUp_rigidity(const TPointD &pos, const TMouseEvent &)
{
	// Track mouse position
	m_pos = pos;
 
	RigidityPainter *painter = static_cast<RigidityPainter *>(m_rigidityPainter.get());
 
	painter->commit();
}
 
//------------------------------------------------------------------------
 
void PlasticTool::addContextMenuActions_rigidity(QMenu *menu)
{
}
 
//------------------------------------------------------------------------
 
void PlasticTool::draw_rigidity()
{
	if (TTool::getApplication()->getCurrentFrame()->isEditingScene()) {
		// In the rigidity case, we're editing the mesh level - so the implicit
		// transformation affine loaded by OpenGL gets multiplied by the level's
		// dpi scale. We have to revert the scale before showing column-related data.
 
		const TPointD &dpiScale = TTool::getViewer()->getDpiScale();
		glPushMatrix();
		{
			tglMultMatrix(TScale(1.0 / dpiScale.x, 1.0 / dpiScale.y));
 
			double pixelSize = sqrt(tglGetPixelSize2());
 
			// Draw original skeleton
			const PlasticSkeletonP &skeleton = this->skeleton();
			if (skeleton) {
				drawOnionSkinSkeletons_build(pixelSize);
				drawSkeleton(*skeleton, pixelSize);
				drawSelections(m_sd, *skeleton, pixelSize);
			}
		}
		glPopMatrix();
	}
 
	// Draw a circle centered at m_pos with m_thickness radius
	glColor3f(1.0f, 0.0f, 0.0f); // Red
	tglDrawCircle(m_pos, m_thickness.getValue());
}