/* Copyright (C) 2001-2023 Artifex Software, Inc.
   All Rights Reserved.

   This software is provided AS-IS with no warranty, either express or
   implied.

   This software is distributed under license and may not be copied,
   modified or distributed except as expressly authorized under the terms
   of the license contained in the file LICENSE in this distribution.

   Refer to licensing information at http://www.artifex.com or contact
   Artifex Software, Inc.,  39 Mesa Street, Suite 108A, San Francisco,
   CA 94129, USA, for further information.
*/


/* TIFF hooks and stubs */

#include "stdint_.h"   /* for tiff.h */
#include "stdio_.h"
#include "time_.h"
#include "malloc_.h"
#include "gstypes.h"
#include "gscdefs.h"
#include "gdevprn.h"

#include "scommon.h"
#include "stream.h"
#include "strmio.h"

#include "gstiffio.h"

#define TIFF_PRINT_BUF_LENGTH 1024
static const char tifs_msg_truncated[] = "\n*** Previous line has been truncated.\n";

/* place to hold the data for our libtiff i/o hooks
 */
typedef struct tifs_io_private_t
{
    gp_file *f;
    gs_memory_t *memory;
} tifs_io_private;

/* libtiff i/o hooks */
static int
gs_tifsDummyMapProc(thandle_t fd, void** pbase, toff_t* psize)
{
    (void) fd;
    (void) pbase;
    (void) psize;
    return (0);
}

static void
gs_tifsDummyUnmapProc(thandle_t fd, void* base, toff_t size)
{
    (void) fd;
    (void) base;
    (void) size;
}

static size_t
gs_tifsReadProc(thandle_t fd, void* buf, size_t size)
{
    tifs_io_private *tiffio = (tifs_io_private *)fd;
    size_t size_io = (size_t) size;

    if ((size_t) size_io != size) {
        return (size_t) -1;
    }
    return((size_t) gp_fread (buf, 1, size_io, tiffio->f));
}

static size_t
gs_tifsWriteProc(thandle_t fd, void* buf, size_t size)
{
    tifs_io_private *tiffio = (tifs_io_private *)fd;
    size_t size_io = (size_t) size;
    size_t written;

    if ((size_t) size_io != size) {
        return (size_t) -1;
    }
    written = (size_t) gp_fwrite (buf, 1, size_io, tiffio->f);
    return written;
}

static uint64_t
gs_tifsSeekProc(thandle_t fd, uint64_t off, int whence)
{
    tifs_io_private *tiffio = (tifs_io_private *)fd;
    gs_offset_t off_io = (gs_offset_t) off;

    if ((uint64_t) off_io != off) {
        return (uint64_t) -1; /* this is really gross */
    }
    if (gp_fseek(tiffio->f , (gs_offset_t)off_io, whence) < 0) {
        return (uint64_t) -1;
    }
    return (gp_ftell(tiffio->f));
}

static int
gs_tifsCloseProc(thandle_t fd)
{
    tifs_io_private *tiffio = (tifs_io_private *)fd;

    /* We don't close tiffio->f as this will be closed later by the
     * device. */

    gs_free(tiffio->memory, tiffio, sizeof(tifs_io_private), 1, "gs_tifsCloseProc");

    return 0;
}

static uint64_t
gs_tifsSizeProc(thandle_t fd)
{
    tifs_io_private *tiffio = (tifs_io_private *)fd;
    uint64_t length;
    gs_offset_t curpos = gp_ftell(tiffio->f);

    if (curpos < 0) {
        return(0);
    }

    if (gp_fseek(tiffio->f, (gs_offset_t)0, SEEK_END) < 0) {
        return(0);
    }
    length = (uint64_t)gp_ftell(tiffio->f);

    if (gp_fseek(tiffio->f, curpos, SEEK_SET) < 0) {
        return(0);
    }
    return length;
}

TIFF *
tiff_from_filep(gx_device_printer *dev,  const char *name, gp_file *filep, int big_endian, bool usebigtiff)
{
    char mode[5] = "w";
    int modelen = 1;
    TIFF *t;
    tifs_io_private *tiffio;

    if (big_endian)
        mode[modelen++] = 'b';
    else
        mode[modelen++] = 'l';

    if (usebigtiff)
    /* this should never happen for libtiff < 4.0 - see tiff_put_some_params() */
        mode[modelen++] = '8';

    mode[modelen] = (char)0;

    tiffio = (tifs_io_private *)gs_malloc(dev->memory, sizeof(tifs_io_private), 1, "tiff_from_filep");
    if (!tiffio) {
        return NULL;
    }
    tiffio->f = filep;
    tiffio->memory = dev->memory;

    t = TIFFClientOpen(name, mode,
        (thandle_t) tiffio, (TIFFReadWriteProc)gs_tifsReadProc,
        (TIFFReadWriteProc)gs_tifsWriteProc, (TIFFSeekProc)gs_tifsSeekProc,
        gs_tifsCloseProc, (TIFFSizeProc)gs_tifsSizeProc, gs_tifsDummyMapProc,
        gs_tifsDummyUnmapProc);

    return t;
}

int tiff_filename_from_tiff(TIFF *t, char **name)
{
    *name = (char *)TIFFFileName(t);
    return 0;
}

static void
gs_tifsWarningHandlerEx(thandle_t client_data, const char* module, const char* fmt, va_list ap)
{
    tifs_io_private *tiffio = (tifs_io_private *)client_data;
    int count;
    char buf[TIFF_PRINT_BUF_LENGTH];

    count = vsnprintf(buf, sizeof(buf), fmt, ap);
    if (count < 0 || count >= sizeof(buf))  { /* MSVC || C99 */
        dmlprintf1(tiffio->memory, "%s", buf);
        dmlprintf1(tiffio->memory, "%s\n", tifs_msg_truncated);
    } else {
        dmlprintf1(tiffio->memory, "%s\n", buf);
    }
}

static void
gs_tifsErrorHandlerEx(thandle_t client_data, const char* module, const char* fmt, va_list ap)
{
    tifs_io_private *tiffio = (tifs_io_private *)client_data;
    const char *max_size_error = "Maximum TIFF file size exceeded";
    int count;
    char buf[TIFF_PRINT_BUF_LENGTH];

    count = vsnprintf(buf, sizeof(buf), fmt, ap);
    if (count < 0 || count >= sizeof(buf) )  { /* MSVC || C99 */
        dmlprintf1(tiffio->memory, "%s\n", buf);
        dmlprintf1(tiffio->memory, "%s", tifs_msg_truncated);
    } else {
        dmlprintf1(tiffio->memory, "%s\n", buf);
    }

#if (TIFFLIB_VERSION >= 20111221)
    if (!strncmp(fmt, max_size_error, strlen(max_size_error))) {
        dmlprintf(tiffio->memory, "Use -dUseBigTIFF(=true) for BigTIFF output\n");
    }
#endif
}

void tiff_set_handlers (void)
{
    /* Bad things happen if we set custom error/warning
     * handlers, and multiple callers are using the shared
     * libtiff - our handlers may be triggered in the
     * context of the other caller(s) meaning it's not
     * our client_data being passed in.
     */
    (void)TIFFSetErrorHandler(NULL);
    (void)TIFFSetWarningHandler(NULL);
#if SHARE_LIBTIFF == 0
    (void)TIFFSetErrorHandlerExt(gs_tifsErrorHandlerEx);
    (void)TIFFSetWarningHandlerExt(gs_tifsWarningHandlerEx);
#endif
}

#if SHARE_LIBTIFF == 0
TIFF*
TIFFFdOpen(int fd, const char* name, const char* mode)
{
    (void)fd;
    (void)name;
    (void)mode;

    return(NULL);
}

TIFF*
TIFFOpen(const char* name, const char* mode)
{
    (void)name;
    (void)mode;

    return(NULL);
}

void*
_TIFFmalloc(tmsize_t s)
{
    return (malloc((size_t) s));
}

void* _TIFFcalloc(tmsize_t nmemb, tmsize_t siz)
{
    void *m = NULL;
    if( nmemb != 0 && siz != 0 ) {
        m = malloc((size_t)(nmemb * siz));
    }
    if (m)
        memset(m, 0x00, (size_t)(nmemb * siz));
    return m;
}

void
_TIFFfree(void* p)
{
    free(p);
}

void*
_TIFFrealloc(void* p, tmsize_t s)
{
    return (realloc(p, (size_t) s));
}

void
_TIFFmemset(void* p, int v, tmsize_t c)
{
    memset(p, v, (size_t) c);
}

void
_TIFFmemcpy(void* d, const void* s, tmsize_t c)
{
    memcpy(d, s, (size_t) c);
}

int
_TIFFmemcmp(const void* p1, const void* p2, tmsize_t c)
{
    return (memcmp(p1, p2, (size_t) c));
}

#if !defined(HAVE_SNPRINTF) && !defined(HAVE__SNPRINTF)
#include "gssprintf.h"
/* gets rid of compiler warning -- could include tiffiop.h, not sure which is better */
int _TIFF_snprintf_f(char* buf, size_t size, const char* format, ...);
int
_TIFF_snprintf_f(char* buf, size_t size, const char* format, ...)
{
    int count;
    va_list args;

    va_start(args, format);
    count = gs_vsnprintf(buf, size, format, args);
    va_end(args);
    return count;
}
#endif

/* We supply our own warning/error handlers when we invoke libtiff */
TIFFErrorHandler _TIFFwarningHandler = NULL;
TIFFErrorHandler _TIFFerrorHandler = NULL;

#endif /*  SHARE_LIBTIFF == 0 */