#include "rasterstyles.h"
#include "trop.h"
#include "tvectorimage.h"
#include "traster.h"
#include "trastercm.h"
#include "tlevel_io.h"
#include "tenv.h"
//#include "tpixelutils.h"

//*************************************************************************************
//    TAirbrushRasterStyle  implementation
//*************************************************************************************

void TAirbrushRasterStyle::loadData(TInputStreamInterface &is) { is >> m_blur; }

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

void TAirbrushRasterStyle::saveData(TOutputStreamInterface &os) const {
  os << m_blur;
}

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

bool TAirbrushRasterStyle::compute(const Params &params) const {
  if (m_blur > 0.0) TRop::blur(params.m_r, params.m_r, m_blur, 0, 0, true);

  return true;
}

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

TColorStyle *TAirbrushRasterStyle::clone() const {
  TColorStyle *cs = new TAirbrushRasterStyle(*this);
  cs->assignNames(this);
  return cs;
}

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

void TAirbrushRasterStyle::makeIcon(const TDimension &d) {
  TFilePath dir = TEnv::getStuffDir() + "pixmaps";
  static TRasterP normalIc;
  if (normalIc == TRasterP())
    TImageReader::load(dir + "airbrush.bmp", normalIc);

  arrangeIcon(d, normalIc);
}

/*---------------------------------------------------------------------------*/

void TAirbrushRasterStyle::arrangeIcon(const TDimension &d,
                                       const TRasterP &normalIc) {
  if (normalIc == TRasterP()) {
    m_icon = TRaster32P(d);
    m_icon->fill(TPixel32::Red);
    return;
  }

  m_icon = TRasterP();

  if (d == TDimension(52, 52))
    m_icon = normalIc->clone();
  else {
    m_icon = TRaster32P(d);
    TRop::resample(m_icon, normalIc, TScale(d.lx / 52.0, d.ly / 52.0));
  }

  m_icon->lock();
  TPixel *buf  = (TPixel *)m_icon->getRawData();
  TPixel color = getMainColor();
  double rd    = (color.r - color.m) / 255.0;
  double gd    = (color.g - color.m) / 255.0;
  double bd    = (color.b - color.m) / 255.0;

  assert(m_icon->getWrap() == m_icon->getSize().lx);

  for (int i = 0; i < m_icon->getSize().lx * m_icon->getSize().ly; i++, buf++) {
    assert(buf->r == buf->g && buf->r == buf->b);

    if (buf->r < 255) {
      if (buf->r == 0)
        *buf = color;
      else {
        int val = 255 - buf->r;
        buf->r  = (UCHAR)(val * rd + 255);
        buf->g  = (UCHAR)(val * gd + 255);
        buf->b  = (UCHAR)(val * bd + 255);
      }
    }
  }
  m_icon->unlock();
}

//*************************************************************************************
//    TBlendRasterStyle  implementation
//*************************************************************************************

TColorStyle *TBlendRasterStyle::clone() const {
  return new TBlendRasterStyle(*this);
}

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

bool TBlendRasterStyle::compute(const Params &params) const {
  int i, j;
  TRasterGR8P r = (TRasterGR8P)params.m_r;
  assert(r);

  double factor = computeFactor(params);

  if (m_blur > 0.0) TRop::blur(params.m_r, params.m_r, m_blur, 0, 0, true);

  r->lock();
  for (i = 0; i < r->getLy(); i++) {
    TPixelGR8 *bufGr = r->pixels(i);
    for (j = 0; j < r->getLx(); j++, bufGr++)
      if (bufGr->value > 0) {
        double val   = bufGr->value * factor + 0.5;
        bufGr->value = (UCHAR)((val > 255) ? 255 : val);
      }
  }
  r->unlock();
  return true;
}

//-----------------------------------------------------------------------------
namespace {
bool inline doIsBorderPix(int index, TPixelCM32 *pix, TPixelGR8 *pixGr,
                          int paint) {
  return (pix->getPaint() != paint &&
          (pix->isPurePaint() || pixGr->value != 0));
}

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

bool inline isBorderPix(int index, TPixelCM32 *pix, int wrap, TPixelGR8 *pixGr,
                        int wrapGr, int color) {
  return doIsBorderPix(index, pix + 1, pixGr + 1, color) ||
         doIsBorderPix(index, pix - 1, pixGr - 1, color) ||
         doIsBorderPix(index, pix + wrap, pixGr + wrapGr, color) ||
         doIsBorderPix(index, pix - wrap, pixGr - wrapGr, color);
}
}

/*---------------------------------------------------------------------------*/

void TBlendRasterStyle::makeIcon(const TDimension &d) {
  TFilePath dir = TEnv::getStuffDir() + "pixmaps";
  static TRasterP normalIc;
  if (normalIc == TRasterP()) TImageReader::load(dir + "blend.bmp", normalIc);

  arrangeIcon(d, normalIc);
}
//-----------------------------------------------------------------------------

double TBlendRasterStyle::computeFactor(const Params &params) const {
  TRasterCM32P rCm = (TRasterCM32P)params.m_rOrig;
  TRasterGR8P rGr  = (TRasterGR8P)params.m_r;
  TPixelGR8 *bufGr;
  TPixelCM32 *bufCmap;
  int i, j;
  int wr         = params.m_rOrig->getWrap();
  int wrGr       = params.m_r->getWrap();
  int num_lines  = 0;
  double tot_sum = 0;

  // interactive!
  // if (Factor == 0)
  rGr->lock();
  rCm->lock();
  for (i = 1; i < params.m_r->getLy() - 1; i++) {
    int line_sum = 0, num_points = 0;
    bufGr   = rGr->pixels(i) + 1;
    bufCmap = rCm->pixels(i) + 1;
    for (j = 1; j < rGr->getLx() - 1; j++, bufGr++, bufCmap++) {
      if (bufGr->value > 0) {
        int paint = bufCmap->getPaint();
        if ((bufCmap->isPurePaint() || bufGr->value != 0) &&
            isBorderPix(params.m_colorIndex, bufCmap, wr, bufGr, wrGr, paint)) {
          line_sum += troundp(bufGr->value);
          num_points++;
        }
      }
    }
    rGr->unlock();
    rCm->unlock();
    if (num_points != 0) {
      tot_sum += ((float)line_sum / ((float)num_points * 255));
      num_lines++;
    }
  }
  if (num_lines == 0) return 0;

  return num_lines / tot_sum;
}

//*************************************************************************************
//    TNoColorRasterStyle  implementation
//*************************************************************************************

void TNoColorRasterStyle::makeIcon(const TDimension &d) {
  TFilePath dir = TEnv::getStuffDir() + "pixmaps";
  static TRasterP normalIc;
  if (normalIc == TRasterP()) TImageReader::load(dir + "markup.bmp", normalIc);

  if (normalIc == TRasterP()) {
    m_icon = TRaster32P(d);
    m_icon->fill(TPixel32::Red);
    return;
  }

  m_icon = TRasterP();
  if (d == TDimension(52, 52) && normalIc != TRasterP())
    m_icon = normalIc->clone();
  else {
    m_icon = TRaster32P(d);
    TRop::resample(m_icon, normalIc, TScale(d.lx / 52.0, d.ly / 52.0));
  }
}