#if defined (HAVE_CONFIG_H)
#  include "config.h"
#endif

#include <string>
#include <iostream>

#include "defun-dld.h"
#include "ov.h"
#include "ovl.h"
#include "error.h"

#include "errwarn.h"

#if defined (HAVE_TIFF)
#  include <tiffio.h>
#endif

// TODO(maged): Tidy up the formatting to be consistant with octave

namespace octve
{
#if defined (HAVE_TIFF)
  // Error if status is not 1 (success status for TIFFGetField)
  void
  validate_tiff_get_field (bool status, void *p_to_free=NULL)
  {
      if (status != 1)
        {
          if (p_to_free != NULL)
            _TIFFfree (p_to_free);
          error ("Failed to read tag");
        }
  }

  octave_value_list
  interpret_scalar (void *data, TIFFDataType tag_datatype)
  {
    double retval;

    switch (tag_datatype)
      {
      case TIFF_BYTE:
      case TIFF_UNDEFINED:
        {
          retval = (double)(*((uint8_t *)data));
          break;
        }
      case TIFF_SHORT:
        {
          retval = (double)(*((uint16_t *)data));
          break;
        }
      case TIFF_LONG:
        {
          retval = (double)(*((uint32_t *)data));
          break;
        }
      case TIFF_LONG8:
        {
          retval = (double)(*((uint64_t *)data));
          break;
        }
      case TIFF_RATIONAL:
        {
          error ("TIFF_RATIONAL should have at least 2 elements but got only 1");
          break;
        }
      case TIFF_SBYTE:
        {
          retval = (double)(*((int8_t *)data));
          break;
        }
      case TIFF_SSHORT:
        {
          retval = (double)(*((int16_t *)data));
          break;
        }
      case TIFF_SLONG:
        {
          retval = (double)(*((int32_t *)data));
          break;
        }
      case TIFF_SLONG8:
        {
          retval = (double)(*((int64_t *)data));
          break;
        }
      case TIFF_FLOAT:
        {
          retval = *((float *)data);
          break;
        }
      case TIFF_DOUBLE:
        {
          retval = *((double *)data);
          break;
        }
      case TIFF_SRATIONAL:
        {
          error ("TIFF_SRATIONAL should have at least 2 elements but got only 1");
          break;
        }
      case TIFF_IFD:
      case TIFF_IFD8:
        error ("Unimplemented IFFD data type");
        break;
      default:
        error ("Unsupported tag data type");
      }

    return octave_value_list (octave_value (retval));
  }

  // Convert memory buffer into suitable octave values
  // depending on tag_datatype
  octave_value_list
  interpret_data (void *data, uint32_t count, TIFFDataType tag_datatype)
  {
    octave_value_list ovl_data;
    // Apparently matlab converts scalar numerical values into double
    // but doesn't do the same for arrays
    if (count == 1 && tag_datatype != TIFF_ASCII)
      {
        ovl_data = interpret_scalar (data, tag_datatype);
      }
    else
      {
        dim_vector arr_dims (1, count);

        switch (tag_datatype)
          {
          case TIFF_BYTE:
          case TIFF_UNDEFINED:
            {
              uint8NDArray arr (arr_dims);
              for (uint32_t i = 0; i < count; i++)
                {
                  arr(i) = ((uint8_t *)data)[i];
                }
              ovl_data(0) = arr;
              break;
            }
          case TIFF_ASCII:
            {
              ovl_data(0) = octave_value (*(char **)data);
              break;
            }
          case TIFF_SHORT:
            {
              uint16NDArray arr (arr_dims);
              for (uint32_t i = 0; i < count; i++)
                {
                  arr(i) = ((uint16_t *)data)[i];
                }
              ovl_data(0) = arr;
              break;
            }
          case TIFF_LONG:
            {
              uint32NDArray arr (arr_dims);
              for (uint32_t i = 0; i < count; i++)
                {
                  arr(i) = ((uint32_t *)data)[i];
                }
              ovl_data(0) = arr;
              break;
            }
          case TIFF_LONG8:
            {
              uint64NDArray arr (arr_dims);
              for (uint32_t i = 0; i < count; i++)
                {
                  arr(i) = ((uint64_t *)data)[i];
                }
              ovl_data(0) = arr;
              break;
            }
          case TIFF_RATIONAL:
            {
              NDArray arr (arr_dims);
              for (uint32_t i = 0; i < count; i+=2)
                {
                  arr(i / 2) = (float)((uint32_t *)data)[i] 
                                / (float)((uint32_t *)data)[i+1];
                }
              ovl_data(0) = arr;
              break;
            }
          case TIFF_SBYTE:
            {
              int8NDArray arr (arr_dims);
              for (uint32_t i = 0; i < count; i++)
                {
                  arr(i) = ((int8_t *)data)[i];
                }
              ovl_data(0) = arr;
              break;
            }
          case TIFF_SSHORT:
            {
              int16NDArray arr (arr_dims);
              for (uint32_t i = 0; i < count; i++)
                {
                  arr(i) = ((int16_t *)data)[i];
                }
              ovl_data(0) = arr;
              break;
            }
          case TIFF_SLONG:
            {
              int32NDArray arr (arr_dims);
              for (uint32_t i = 0; i < count; i++)
                {
                  arr(i) = ((int32_t *)data)[i];
                }
              ovl_data(0) = arr;
              break;
            }
          case TIFF_SLONG8:
            {
              int64NDArray arr (arr_dims);
              for (uint32_t i = 0; i < count; i++)
                {
                  arr(i) = ((int64_t *)data)[i];
                }
              ovl_data(0) = arr;
              break;
            }
          case TIFF_FLOAT:
            {
              NDArray arr (arr_dims);
              for (uint32_t i = 0; i < count; i++)
                {
                  arr(i) = ((float *)data)[i];
                }
              ovl_data(0) = arr;
              break;
            }
          case TIFF_DOUBLE:
            {
              NDArray arr (arr_dims);
              for (uint32_t i = 0; i < count; i++)
              {
                  arr(i) = ((double *)data)[i];
              }
              ovl_data(0) = arr;
              break;
            }
          case TIFF_SRATIONAL:
            {
              NDArray arr (arr_dims);
              for (uint32_t i = 0; i < count; i+=2)
                {
                  arr(i / 2) = (float)((int32_t *)data)[i] 
                                / (float)((int32_t *)data)[i+1];
                }
              ovl_data(0) = arr;
              break;
            }
          case TIFF_IFD:
          case TIFF_IFD8:
            // TODO(maged): implement IFD datatype?
            error ("Unimplemented IFFD data type");
            break;
          default:
            error ("Unsupported tag data type");
          }
      }

    return ovl_data;
  }

  octave_value_list
  get_scalar_field_data (TIFF *tif, const TIFFField *fip)
  {
    octave_value_list tag_data_ovl;
    uint32_t tag_id = TIFFFieldTag (fip);

    // TIFFFieldReadCount returns VARIABLE for some scalar tags
    // (e.g. Compression) But TIFFFieldPassCount seems consistent
    // Since scalar tags are the last to be handled, any tag that
    // require a count to be passed is an unsupported tag.
    if (TIFFFieldPassCount (fip))
      error ("Unsupported tag");
    
    // TODO(maged): test this function vs actual data type size
    int type_size = TIFFDataWidth (TIFFFieldDataType (fip));
    void *data = _TIFFmalloc (type_size);
    validate_tiff_get_field (TIFFGetField (tif, tag_id, data), data);
    tag_data_ovl = interpret_data (data, 1, TIFFFieldDataType (fip));
    _TIFFfree (data);

    return tag_data_ovl;
  }

  octave_value_list
  get_array_field_data (TIFF *tif, const TIFFField *fip, uint32_t array_size)
  {
    void *data;
    validate_tiff_get_field (TIFFGetField (tif, TIFFFieldTag (fip), &data));
      
    return interpret_data (data, array_size, TIFFFieldDataType (fip));
  }

  octave_value_list
  get_field_data (TIFF *tif, const TIFFField *fip)
  {
    octave_value_list tag_data_ovl;
    uint32_t tag_id = TIFFFieldTag (fip);

    // TODO(maged): find/create images to test the special tags
    switch (tag_id)
      {
      case TIFFTAG_STRIPBYTECOUNTS:
      case TIFFTAG_STRIPOFFSETS:
        tag_data_ovl = get_array_field_data (tif, fip, 
                                            TIFFNumberOfStrips (tif));
        break;
      case TIFFTAG_TILEBYTECOUNTS:
      case TIFFTAG_TILEOFFSETS:
        tag_data_ovl = get_array_field_data (tif, fip, TIFFNumberOfTiles (tif));
        break;
      case TIFFTAG_YCBCRCOEFFICIENTS:
        tag_data_ovl = get_array_field_data (tif, fip, 3);
        break;
      case TIFFTAG_REFERENCEBLACKWHITE:
        tag_data_ovl = get_array_field_data (tif, fip, 6);
        break;
      case TIFFTAG_GRAYRESPONSECURVE:
        {
          uint16_t bits_per_sample;
          if (! TIFFGetField (tif, TIFFTAG_BITSPERSAMPLE, &bits_per_sample))
            error ("Failed to obtain the bit depth");
          
          tag_data_ovl = get_array_field_data (tif, fip, 1<<bits_per_sample);
          break;
        }
      case TIFFTAG_COLORMAP:
        {
          uint16_t bits_per_sample;
          if (! TIFFGetField (tif, TIFFTAG_BITSPERSAMPLE, &bits_per_sample))
            error ("Failed to obtain the bit depth");
                
          if (bits_per_sample > 24)
            error ("Too high bit depth for a palette image");

          uint32_t count = 1 << bits_per_sample;
          uint16_t *red, *green, *blue;
          validate_tiff_get_field (TIFFGetField (tif, TIFFTAG_COLORMAP,
                                                &red, &green, &blue));
          tag_data_ovl(0) 
            = octave_value (interpret_data (red, count,
                                            TIFFFieldDataType (fip)));
          tag_data_ovl(1) 
            = octave_value (interpret_data (green, count,
                                            TIFFFieldDataType (fip)));
          tag_data_ovl(2) 
            = octave_value (interpret_data (blue, count,
                                            TIFFFieldDataType (fip)));
          
          break;
        }
      case TIFFTAG_TRANSFERFUNCTION:
        {
          uint16_t samples_per_pixel;
          if (! TIFFGetField (tif, TIFFTAG_SAMPLESPERPIXEL, &samples_per_pixel))
            error ("Failed to obtain the number of samples per pixel");

          uint16_t bits_per_sample;
          if (! TIFFGetField (tif, TIFFTAG_BITSPERSAMPLE, &bits_per_sample))
            error ("Failed to obtain the number of samples per pixel");

          uint32_t count = 1 << bits_per_sample;
          uint16_t *ch1, *ch2, *ch3;
          if (samples_per_pixel == 1)
            {
              validate_tiff_get_field (TIFFGetField (tif, TIFFTAG_COLORMAP, &ch1));
              tag_data_ovl(0) 
                = octave_value (interpret_data (ch1, count,
                                                TIFFFieldDataType (fip)));
            }
          else
            {
              validate_tiff_get_field (TIFFGetField (tif, TIFFTAG_COLORMAP,
                                                    &ch1, &ch2, &ch3));
              tag_data_ovl(0)
                = octave_value (interpret_data (ch1, count,
                                                TIFFFieldDataType (fip)));
              tag_data_ovl(1)
                = octave_value (interpret_data (ch2, count,
                                                TIFFFieldDataType (fip)));
              tag_data_ovl(2)
                = octave_value (interpret_data (ch3, count,
                                                TIFFFieldDataType (fip)));
            }
          break;
        }
      case TIFFTAG_PAGENUMBER:
      case TIFFTAG_HALFTONEHINTS:
      case TIFFTAG_DOTRANGE:
      case TIFFTAG_YCBCRSUBSAMPLING:
        {
          uint16_t tag_part1, tag_part2;
          validate_tiff_get_field (TIFFGetField (tif, tag_id,
                                                &tag_part1, &tag_part2));
          tag_data_ovl(0)
            = octave_value (interpret_data (&tag_part1, 1,
                                            TIFFFieldDataType (fip)));
          tag_data_ovl(1)
            = octave_value (interpret_data (&tag_part2, 1,
                                            TIFFFieldDataType (fip)));
          break;
        }
      case TIFFTAG_SUBIFD:
        {
          uint16_t count;
          uint64_t *offsets;
          validate_tiff_get_field (TIFFGetField (tif, tag_id, &count, &offsets));
          tag_data_ovl = interpret_data (offsets, count, TIFFFieldDataType (fip));
          break;
        }
      case TIFFTAG_EXTRASAMPLES:
        {
          uint16_t count;
          uint16_t *types;
          validate_tiff_get_field (TIFFGetField (tif, tag_id, &count, &types));
          tag_data_ovl = interpret_data (types, count, TIFFFieldDataType (fip));
          break;
        }
      // TODO(maged): These tags are more complex to implement
      //  will be implemented and tested later.
      case TIFFTAG_XMLPACKET:
      case TIFFTAG_RICHTIFFIPTC:
      case TIFFTAG_PHOTOSHOP:
      case TIFFTAG_ICCPROFILE:
        {
          error ("Complex Tags not implemented");
          break;
        }
      // These tags are not mentioned in the LibTIFF documentation
      // but are handled correctly by the library
      case TIFFTAG_ZIPQUALITY:
      case TIFFTAG_SGILOGDATAFMT:
      case TIFFTAG_GRAYRESPONSEUNIT:
        {
          tag_data_ovl = get_scalar_field_data (tif, fip);
          break;
        }
      default:
        tag_data_ovl = get_scalar_field_data (tif, fip);
    }
    
    return tag_data_ovl;
  }
#endif

  DEFUN_DLD (__open_tiff__, args, nargout,
             "Open a Tiff file and return its handle")
  {
#if defined (HAVE_TIFF)
    int nargin = args.length ();

    if (nargin == 0 || nargin > 2)
      {
        // TODO(maged): return invalid object instead??
        error ("No filename supplied\n");
      }

    std::string filename = args (0).string_value ();
    std::string mode = "r";

    // TODO(maged): check valid mode
    if (nargin == 2)
      mode = args (1).string_value ();
    
    // TODO(maged): Look into unwind action
    TIFF *tif = TIFFOpen (filename.c_str (), mode.c_str ());
    
    if (! tif)
      error ("Failed to open Tiff file\n");

    // TODO(maged): use inheritance of octave_base_value instead
    octave_value tiff_ov = octave_value ((uint64_t)tif);
    return octave_value_list (tiff_ov);
#else
    err_disabled_feature ("Tiff", "Tiff");
#endif
  }


  DEFUN_DLD (__close_tiff__, args, nargout,
             "Close a tiff file")
  {
#if defined (HAVE_TIFF)
    int nargin = args.length ();

    if (nargin == 0)
      error ("No handle provided\n");
    
    TIFF *tif = (TIFF *)(args (0).uint64_value ());
    TIFFClose (tif);

    return octave_value_list ();
#else
    err_disabled_feature ("close", "Tiff");
#endif
  }


  DEFUN_DLD (__tiff_get_tag__, args, nargout,
             "Get the value of a tag from a tiff image")
  {
#if defined (HAVE_TIFF)
    int nargin = args.length ();

    if (nargin == 0)
      error ("No handle provided\n");
    
    if (nargin < 2)
      error ("No tag name provided\n");
    
    TIFF *tif = (TIFF *)(args (0).uint64_value ());

    uint32_t tag_id;
    const TIFFField *fip;
    if (args (1).type_name () == "string")
      {
        std::string tagName = args (1).string_value ();
        fip = TIFFFieldWithName (tif, tagName.c_str ());
        if (! fip)
          error ("Tiff tag not found");
        
        tag_id = TIFFFieldTag (fip);
      }
    else
      {
        tag_id = args (1).int_value ();
        fip = TIFFFieldWithTag (tif, tag_id);
        // TODO(maged): Handle other types of errors (e.g. unsupported tags)
        if (! fip)
          error ("Tiff tag not found");
      }


    octave_value_list tag_data_ovl = get_field_data (tif, fip);

    return tag_data_ovl;
#else
    err_disabled_feature ("getTag", "Tiff");
#endif
  }

  DEFUN_DLD (__tiff_read__, args, nargout,
             "Read the image in the current IFD")
  {
#if defined (HAVE_TIFF)
    int nargin = args.length ();

    if (nargin == 0)
      error ("No handle provided\n");
    
    TIFF *tif = (TIFF *)(args (0).uint64_value ());

    // Check: Strips vs Tiles
    //        Planar Configuration
    //        StripByteCounts
    //        SamplesPerPixel and bits_per_smaple
    //        nargout and ycbcr
    //        ExtendedSamples? TransferFunction? GrayResponse? ColorMap?
    //        What about floating point images?

    // Obtain all necessary tags
    uint32_t width, height;
    if (! TIFFGetField (tif, TIFFTAG_IMAGEWIDTH, &width))
      error ("Failed to read image width");

    if (! TIFFGetField (tif, TIFFTAG_IMAGELENGTH, &height))
      error ("Failed to read image height");
    
    uint16_t samples_per_pixel;
    if (! TIFFGetField (tif, TIFFTAG_SAMPLESPERPIXEL, &samples_per_pixel))
      error ("Failed to read the SamplesPerPixel tag");

    uint16_t bits_per_sample;
    if (! TIFFGetField (tif, TIFFTAG_BITSPERSAMPLE, &bits_per_sample))
      error ("Failed to read the BitsPerSample tag");
    
    uint16_t planar_configuration;
    if (! TIFFGetField (tif, TIFFTAG_PLANARCONFIG, &planar_configuration))
      error ("Failed to read the PlanarConfiguration tag");
    
    int is_tiled = TIFFIsTiled(tif);

    // Create memory for storing the image data
    // TODO(maged): replace malloc with a suitable C++ structure
    void ***image = (void ***)malloc (sizeof(void ***) * height);
    uint32_t pixel_size = samples_per_pixel * (bits_per_sample / 8);
    for (uint32_t row = 0; row < height; row++)
      {
        image[row] = (void **)malloc (sizeof(void **) * width);
        for (uint32_t column = 0; column < width; column++)
          // Allocate at least one byte per pixel (For BitsPerSample < 8)
          image[row][column] = malloc (pixel_size > 0? pixel_size: 1);
      }

    if (is_tiled)
      // TODO(maged): Implement tiled images
      error ("Tiled images are not implemented yet");
    else
      {
        // Obtain the necessary data for handling the strips
        uint32_t strip_count = TIFFNumberOfStrips (tif);
        tdata_t buf = _TIFFmalloc (TIFFStripSize (tif));
        if (! buf)
          error ("Failed to allocate buffer for strip data");

        uint32_t row_index = 0;
        uint32_t row_size_in_bits = width * samples_per_pixel
                                    * bits_per_sample;
        // According to the Tiff format specification, the row size is
        // padded at least up to the next byte, so we add padding to
        // complete the byte
        row_size_in_bits += (8 - row_size_in_bits % 8) % 8;
        for (uint32_t strip = 0; strip < strip_count; strip++)
          {
            uint32_t strip_bytes = TIFFReadEncodedStrip (tif, strip, buf, -1);
            if (strip_bytes == -1)
              error ("Failed to read strip data");
            
            if (planar_configuration == PLANARCONFIG_CONTIG)
              {
                uint32_t rows_in_strip = strip_bytes * 8 / row_size_in_bits;
                for (uint32_t row_subindex = 0;
                     row_subindex < rows_in_strip;
                     row_subindex++)
                  {
                    for (uint32_t column = 0; column < width; column++)
                      {
                        uint32_t row_offset = row_size_in_bits / 8
                                              * row_subindex;
                        // TODO(maged): support arbitrary BitsPerSample
                        // for palette images
                        if (bits_per_sample >= 8 && bits_per_sample % 8 == 0)
                          {
                            memcpy (image[row_index + row_subindex][column],
                                    buf + row_offset + column * pixel_size,
                                    pixel_size);
                          }
                        else if (bits_per_sample == 4
                                 && samples_per_pixel == 1)
                          {
                            // TODO(maged): Check FillOrder for completeness
                            uint8_t byte
                              = ((uint8_t *)buf)[row_offset + column / 2];
                            // Extract the needed nibble from the byte
                            byte = (column % 2 == 0? byte >> 4: byte) & 0x0F;
                            uint8_t ***u8_img = (uint8_t ***)image;
                            u8_img[row_index + row_subindex][column][0] = byte;
                          }
                        else if (bits_per_sample == 1
                                 && samples_per_pixel == 1)
                          {
                            uint8_t byte
                              = ((uint8_t *)buf)[row_offset + column / 8];
                            // Extract the needed bit from the byte
                            uint8_t bit = (byte >> (7 - column % 8)) & 0x01;
                            uint8_t ***u8_img = (uint8_t ***)image;
                            u8_img[row_index + row_subindex][column][0] = bit;
                          }
                        else
                          error ("Unsupported bit depth");
                      }
                  }
                row_index += rows_in_strip;
              }
            else
              error ("Images with multiple planes are not implemented yet");
          }
        _TIFFfree (buf);
      }
    
    octave_value_list retval;
    dim_vector arr_dims (height, width, samples_per_pixel);
    // TODO(maged): what about palette images? are they handled internally?
    switch (bits_per_sample)
      {
      case 1:
        {
          boolNDArray arr(arr_dims);
          for (uint32_t row = 0; row < height; row++)
            for (uint32_t column = 0; column < width; column++)
              for (uint16_t sample = 0; sample < samples_per_pixel; sample++)
                arr(row, column, sample) = ((uint8_t ***)image)[row][column][sample];
          
          retval(0) = arr;
          break;
        }
      case 4:
      case 8:
        {
          uint8NDArray arr(arr_dims);
          for (uint32_t row = 0; row < height; row++)
            for (uint32_t column = 0; column < width; column++)
              for (uint16_t sample = 0; sample < samples_per_pixel; sample++)
                arr(row, column, sample) = ((uint8_t ***)image)[row][column][sample];
          
          retval(0) = arr;
          break;
        }
      case 16:
        {
          uint16NDArray arr(arr_dims);
          for (uint32_t row = 0; row < height; row++)
            for (uint32_t column = 0; column < width; column++)
              for (uint16_t sample = 0; sample < samples_per_pixel; sample++)
                arr(row, column, sample) = ((uint16_t ***)image)[row][column][sample];
          
          retval(0) = arr;
          break;
        }
      case 32:
        {
          uint32NDArray arr(arr_dims);
          for (uint32_t row = 0; row < height; row++)
            for (uint32_t column = 0; column < width; column++)
              for (uint16_t sample = 0; sample < samples_per_pixel; sample++)
                arr(row, column, sample) = ((uint32_t ***)image)[row][column][sample];
          
          retval(0) = arr;
          break;
        }
      case 64:
        {
          uint64NDArray arr(arr_dims);
          for (uint32_t row = 0; row < height; row++)
            for (uint32_t column = 0; column < width; column++)
              for (uint16_t sample = 0; sample < samples_per_pixel; sample++)
                arr(row, column, sample) = ((uint64_t ***)image)[row][column][sample];
          
          retval(0) = arr;
          break;
        }
      default:
        error ("Unsupported bit depth");
      }
    
    for (uint32_t row = 0; row < height; row++)
      {
        for (uint32_t column = 0; column < width; column++)
          free (image[row][column]);
        
        free (image[row]);
      }
    return retval;
#else
    err_disabled_feature ("read", "Tiff");
#endif
  }
}