#include "img.h"

#pragma pack(push,1)

typedef struct {

  unsigned char  idLength;

  unsigned char  colormapType;

  unsigned char  imageType;

  unsigned char  colormapIndex[2];

  unsigned char  colormapLength[2];

  unsigned char  colormapSize;

  unsigned char  xOrigin[2];

  unsigned char  yOrigin[2];

  unsigned char  width[2];

  unsigned char  height[2];

  unsigned char  pixelSize;

  unsigned char  attributes;

} TgaHeader;

#pragma pack(pop)

Image imgCreate(int w, int h) {

  if (w <= 0 || h <= 0)

    return (Image){};

  Color *pixels = malloc(sizeof(Color)*w*h);

  if (!pixels)

    return LOGERR("imgCreate: cannot alocate memory for pixels (%dx%d)", w, h), (Image){};

  return (Image){ .w = w, .h = h, .data = pixels };

}

void imgFree(Image *img) {

  if (!img) return;

  LOGDBG("imgFree");

  free(img->data);

  *img = (Image){};

}

Image imgCopy(Image img) {

  if (!imgValid(img)) return (Image){};

  Image res = imgCreate(img.w, img.h);

  if (!imgValid(res)) return (Image){};

  memcpy(res.data, img.data, sizeof(Color)*img.w*img.h);

  return res;

}

Image imgSub(Image img, int x, int y, int w, int h) {

  if (!imgValid(img)) return (Image){};

  if (x < 0) w += x, x = 0;

  if (y < 0) h += y, y = 0;

  if (x + w > img.w) w = img.w - x;

  if (y + h > img.h) h = img.h - y;

  if (w <= 0 || h <= 0) return (Image){};

  Image res = imgCreate(w, h);

  if (!imgValid(res)) return (Image){};

  for(int i = 0; i < h; ++i)

    memcpy(res.data + i*w, img.data + (y+i)*img.w + x, sizeof(Color)*w);

  return res;

}

void imgClear(Image img) {

  if (!imgValid(img)) return;

  memset(img.data, 0, sizeof(Color)*img.w*img.h);

}

void imgMultA(Image img) {

  if (!imgValid(img)) return;

  for(Color *p = img.data, *e = p + img.w*img.h; p < e; ++p) {

    unsigned int a = p->a;

    p->r = (p->r*a + 0xff) >> 8;

    p->g = (p->g*a + 0xff) >> 8;

    p->b = (p->b*a + 0xff) >> 8;

  }

}

void imgDivA(Image img) {

  if (!imgValid(img)) return;

  for(Color *p = img.data, *e = p + img.w*img.h; p < e; ++p) {

    unsigned int a = p->a;

    if (!a) continue;

    p->r = (((unsigned int)p->r << 8) - 1)/a;

    p->g = (((unsigned int)p->g << 8) - 1)/a;

    p->b = (((unsigned int)p->b << 8) - 1)/a;

  }

}

int imgVisible(Image img) {

  if (!imgValid(img)) return 0;

  for(Color *p = img.data, *e = p + img.w*img.h; p < e; ++p)

    if (p->a) return 1;

  return 0;

}

int imgHasPicture(Image img) {

  if (!imgValid(img)) return 0;

  Color c = {};

  for(Color *p = img.data, *e = p + img.w*img.h; p < e; ++p)

    if (p->a) { c = *p; break; }

  if (!c.a) return 0;

  for(Color *p = img.data, *e = p + img.w*img.h; p < e; ++p)

    for(int i = 0; i < 4; ++i)

      if (p->c[i] != c.c[i]) return 1;

  return 0;

}

static void rowResample(

  Color *dst, unsigned int dcnt, unsigned int dstep,

  Color *src, unsigned int scnt, unsigned int sstep

) {

  if (dcnt < scnt) {

    // downscale

    unsigned int sistep = dcnt << 8, si = sistep, di1 = 0x100, w = 0, sum[4];

    for(Color *e = src + scnt*sstep; src != e; src += sstep, si += sistep) {

      unsigned int di = si/scnt;

      if (di < di1) {

        w += 0xff;

        for(int i = 0; i < 4; ++i)

          sum[i] += src->c[i];

      } else {

        unsigned int k1 = (di - di1)*scnt/dcnt;

        unsigned int k0 = 0xff - k1;

        w += k0;

        for(int i = 0; i < 4; ++i) {

          unsigned int c = src->c[i];

          unsigned int cc = (c*k0 + 0xff) >> 8;

          dst->c[i] = (sum[i] + cc)*255/w;

          sum[i] = (c*k1 + 0xff) >> 8;

        }

        w = k1;

        di1 += 0x100;

        dst += dstep;

      }

    }

  } else {

    // upscale

    if (!--dcnt) dcnt = 1;

    if (!--scnt) sstep = 0;

    unsigned int di = 0, distep = (scnt << 8) - 1;

    for(Color *e = dst + dcnt*dstep + dstep; dst != e; dst += dstep, di += distep) {

      unsigned int si = di/dcnt;

      unsigned int k1 = si & 0xff;

      unsigned int k0 = 0xff - k1;

      si >>= 8;

      Color *s0 = src + si*sstep;

      Color *s1 = s0 + sstep;

      for(int i = 0; i < 4; ++i)

        dst->c[i] = (s0->c[i]*k0 + s1->c[i]*k1 + 0xff) >> 8;

    }

  }

}

Image imgResampleX(Image img, int w) {

  if (!imgValid(img) || w <= 0)

    return (Image){};

  if (img.w == w)

    return imgCopy(img);

  Image res = imgCreate(w, img.h);

  for(int i = 0; i < res.h; ++i)

    rowResample(res.data + i*w, w, 1, img.data + i*img.w, img.w, 1);

  return res;

}

Image imgResampleY(Image img, int h) {

  if (!imgValid(img) || h <= 0)

    return (Image){};

  if (img.h == h)

    return imgCopy(img);

  Image res = imgCreate(img.w, h);

  for(int i = 0; i < res.w; ++i)

    rowResample(res.data + i, h, img.w, img.data + i, img.h, img.w);

  return res;

}

Image imgResample(Image img, int w, int h) {

  if (!imgValid(img) || w <= 0 || h <= 0)

    return (Image){};

  if (img.w == w && img.h == h)

    return imgCopy(img);

  if (img.h == h)

    return imgResampleX(img, w);

  if (img.w == w)

    return imgResampleY(img, h);

  //clock_t start = clock();

  Image tmp = imgResampleX(img, w);

  Image res = imgResampleY(tmp, h);

  imgFree(&tmp);

  //LOGDBG("imgResample: %f sec", (clock() - start)/(double)CLOCKS_PER_SEC);

  return res;

}

XImage* imgToX(Image *img) {

  LOGDBG("imgToX: create XImage");

  if (!img)

    return LOGERR("imgToX: bad args"), NULL;

  XImage *res = XCreateImage(dpy, visual, 24, ZPixmap, 0, (char*)img->data, img->w, img->h, 32, img->w*sizeof(Color));

  if (!res)

    return LOGERR("imgToX: cannot create XImage (%dx%d)", img->w, img->h), imgFree(img), NULL;

  *img = (Image){};

  return res;

}

Image imgLoadTga(const char *filename) {

  LOGDBG("imgLoadTga: open: %s", filename);

  FILE *f = fopen(filename, "rb");

  if (!f)

    return LOGERR("imgLoadTga: cannot open file for read: %s", filename), (Image){};

  LOGDBG("imgLoadTga: read header");

  TgaHeader header = {};

  fread(&header, sizeof(header), 1, f);

  if ( header.imageType != 2

    || (!header.width[0] && !header.width[1])

    || (!header.height[0] && !header.height[1])

    || header.colormapType

    || (header.pixelSize != 24 && header.pixelSize != 32) )

    return LOGERR("imgLoadTga: unsupported format, only uncompressed 24 or 32 bits TGA are supported: %s", filename), fclose(f), (Image){};

  int w = header.width[1]*256 + header.width[0];

  int h = header.height[1]*256 + header.height[0];

  LOGDBG("imgLoadTga: create image (%d x %d)", w, h);

  Image res = imgCreate(w, h);

  if (!imgValid(res))

    return LOGERR("imgLoadTga: cannot create image (%d x %d): %s", w, h, filename), fclose(f), (Image){};

  LOGDBG("imgLoadTga: read data");

  fseek(f, header.idLength, SEEK_CUR);

  Color *row = res.data + w*h;

  for(unsigned short r = h; r; --r, row -= w) {

    for(Color *c = row - w; c < row; ++c) {

      c->r = fgetc(f);

      c->g = fgetc(f);

      c->b = fgetc(f);

      c->a = header.pixelSize == 32 ? fgetc(f) : 255;

    }

  }

  LOGDBG("imgLoadTga: done");

  fclose(f);

  return res;

}