// 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/NotSymmetricBezierPotential.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></tcurves.h>

#include <tstrokeutil.h></tstrokeutil.h>

#include <tmathutil.h></tmathutil.h>

#include <algorithm></algorithm>

#include <iterator></iterator>

#include <vector></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

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