/*
 * Create a tiled interface and draw it.
 *
 *
 * Compile with:
 *    gcc -g -O2 -o tileTest tileTest.c -ltiff -lgeotiff \
 *       `pkg-config --libs --cflags gtk+-2.0`
 */


#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <assert.h>

#include <gtk/gtk.h>

#include <tiffio.h>
#include <xtiffio.h>
//#include <geotiff.h>
//#include <geo_normalize.h>

#define APPNAME "tileTest"
#define WIDTH   640
#define HEIGHT  480

static GdkPixbuf *pixbuf;
static TIFF *tiff;






static void
FillGradient(guchar *pixels, uint32 chan, uint32 rs, uint32 w, uint32 h)
{
   int x, y;
   guchar *p;

   /*
    * Pattern goes like:
    * 
    * (0,0,0)   ... (X,X/2,0)
    * .                .
    * .                .
    * .                .
    * (0,Y/2,Y) ... (X,X/2+Y/2,Y)
    * 
    * X and Y are normalized from 0:width-1 and 0:height-1 to 0:255 and 0:255.
    * 
    */

#define NORM(v,a) ((v) * 256 / (a))

   for (x = 0; x < w; x++) {
      for (y = 0; y < h; y++) {
         int r, g, b;


         r = NORM(x, w);
         b = NORM(y, h);
         g = r / 2 + b / 2;

         p = pixels + y * rs + x * chan;

         p[0] = r;
         p[1] = g;
         p[2] = b;
         p[3] = 255;
      }
   }
}


struct BackingStore {
   uint32 w;  // width of bs
   uint32 h;  // height of bs
   uint32 x;  // offset into bs of viewport
   uint32 y;  // offset into bs of viewport
   uint8 *buf;
};

static struct BackingStore *bs = NULL;

void
FreeBackingStore(void)
{
   free(bs->buf);
   free(bs);
}

void
AllocBackingStore(uint32 w, uint32 h)
{
   assert(bs == NULL);

   bs = malloc(sizeof(struct BackingStore));
   if (bs == NULL) {
      fprintf(stderr, "Failed to alloc backing store: %s\n", strerror(errno));
      exit(EXIT_FAILURE);
   }

   bs->buf = malloc(w * h * 16); // 4 bytes/pixel and 2x width and height
   if (bs == NULL) {
      free(bs);
      fprintf(stderr, "Failed to alloc backing store buffer: %s\n",
              strerror(errno));
      exit(EXIT_FAILURE);
   }

   bs->w = w * 2;
   bs->h = h * 2;
   bs->x = 0;
   bs->y = 0;
}

void
UpdateBackingStore(uint32 vx, uint32 vy, uint32 vw, uint32 vh)
{

}


void
FillImage(guchar *pixels, uint32 chan, uint32 rs, uint32 w, uint32 h)
{
   /* w, h => viewport width, height */
   /* rs => row stride */
   uint32 tw, th, npix, *ras; /* TIFF width, height, number of pixels, raster */
   uint32 txo, tyo; /* TIFF X offset, Y offset to start of viewport */
   uint32 xo, yo;
   uint32 W, H, x, y;

   TIFFGetField(tiff, TIFFTAG_IMAGEWIDTH, &tw);
   TIFFGetField(tiff, TIFFTAG_IMAGELENGTH, &th);
   npix = tw * th;

   printf("image width %u, height %u, npix %u\n", tw, th, npix);

   ras = (uint32 *)_TIFFmalloc(npix * 4);
   if (ras == NULL) {
      fprintf(stderr, "Failed to _TIFFmalloc %u bytes!\n", npix * 4);
      gtk_main_quit();
      return;
   }

   /*
    * Figure out viewport.
    */

   if (tw > w) {
      txo = (tw - w) / 2;
      W = w;
      xo = 0;
   } else if (tw < w) {
      txo = 0;
      W = tw;
      xo = (w - tw) / 2;
   } else {
      txo = xo = 0;
      W = w;
   }

   if (th > h) {
      tyo = (th - h) / 2;
      H = h;
      yo = 0;
   } else if (th < h) {
      tyo = 0;
      H = th;
      yo = (h - th) / 2;
   } else {
      tyo = yo = 0;
      H = h;
   }


   printf("TIFF offset (%u,%u), pixbuf offset (%u,%u), (W,H) (%u,%u)\n",
          txo, tyo, xo, yo, W, H);

   if (TIFFIsTiled(tiff)) {
      printf("image is tiled, size = %u bytes\n", TIFFTileSize(tiff));
   } else {
      printf("image has %u strips, scanline size = %u\n",
             TIFFNumberOfStrips(tiff), TIFFScanlineSize(tiff));

      
   }

   if (!TIFFReadRGBAImage(tiff, tw, th, ras, 0)) {
      fprintf(stderr, "TIFFReadRGBAImage failed\n");
      goto out;
   }

/*    if (!TIFFReadRGBAImageOriented(tiff, tw, th, ras, 0, ORIENTATION_TOPLEFT)) { */
/*       fprintf(stderr, "Failed to TIFFReadRGBAImage!\n"); */
/*       gtk_main_quit(); */
/*       return; */
/*    } */

   for (x = 0; x < W; x++) {
      for (y = 0; y < H; y++) {
         guchar *p;
         uint32 *tp;
         //uint8 r, g, b;

         p = pixels + (y + yo) * rs + (x + xo) * chan;
         tp = ras + (y + tyo) * tw + (x + txo);

         p[0] = TIFFGetR(*tp);
         p[1] = TIFFGetG(*tp);
         p[2] = TIFFGetB(*tp);
         p[3] = TIFFGetA(*tp);
         /* printf("(x,y,r,g,b,A) => (%u,%u,%hhu,%hhu,%hhu,%hhu)\n", */
         /*        x, y, p[0], p[1], p[2], p[3]); */
      }
   }

  out:
   _TIFFfree(ras);
}


void
FillPixbuf(void)
{
   uint32 chan, w, h, rs;
   guchar *pixels;
   
   pixels = gdk_pixbuf_get_pixels(pixbuf);
   chan = gdk_pixbuf_get_n_channels(pixbuf);
   rs = gdk_pixbuf_get_rowstride(pixbuf);
   w = gdk_pixbuf_get_width(pixbuf);
   h = gdk_pixbuf_get_height(pixbuf);

   FillGradient(pixels, chan, rs, w, h);
   FillImage(pixels, chan, rs, w, h);
}



gboolean
quit(GtkWidget *widget, GdkEvent *thisevent, gpointer data)
{
  gtk_main_quit();

  return TRUE;
}

gboolean
expose(GtkWidget *widget, GdkEvent *thisevent, gpointer data)
{
   gdk_draw_pixbuf(widget->window, NULL, pixbuf, 0, 0, 0, 0, -1, -1,
                   GDK_RGB_DITHER_NONE, 0, 0);

   return TRUE;
}

void
ui(void)
{
   GtkWidget *window, *img;

   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

   gtk_window_set_title(GTK_WINDOW(window), APPNAME);
   gtk_window_set_default_size(GTK_WINDOW(window), WIDTH, HEIGHT);
   gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);

   g_signal_connect(G_OBJECT (window), "delete_event", G_CALLBACK(quit),NULL);


   pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, WIDTH, HEIGHT);

   FillPixbuf();

   img = gtk_drawing_area_new();
   gtk_widget_set_size_request(img, WIDTH, HEIGHT);
   g_signal_connect(G_OBJECT(img), "expose_event", G_CALLBACK(expose), NULL);

   gtk_container_add(GTK_CONTAINER(window), img);

   gtk_widget_show_all(window);
}



int
main(int argc, char *argv[])
{
   gtk_init(&argc, &argv);

   if (argc != 2) {
      fprintf(stderr, "Missing filename\n");
      exit(EXIT_FAILURE);
   }

   if ((tiff = TIFFOpen(argv[1], "r")) == NULL) {
      fprintf(stderr, "Failed to open %s\n", argv[1]);
      exit(EXIT_FAILURE);
   }

   ui();
   g_set_application_name(APPNAME);

   AllocBackingStore(WIDTH, HEIGHT);

   gtk_main();

   FreeBackingStore();
   TIFFClose(tiff);

   return 0;
}