// StrokeDeformation.cpp: implementation of the StrokeDeformation class.
//
//-----------------------------------------------------------------------------
#ifdef _DEBUG
#define _STLP_DEBUG 1
#endif

#include "ext/StrokeDeformation.h"
#include "ext/SquarePotential.h"
#include "ext/StrokeParametricDeformer.h"
#include "ext/NotSimmetricBezierPotential.h"
#include "ext/SmoothDeformation.h"
#include "ext/ContextStatus.h"
#include "ext/Designer.h"
//#include "ext/TriParam.h"

#include "ext/StraightCornerDeformation.h"
#include "ext/CornerDeformation.h"
#include "ext/SmoothDeformation.h"

#include "ext/StrokeDeformationImpl.h"
#include "DeformationSelector.h"

#include <tcurves.h>
#include <tstrokeutil.h>
#include <tmathutil.h>

#include <algorithm>
#include <iterator>
#include <vector>

#include "tthreadmessage.h"

using namespace ToonzExt;
using namespace std;

/**
 * @brief Manage a mutable context.
 */
static TThread::Mutex s_mutex;

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

StrokeDeformation::StrokeDeformation()
{
	state_ = CREATED;
	deformationImpl_ = SmoothDeformation::instance();
}

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

StrokeDeformation::~StrokeDeformation()
{
}

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

void StrokeDeformation::activate(const ContextStatus *status)
{
	QMutexLocker sl(&s_mutex);

	assert(status && "Status is null!!!");
	if (!status)
		return;

	if (state_ == RESETTED)
		delete this->deactivate();

	if (state_ == CREATED ||
		state_ == DEACTIVE) {
		deformationImpl_ = this->retrieveDeformator(status);
	} else {
		// if it is a not valid entry state_ recover
		assert(deformationImpl_ && "Can not find a valid deformator!!!");
		if (!deformationImpl_)
			return;
		deformationImpl_->reset();
		deformationImpl_ = DeformationSelector::instance()->getDeformation(status);
	}

	assert(deformationImpl_ && "Deformation is null!!!");
	if (!deformationImpl_)
		return;

	if (!deformationImpl_->activate_impl(status)) {
		deformationImpl_->reset();
		state_ = DEACTIVE;
		return;
	}

	state_ = ACTIVE;
}

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

void StrokeDeformation::update(const TPointD &delta)
{
	QMutexLocker sl(&s_mutex);

	assert(deformationImpl_ && "Deformation is null!!!");
	if (!deformationImpl_) {
		state_ = DEACTIVE;
		return;
	}

	if (state_ != ACTIVE &&
		state_ != UPDATING) {
		deformationImpl_->reset();
		state_ = ACTIVE;
		return;
	}

	deformationImpl_->update_impl(delta);
	state_ = UPDATING;
}

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

TStroke *
StrokeDeformation::deactivate()
{
	QMutexLocker sl(&s_mutex);

	if (!deformationImpl_) {
		state_ = DEACTIVE;
		return 0;
	}

	if (state_ != ACTIVE &&
		state_ != UPDATING) {
		state_ = DEACTIVE;
		deformationImpl_->reset();
		return 0;
	}

	state_ = DEACTIVE;
	TStroke *
		out = deformationImpl_->deactivate_impl();
	deformationImpl_ = 0;
	return out;
}

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

void StrokeDeformation::reset()
{
	QMutexLocker sl(&s_mutex);

	state_ = RESETTED;
}

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

void StrokeDeformation::draw(Designer *designer)
{
	QMutexLocker sl(&s_mutex);

	assert(designer && "Designer is null!!!");
	if (!deformationImpl_ ||
		!designer)
		return;

	// this is to draw the icon
	deformationImpl_->draw(designer);

	// this is to draw stroke when change something
	designer->draw(this);
}

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

void StrokeDeformation::check(const ContextStatus *status)
{
	QMutexLocker sl(&s_mutex);
	if (state_ != UPDATING)
		deformationImpl_ = this->retrieveDeformator(status);
}

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

const TStroke *
StrokeDeformation::getCopiedStroke() const
{
	QMutexLocker sl(&s_mutex);
	if (deformationImpl_)
		return deformationImpl_->getCopiedStroke();
	return 0;
}

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

const TStroke *
StrokeDeformation::getStroke() const
{
	QMutexLocker sl(&s_mutex);
	if (deformationImpl_)
		return deformationImpl_->getStrokeSelected();
	return 0;
}

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

const TStroke *
StrokeDeformation::getTransformedStroke() const
{
	QMutexLocker sl(&s_mutex);
	if (deformationImpl_)
		return deformationImpl_->getTransformedStroke();
	return 0;
}

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

void StrokeDeformation::recover()
{
	QMutexLocker sl(&s_mutex);
	assert(deformationImpl_ && "Deformation is null!!!");
	if (!deformationImpl_)
		return;

	deformationImpl_->reset();
	//  this->clearStatus();

	//deformationImpl_ = DeformationSelector::instance()->getDeformation(status);
	//assert(deformationImpl_ &&  "Deformation is null!!!" );
	//if( !deformationImpl_ )
	//  return;
	// deformationImpl_->activate_impl(status);
}

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

const ContextStatus *
StrokeDeformation::getStatus() const
{
	QMutexLocker sl(&s_mutex);
	if (deformationImpl_)
		return deformationImpl_->getImplStatus();
	return 0;
}

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

ToonzExt::Interval
StrokeDeformation::getExtremes() const
{
	QMutexLocker sl(&s_mutex);
	if (!deformationImpl_)
		return Interval(-1, -1);
	return deformationImpl_->getExtremes();
}

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

StrokeDeformationImpl *
StrokeDeformation::retrieveDeformator(const ContextStatus *status)
{
	QMutexLocker sl(&s_mutex);
	return DeformationSelector::instance()->getDeformation(status);
}

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

int StrokeDeformation::getCursorId() const
{
	QMutexLocker sl(&s_mutex);
	if (!deformationImpl_)
		return -1;
	return deformationImpl_->getCursorId();
}

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

#ifdef _DEBUG

const Potential *
StrokeDeformation::getPotential() const
{
	assert(deformationImpl_ && "Deformation is null!!!");
	if (!deformationImpl_)
		return 0;
	return deformationImpl_->getPotential();
}

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

const StrokeDeformationImpl *
StrokeDeformation::getDeformationImpl() const
{
	return deformationImpl_;
}
#endif

//-----------------------------------------------------------------------------
//  End Of File
//-----------------------------------------------------------------------------