// 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
//-----------------------------------------------------------------------------