#include "texception.h"
#include "tfxparam.h"
#include "trop.h"
#include "stdfx.h"
#include "trasterfx.h"

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

class BlurFx final : public TStandardRasterFx {
  FX_PLUGIN_DECLARATION(BlurFx)

  TRasterFxPort m_input;
  TDoubleParamP m_value;
  TBoolParamP m_useSSE;

public:
  BlurFx() : m_value(20), m_useSSE(true) {
    m_value->setMeasureName("fxLength");
    bindParam(this, "value", m_value);
    bindParam(this, "useSSE", m_useSSE, true);

    addInputPort("Source", m_input);
    m_value->setValueRange(0, std::numeric_limits<double>::max());
  }

  ~BlurFx(){};

  bool doGetBBox(double frame, TRectD &bBox,
                 const TRenderSettings &info) override {
    if (m_input.isConnected()) {
      bool ret = m_input->doGetBBox(frame, bBox, info);

      double blur = fabs(m_value->getValue(frame));
      int brad    = tceil(blur);
      bBox        = bBox.enlarge(brad);

      return ret;
    } else {
      bBox = TRectD();
      return false;
    }
  }

  void enlarge(const TRectD &bbox, TRectD &requestedRect, int blur);

  void transform(double frame, int port, const TRectD &rectOnOutput,
                 const TRenderSettings &infoOnOutput, TRectD &rectOnInput,
                 TRenderSettings &infoOnInput) override;

  void doCompute(TTile &tile, double frame, const TRenderSettings &) override;

  int getMemoryRequirement(const TRectD &rect, double frame,
                           const TRenderSettings &info) override;

  bool canHandle(const TRenderSettings &info, double frame) override {
    if (m_value->getValue(frame) == 0) return true;
    return (isAlmostIsotropic(info.m_affine));
  }
};

FX_PLUGIN_IDENTIFIER(BlurFx, "blurFx")

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

//! Calculates the geometry we need for this node computation, given
//! the known input data (bbox), the requested output (requestedRect) and the
//! blur factor.
void BlurFx::enlarge(const TRectD &bbox, TRectD &requestedRect, int blur) {
  if (bbox.isEmpty() || requestedRect.isEmpty()) {
    requestedRect.empty();
    return;
  }

  // We are to find out the geometry that is useful for the fx computation.
  // There are some rules to follow:
  //  a) First, the interesting output we can generate is bounded by both
  //     the requestedRect and the blurred bbox (i.e. enlarged by the blur
  //     radius).
  //  b) Pixels contributing to any output are necessarily part of bbox - and
  //  only
  //     those which are blurrable into the requestedRect are useful to us
  //     (i.e. pixels contained in its enlargement by the blur radius).

  TRectD enlargedBBox(bbox.enlarge(blur));
  TRectD enlargedOut(requestedRect.enlarge(blur));

  TPointD originalP00(requestedRect.getP00());
  requestedRect = (enlargedOut * bbox) + (enlargedBBox * requestedRect);

  // Finally, make sure that the result is coherent with the original P00
  requestedRect -= originalP00;
  requestedRect.x0 = tfloor(requestedRect.x0);
  requestedRect.y0 = tfloor(requestedRect.y0);
  requestedRect.x1 = tceil(requestedRect.x1);
  requestedRect.y1 = tceil(requestedRect.y1);
  requestedRect += originalP00;
}

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

void BlurFx::transform(double frame, int port, const TRectD &rectOnOutput,
                       const TRenderSettings &infoOnOutput, TRectD &rectOnInput,
                       TRenderSettings &infoOnInput) {
  infoOnInput = infoOnOutput;
  rectOnInput = rectOnOutput;

  double blur =
      fabs(m_value->getValue(frame) * sqrt(fabs(infoOnOutput.m_affine.det())));

  if (blur == 0) {
    rectOnInput = rectOnOutput;
    return;
  }

  int brad = tceil(blur);
  TRectD bbox;
  m_input->getBBox(frame, bbox, infoOnInput);
  enlarge(bbox, rectOnInput, brad);
}

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

int BlurFx::getMemoryRequirement(const TRectD &rect, double frame,
                                 const TRenderSettings &info) {
  double blurValue =
      fabs(m_value->getValue(frame) * sqrt(fabs(info.m_affine.det())));

  if (blurValue == 0.0) return 0;

  int brad = tceil(blurValue);

  // Trop::blur is quite inefficient at the moment - it has to allocate a whole
  // raster of the same size of the input/output made of FLOAT QUADRUPLES...!
  return TRasterFx::memorySize(rect.enlarge(brad), sizeof(float) << 5);
}

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

void BlurFx::doCompute(TTile &tile, double frame,
                       const TRenderSettings &renderSettings) {
  if (!m_input.isConnected()) return;

  double shrink = 0.5 * (renderSettings.m_shrinkX + renderSettings.m_shrinkY);
  // Note: shrink is obsolete. It should be always = 1

  double blurValue = fabs(m_value->getValue(frame) *
                          sqrt(fabs(renderSettings.m_affine.det())) / shrink);

  if (blurValue == 0) {
    // No blur will be done. The underlying fx may pass by.
    m_input->compute(tile, frame, renderSettings);
    return;
  }

  int brad = tceil(blurValue);

  // Get the requested tile's geometry
  TRectD rectIn, rectOut;
  rectOut = TRectD(tile.m_pos, TDimensionD(tile.getRaster()->getLx(),
                                           tile.getRaster()->getLy()));

  // Retrieve the input interesting geometry - and ensure that something
  // actually has
  // to be computed
  if (!m_input->getBBox(frame, rectIn, renderSettings) || rectOut.isEmpty())
    return;

  enlarge(rectIn, rectOut, brad);

  if (rectOut.isEmpty()) return;

  // Finally, allocate and compute the blur argument
  TTile tileIn;
  m_input->allocateAndCompute(tileIn, rectOut.getP00(),
                              TDimension(rectOut.getLx(), rectOut.getLy()),
                              tile.getRaster(), frame, renderSettings);

  TPointD displacement(rectOut.getP00() - tile.m_pos);
  TRop::blur(tile.getRaster(), tileIn.getRaster(), blurValue, displacement.x,
             displacement.y, false);
}