#include <X11/Xlib.h>
#include "common.h"
#include "scale.h"
#include "image.h"
#include "context.h"
#include "rgba.h"
#include "blend.h"
#include "rgbadraw.h"

void
__imlib_FlipImageHoriz(ImlibImage *im)
{
   DATA32 *p1, *p2, tmp;
   int x, y;
   
   for (y = 0; y < im->h; y++)
     {
	p1 = im->data + (y * im->w);
	p2 = im->data + ((y  + 1) * im->w) - 1;
	for (x = 0; x < (im->w >> 1); x++)
	  {
	     tmp = *p1;
	     *p1 = *p2;
	     *p2 = tmp;
	     p1++;
	     p2--;
	  }
     }
}

void
__imlib_FlipImageVert(ImlibImage *im)
{
   DATA32 *p1, *p2, tmp;
   int x, y;
   
   for (y = 0; y < (im->h >> 1); y++)
     {
	p1 = im->data + (y * im->w);
	p2 = im->data + ((im->h - 1 - y) * im->w);
	for (x = 0; x < im->w; x++)
	  {
	     tmp = *p1;
	     *p1 = *p2;
	     *p2 = tmp;
	     p1++;
	     p2++;
	  }
     }
}

void
__imlib_FlipImageDiagonal(ImlibImage *im)
{
   DATA32 *p1, *p2, *data;
   int x, y, tmp;

   data = malloc(im->w * im->h * sizeof(DATA32));
   p1 = im->data;
   for (y = im->h - 1; y >= 0; y--)
     {
	p2 = data + y;
	for (x = 0; x < im->w; x++)
	  {
	     *p2 = *p1;
	     p2 += im->h;
	     p1++;
	  }
     }
   free(im->data);
   im->data = data;
   tmp = im->w;
   im->w = im->h;
   im->h = tmp;
   tmp = im->border.top;
   im->border.top = im->border.left;
   im->border.left = tmp;
   tmp = im->border.bottom;
   im->border.bottom = im->border.right;
   im->border.right = tmp;
}

void
__imlib_BlurImage(ImlibImage *im, int rad)
{
   DATA32 *p1, *p2, *data;
   int x, y, mx, my, mw, mh, mt, xx, yy;
   int a, r, g, b;
   int *as, *rs, *gs, *bs;
   
   if (rad < 1)
      return;
   data = malloc(im->w * im->h * sizeof(DATA32));
   as = malloc(sizeof(int) * im->w);
   rs = malloc(sizeof(int) * im->w);
   gs = malloc(sizeof(int) * im->w);
   bs = malloc(sizeof(int) * im->w);
   for (y = 0; y < im->h; y++)
     {
	my = y - rad;
	mh = (rad << 1) + 1;
	if (my < 0)
	  {
	     mh += my;
	     my = 0;
	  }
	if ((my + mh) > im->h)
	   mh = im->h - my;
	
	p1 = data + (y * im->w);
	memset(as, 0, im->w * sizeof(int));
	memset(rs, 0, im->w * sizeof(int));
	memset(gs, 0, im->w * sizeof(int));
	memset(bs, 0, im->w * sizeof(int));
	for (yy = 0; yy < mh; yy++)
	  {
	     p2 = im->data + ((yy + my) * im->w);
	     for (x = 0; x < im->w; x++)
	       {
		  as[x] += (*p2 >> 24) & 0xff;
		  rs[x] += (*p2 >> 16) & 0xff;
		  gs[x] += (*p2 >> 8) & 0xff;
		  bs[x] += *p2 & 0xff;
		  p2 ++;
	       }
	  }
	if (im->w > ((rad << 1) + 1))
	  {
	     for (x = 0; x < im->w; x++)
	       {	     
		  a = 0; r = 0; g = 0; b = 0;
		  mx = x - rad;
		  mw = (rad << 1) + 1;
		  if (mx < 0)
		    {
		       mw += mx;
		       mx = 0;
		    }
		  if ((mx + mw) > im->w)
		     mw = im->w - mx;
		  mt = mw * mh;
		  for (xx = mx; xx < (mw + mx); xx++)
		    {
		       a += as[xx];
		       r += rs[xx];
		       g += gs[xx];
		       b += bs[xx];
		    }
		  a = a / mt; r = r / mt; g = g / mt; b = b / mt;
		  *p1 = (a << 24) | (r << 16) | (g << 8) | b;
		  p1++;
	       }
	  }
	else
	  {
	  }
     }
   free(as);
   free(rs);
   free(gs);
   free(bs);
   free(im->data);
   im->data = data;
}

void
__imlib_SharpenImage(ImlibImage *im, int rad)
{
   DATA32 *data, *p1, *p2;
   int a, r, g, b, x, y;
   /* FIXME: impliment */
   
   data = malloc(im->w * im->h * sizeof(DATA32));
   if (rad == 0)
      return;
   else
     {
	int mul, mul2, tot;
	
	mul = (rad * 4) + 1;
	mul2 = rad;
	tot = mul - (mul2 * 4);
	for (y = 1; y < (im->h - 1); y++)
	  {
	     p1 = im->data + 1 + (y * im->w);
	     p2 = data + 1 + (y * im->w);
	     for (x = 1; x < (im->w - 1); x++)
	       {
		  b =  (int)((p1[0]      ) & 0xff) * 5;
		  g =  (int)((p1[0] >> 8 ) & 0xff) * 5;
		  r =  (int)((p1[0] >> 16) & 0xff) * 5;
		  a =  (int)((p1[0] >> 24) & 0xff) * 5;
		  b -= (int)((p1[-1]      ) & 0xff);
		  g -= (int)((p1[-1] >> 8 ) & 0xff);
		  r -= (int)((p1[-1] >> 16) & 0xff);
		  a -= (int)((p1[-1] >> 24) & 0xff);
		  b -= (int)((p1[1]      ) & 0xff);
		  g -= (int)((p1[1] >> 8 ) & 0xff);
		  r -= (int)((p1[1] >> 16) & 0xff);
		  a -= (int)((p1[1] >> 24) & 0xff);
		  b -= (int)((p1[-im->w]      ) & 0xff);
		  g -= (int)((p1[-im->w] >> 8 ) & 0xff);
		  r -= (int)((p1[-im->w] >> 16) & 0xff);
		  a -= (int)((p1[-im->w] >> 24) & 0xff);
		  b -= (int)((p1[im->w]      ) & 0xff);
		  g -= (int)((p1[im->w] >> 8 ) & 0xff);
		  r -= (int)((p1[im->w] >> 16) & 0xff);
		  a -= (int)((p1[im->w] >> 24) & 0xff);
		  
		  a = (a & ((~a) >> 16));
		  a = ((a | ((a & 256) - ((a & 256) >> 8))) );
		  r = (r & ((~r) >> 16));
		  r = ((r | ((r & 256) - ((r & 256) >> 8))) );
		  g = (g & ((~g) >> 16));
		  g = ((g | ((g & 256) - ((g & 256) >> 8))) );
		  b = (b & ((~b) >> 16));
		  b = ((b | ((b & 256) - ((b & 256) >> 8))) );
		  
		  *p2 = (a << 24) | (r << 16) | (g << 8) | b;
		  p2++;
		  p1++;
	       }
	  }
     }
   free(im->data);
   im->data = data;
}

void
__imlib_TileImageHoriz(ImlibImage *im)
{
   DATA32 *p1, *p2, *p3, *p, *data;
   int x, y, per, tmp, na, nr, ng, nb, mix, a, r, g, b, aa, rr, gg, bb;
   
   data = malloc(im->w * im->h * sizeof(DATA32));
   p1 = im->data;
   p = data;
   for (y = 0; y < im->h; y++)
     {
	p2 = p1 + (im->w >> 1);
	p3 = p1;
	per = (im->w >> 1);
	for (x = 0; x < (im->w >> 1); x++)
	  {
	     mix = (x * 255) / per;
	     b =  (*p1      ) & 0xff;
	     g =  (*p1 >> 8 ) & 0xff;
	     r =  (*p1 >> 16) & 0xff;
	     a =  (*p1 >> 24) & 0xff;
	     
	     bb = (*p2      ) & 0xff;
	     gg = (*p2 >> 8 ) & 0xff;
	     rr = (*p2 >> 16) & 0xff;
	     aa = (*p2 >> 24) & 0xff;
	     
	     tmp = (r - rr) * mix;
	     nr = rr + ((tmp + (tmp >> 8) + 0x80) >> 8);
	     tmp = (g - gg) * mix;
	     ng = gg + ((tmp + (tmp >> 8) + 0x80) >> 8);
	     tmp = (b - bb) * mix;
	     nb = bb + ((tmp + (tmp >> 8) + 0x80) >> 8);
	     tmp = (a - aa) * mix;
	     na = aa + ((tmp + (tmp >> 8) + 0x80) >> 8);
	     *p = (na << 24) | (nr << 16) | (ng << 8) | nb;
	     p++;
	     p1++;
	     p2++;
	  }
	p2 = p3;
	per = (im->w - (im->w >> 1));
	for (; x < im->w; x++)
	  {
	     mix = ((im->w - 1 - x) * 255) / per;
	     b =  (*p1      ) & 0xff;
	     g =  (*p1 >> 8 ) & 0xff;
	     r =  (*p1 >> 16) & 0xff;
	     a =  (*p1 >> 24) & 0xff;
	     
	     bb = (*p2      ) & 0xff;
	     gg = (*p2 >> 8 ) & 0xff;
	     rr = (*p2 >> 16) & 0xff;
	     aa = (*p2 >> 24) & 0xff;
	     
	     tmp = (r - rr) * mix;
	     nr = rr + ((tmp + (tmp >> 8) + 0x80) >> 8);
	     tmp = (g - gg) * mix;
	     ng = gg + ((tmp + (tmp >> 8) + 0x80) >> 8);
	     tmp = (b - bb) * mix;
	     nb = bb + ((tmp + (tmp >> 8) + 0x80) >> 8);
	     tmp = (a - aa) * mix;
	     na = aa + ((tmp + (tmp >> 8) + 0x80) >> 8);
	     *p = (na << 24) | (nr << 16) | (ng << 8) | nb;
	     p++;
	     p1++;
	     p2++;
	  }
     }
   free(im->data);
   im->data = data;
}

void
__imlib_TileImageVert(ImlibImage *im)
{
   DATA32 *p1, *p2, *p, *data;
   int x, y, tmp, na, nr, ng, nb, mix, a, r, g, b, aa, rr, gg, bb;
   
   data = malloc(im->w * im->h * sizeof(DATA32));
   p = data;
   for (y = 0; y < im->h; y++)
     {
	p1 = im->data + (y * im->w);
	if (y < (im->h >> 1))
	  {
	     p2 = im->data + ((y + (im->h >> 1)) * im->w);
	     mix = (y * 255) / (im->h >> 1);
	  }
	else
	  {
	     p2 = im->data + ((y - (im->h - (im->h >> 1))) * im->w);
	     mix = ((im->h - y) * 255) / (im->h - (im->h >> 1));
	  }
	for (x = 0; x < im->w; x++)
	  {
	     b =  (*p1      ) & 0xff;
	     g =  (*p1 >> 8 ) & 0xff;
	     r =  (*p1 >> 16) & 0xff;
	     a =  (*p1 >> 24) & 0xff;
	     
	     bb = (*p2      ) & 0xff;
	     gg = (*p2 >> 8 ) & 0xff;
	     rr = (*p2 >> 16) & 0xff;
	     aa = (*p2 >> 24) & 0xff;
	     
	     tmp = (r - rr) * mix;
	     nr = rr + ((tmp + (tmp >> 8) + 0x80) >> 8);
	     tmp = (g - gg) * mix;
	     ng = gg + ((tmp + (tmp >> 8) + 0x80) >> 8);
	     tmp = (b - bb) * mix;
	     nb = bb + ((tmp + (tmp >> 8) + 0x80) >> 8);
	     tmp = (a - aa) * mix;
	     na = aa + ((tmp + (tmp >> 8) + 0x80) >> 8);
	     *p = (na << 24) | (nr << 16) | (ng << 8) | nb;
	     p++;
	     p1++;
	     p2++;
	  }
     }
   free(im->data);
   im->data = data;
}