#include "texception.h"
#include "stdfx.h"
#include "tpixelutils.h"

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

class BacklitFx : public TStandardRasterFx {
  FX_PLUGIN_DECLARATION(BacklitFx)

  TRasterFxPort m_input;
  // TDoubleParamP m_value;

public:
  BacklitFx()
  //    , m_value (args, "Blur")
  {
    // m_value->setDefaultValue(100);
    addInputPort("Source", m_input);
  }

  ~BacklitFx(){};

  bool doGetBBox(double frame, TRectD &bBox);
  void doCompute(TTile &tile, double frame, const TRenderSettings &ri);
  int getMemoryRequirement(const TRectD &rect, double frame,
                           const TRenderSettings &info);

  TRect getInvalidRect(const TRect &max);
};

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

bool BacklitFx::doGetBBox(double frame, TRectD &bBox) {
  if (m_input.isConnected()) {
    bool ret = m_input->doGetBBox(frame, bBox);
    // devo scurire bgColor
    return ret;
  } else {
    bBox = TRectD();
    return false;
  }
}

//===================================================================

namespace {

template <class T>
void computeBacklit(TRasterPT<T> dst, TRasterPT<T> src, const TPoint &srcPos,
                    // cordinate di src[0,0] rispetto a dst;
                    // in genere srcPos.x,.y <= 0
                    const TPoint &center
                    // coordinate della sorgente di luce rispetto a dst;
                    ) {
  // TRect srcRect = src->getBounds() + srcPos;
  // assert(srcRect.contains(dst->getBounds()));
  // assert(srcRect.contains(center));
  UINT max = T::maxChannelValue;
  dst->lock();
  for (int x = 0; x < dst->getLx(); x++)
    for (int y = 0; y < dst->getLy(); y++) {
      int dx   = x - center.x;
      int dy   = y - center.y;
      int dist = (int)sqrt((float)(dx * dx + dy * dy));

      int d        = tmin(100, dist) + 1;
      double value = 0.0;
      for (int i = 0; i <= d; i++) {
        int xx = center.x + (x - center.x) * i / d - srcPos.x;
        int yy = center.y + (y - center.y) * i / d - srcPos.y;
        assert(src->getBounds().contains(TPoint(xx, yy)));
        value += (max - src->pixels(yy)[xx].m) * 2;
      }
      value = value / dist;
      //    double value = sin(dist)<0?0:255;
      int v = tcrop((int)value, 0, (int)max);

      int srcX = -srcPos.x + x;
      int srcY = -srcPos.y + y;
      T srcPix(0, 0, 0, 0);
      if (src->getBounds().contains(TPoint(srcX, srcY)))
        srcPix = src->pixels(srcY)[srcX];
      srcPix.r = srcPix.r * (max - v) / max;
      srcPix.g = srcPix.g * (max - v) / max;
      srcPix.b = srcPix.b * (max - v) / max;

      dst->pixels(y)[x] = overPix(srcPix, T(v, v, v, v / 2));
    }
  dst->unlock();
}

}  // namespace

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

void BacklitFx::doCompute(TTile &tile, double frame,
                          const TRenderSettings &ri) {
  if (!m_input.isConnected()) {
    tile.getRaster()->clear();
    return;
  }
  TTile srcTile;
  srcTile.m_pos = tile.m_pos;
  TPoint srcPos(0, 0);
  TDimension srcSize = tile.getRaster()->getSize();

  TPoint center(-(int)tile.m_pos.x, -(int)tile.m_pos.y);
  center += TPoint(10, 10);
  if (center.x < 0) {
    srcSize.lx += -center.x;
    srcPos.x += center.x;
    srcTile.m_pos.x += center.x;
  } else if (center.x >= srcSize.lx) {
    srcSize.lx += center.x - srcSize.lx + 1;
  }

  if (center.y < 0) {
    srcSize.ly += -center.y;
    srcPos.y += center.y;
    srcTile.m_pos.y += center.y;
  } else if (center.y >= srcSize.ly) {
    srcSize.ly += center.y - srcSize.ly + 1;
  }

  if ((TRaster32P)tile.getRaster()) {
    TRaster32P src = TRaster32P(srcSize);
    src->clear();
    srcTile.getRaster() = src;

    m_input->compute(srcTile, frame, ri);

    TRaster32P dst = tile.getRaster();
    assert(dst);
    computeBacklit<TPixel32>(dst, src, srcPos, center);
  } else if ((TRaster64P)tile.getRaster()) {
    TRaster64P src = TRaster64P(srcSize);
    src->clear();
    srcTile.getRaster() = src;

    m_input->compute(srcTile, frame, ri);

    TRaster64P dst = tile.getRaster();
    assert(dst);
    computeBacklit<TPixel64>(dst, src, srcPos, center);
  }

  // dst->copy(src,srcPos);
}

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

int BacklitFx::getMemoryRequirement(const TRectD &rect, double frame,
                                    const TRenderSettings &info) {
  return TRasterFx::memorySize(rect, frame, info);
}

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

TRect BacklitFx::getInvalidRect(const TRect &max) {
  if (!m_input.isConnected()) return TRect();
  TRect rect = m_input->getInvalidRect(max);
  TRect ris  = max;

  if (rect.x0 >= 0)
    ris.x0 = tmin(rect.x0, max.x1);
  else if (rect.x1 <= 0)
    ris.x1 = tmax(rect.x1, max.x0);
  if (rect.y0 >= 0)
    ris.y0 = tmin(rect.y0, max.y1);
  else if (rect.y1 <= 0)
    ris.y1 = tmax(rect.y1, max.y0);

  return ris;
}

// FX_PLUGIN_IDENTIFIER(BacklitFx        , "backlitFx")