#include "trop.h"

namespace {

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

template <typename PIXEL, typename CHANNEL_TYPE>
void computeBBox(TRasterPT<PIXEL> ras, TRect &bbox) {
  bbox   = ras->getBounds();
  int lx = ras->getLx();
  int ly = ras->getLy();

  // se c'e' un pixel opaco in alto a sin e in basso a destra allora bbox =
  // bounds
  if (ras->pixels(0)[0].m != 0 && ras->pixels(ly - 1)[lx - 1].m != 0) return;

  int y;
  ras->lock();
  for (y = 0; y < ly; y++) {
    CHANNEL_TYPE *pix    = &(ras->pixels(y)->m);
    CHANNEL_TYPE *endPix = pix + 4 * lx;
    while (pix < endPix && *pix == 0) pix += 4;
    if (pix < endPix) break;
  }
  if (y == ly) {
    // tutta trasparente
    bbox = TRect();
    ras->unlock();
    return;
  }
  bbox.y0 = y;
  for (y = ly - 1; y > bbox.y0; y--) {
    CHANNEL_TYPE *pix    = &(ras->pixels(y)->m);
    CHANNEL_TYPE *endPix = pix + 4 * lx;
    while (pix < endPix && *pix == 0) pix += 4;
    if (pix < endPix) break;
  }
  bbox.y1 = y;
  assert(bbox.y0 <= bbox.y1);
  bbox.x0 = lx;
  bbox.x1 = -1;
  for (y = bbox.y0; y <= bbox.y1; y++) {
    CHANNEL_TYPE *row = &(ras->pixels(y)->m);
    int x             = 0;
    for (x = 0; x < bbox.x0 && row[x * 4] == 0; x++) {
    }
    bbox.x0 = x;
    for (x = lx - 1; x > bbox.x1 && row[x * 4] == 0; x--) {
    }
    bbox.x1 = x;
  }
  assert(bbox.x0 <= bbox.x1);

  ras->unlock();
  /*

  UCHAR *row_m = &(ras->pixels()->m);
// se c'e' un pixel opaco in alto a sin e in basso a destra allora bbox = bounds
if(row_m[0] && row_m[(ly-1)*wrap4 + (lx-1)*4])
    return;

int y;
UCHAR *m, *max_m, *min_m;

for(y=0;y<ly;y++)
    {
max_m = row_m + lx * 4;
           for(m = row_m; m<max_m && *m==0; m+=4) {}
           if(m<max_m) break;
           row_m += wrap4;
          }
if(y>=ly)
    {
           // tutta trasparente
           return;
          }

  bbox.y0 = bbox.y1 = y;
bbox.x0 = (m - row_m)/4;
assert(0<=bbox.x0 && bbox.x0<lx);
assert(ras->pixels(bbox.y0)[bbox.x0].m>0);
assert(bbox.x0 == 0 || ras->pixels(bbox.y0)[bbox.x0-1].m==0);

min_m = m;
for(m = max_m - 4;m>min_m && *m==0;m-=4) {}
bbox.x1 = (m - row_m)/4;
assert(0<=bbox.x1 && bbox.x1<lx);
assert(ras->pixels(bbox.y0)[bbox.x1].m>0);
assert(bbox.x1 == lx-1 || ras->pixels(bbox.y0)[bbox.x1+1].m==0);

  row_m += wrap4;

for(y++;y<ly;y++)
    {
max_m = row_m + lx * 4;
           for(m = row_m; m<max_m && *m==0; m+=4) {}
           if(m<max_m)
             {
                    int x = (m - row_m)/4;
                          if(x<bbox.x0)
                            {
                                   bbox.x0 = x;
     assert(0<=bbox.x0 && bbox.x0<lx);
     assert(ras->pixels(y)[bbox.x0].m>0);
     assert(bbox.x0 == 0 || ras->pixels(y)[bbox.x0-1].m==0);
    }
  min_m = row_m + bbox.x1*4;
                    for(m = max_m - 4;m>min_m && *m==0;m-=4) {}
                          if(m>min_m)
                            {
                                   x = (m - row_m)/4;
                                   assert(x>bbox.x1);
                                   bbox.x1 = x;
                                  }
                          bbox.y1 = y;
                   }
           row_m += wrap4;
          }
*/
}

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

inline bool isTransparent(TPixelCM32 *pix) {
  return (!pix->isPureInk() &&
          //  (pix->getPaint()==BackgroundStyle
          (pix->getPaint() == 0 && pix->isPurePaint()));
}

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

void computeBBoxCM32(TRasterCM32P ras, TRect &bbox) {
  bbox   = ras->getBounds();
  int lx = ras->getLx();
  int ly = ras->getLy();

  // se c'e' un pixel opaco in alto a sin e in basso a destra allora bbox =
  // bounds
  if (!isTransparent(&(ras->pixels(0)[0])) &&
      !isTransparent(&(ras->pixels(ly - 1)[lx - 1])))
    return;

  int y;
  ras->lock();
  for (y = 0; y < ly; y++) {
    TPixelCM32 *pix    = ras->pixels(y);
    TPixelCM32 *endPix = pix + lx;
    while (pix < endPix && isTransparent(pix)) ++pix;
    if (pix < endPix) break;
  }
  if (y == ly) {
    // tutta trasparente
    bbox = TRect();
    ras->unlock();
    return;
  }
  bbox.y0 = y;
  for (y = ly - 1; y > bbox.y0; y--) {
    TPixelCM32 *pix    = ras->pixels(y);
    TPixelCM32 *endPix = pix + lx;
    while (pix < endPix && isTransparent(pix)) ++pix;
    if (pix < endPix) break;
  }
  bbox.y1 = y;
  assert(bbox.y0 <= bbox.y1);
  bbox.x0 = lx;
  bbox.x1 = -1;
  for (y = bbox.y0; y <= bbox.y1; y++) {
    TPixelCM32 *row = ras->pixels(y);
    int x           = 0;
    for (x = 0; x < bbox.x0 && isTransparent(&row[x]); x++) {
    }
    bbox.x0 = x;
    for (x = lx - 1; x > bbox.x1 && isTransparent(&row[x]); x--) {
    }
    bbox.x1 = x;
  }
  assert(bbox.x0 <= bbox.x1);
  ras->unlock();
}

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

}  // namespace

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

void TRop::computeBBox(TRasterP ras, TRect &bbox) {
  TRaster32P ras32 = ras;
  if (ras32) {
    ::computeBBox<TPixel32, UCHAR>(ras32, bbox);
    return;
  }

  TRaster64P ras64 = ras;
  if (ras64) {
    ::computeBBox<TPixel64, USHORT>(ras64, bbox);
    return;
  }

  TRasterCM32P rasCM32 = ras;
  if (rasCM32) {
    computeBBoxCM32(rasCM32, bbox);
    return;
  }

  TRasterGR8P ras8 = ras;
  if (ras8) {
    bbox = ras->getBounds();
    return;
  }
  assert(0);
}