/* -*- tab-width: 4; -*- */
/* vi: set sw=2 ts=4 expandtab: */

/*
 * Copyright 2010-2020 The Khronos Group Inc.
 * SPDX-License-Identifier: Apache-2.0
 */

/**
 * @file
 * @~English
 *
 * @brief Implementation of ktxStream for FILE.
 *
 * @author Maksim Kolesin, Under Development
 * @author Georg Kolling, Imagination Technology
 * @author Mark Callow, HI Corporation
 */

#include <assert.h>
#include <errno.h>
#include <inttypes.h>
#include <string.h>
/* I need these on Linux. Why? */
#define __USE_LARGEFILE 1  // For declaration of ftello, etc.
#define __USE_POSIX 1      // For declaration of fileno.
#define _POSIX_SOURCE 1    // For both the above in Emscripten.
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>     // For stat.h on Windows
#define __USE_MISC 1       // For declaration of S_IF...
#include <sys/stat.h>

#include "ktx.h"
#include "ktxint.h"
#include "filestream.h"

// Gotta love Windows :-(
#if defined(_MSC_VER)
  #if defined(_WIN64)
    #define ftello _ftelli64
    #define fseeko _fseeki64
  #else
    #define ftello ftell
    #define fseeko fseek
  #endif
  #define fileno _fileno
  #define fstat _fstat
  #define stat _stat
  #define S_IFIFO _S_IFIFO
  #define S_IFSOCK 0xC000
  typedef unsigned short mode_t;
#endif

#if defined(__MINGW32__)
    #define S_IFSOCK 0xC000
#endif

#define KTX_FILE_STREAM_MAX (1 << (sizeof(ktx_off_t) - 1) - 1)

/**
 * @~English
 * @brief Read bytes from a ktxFileStream.
 *
 * @param [in]  str     pointer to the ktxStream from which to read.
 * @param [out] dst     pointer to a block of memory with a size
 *                      of at least @p size bytes, converted to a void*.
 * @param [in,out] count   pointer to total count of bytes to be read.
 *                         On completion set to number of bytes read.
 *
 * @return      KTX_SUCCESS on success, other KTX_* enum values on error.
 *
 * @exception KTX_INVALID_VALUE @p dst is @c NULL or @p src is @c NULL.
 * @exception KTX_FILE_READ_ERROR  an error occurred while reading the file.
 * @exception KTX_FILE_UNEXPECTED_EOF not enough data to satisfy the request.
 */
static
KTX_error_code ktxFileStream_read(ktxStream* str, void* dst, const ktx_size_t count)
{
    ktx_size_t nread;

    if (!str || !dst)
        return KTX_INVALID_VALUE;

    assert(str->type == eStreamTypeFile);

    if ((nread = fread(dst, 1, count, str->data.file)) != count) {
        if (feof(str->data.file)) {
            return KTX_FILE_UNEXPECTED_EOF;
        } else {
            return KTX_FILE_READ_ERROR;
        }
    }
    str->readpos += count;

    return KTX_SUCCESS;
}

/**
 * @~English
 * @brief Skip bytes in a ktxFileStream.
 *
 * @param [in] str           pointer to a ktxStream object.
 * @param [in] count         number of bytes to be skipped.
 *
 * In order to support applications reading from stdin, read characters
 * rather than using seek functions.
 *
 * @return      KTX_SUCCESS on success, other KTX_* enum values on error.
 *
 * @exception KTX_INVALID_VALUE @p str is @c NULL or @p count is less than zero.
 * @exception KTX_INVALID_OPERATION skipping @p count bytes would go beyond EOF.
 * @exception KTX_FILE_READ_ERROR  an error occurred while reading the file.
 * @exception KTX_FILE_UNEXPECTED_EOF not enough data to satisfy the request.
 *                                    @p count is set to the number of bytes
 *                                    skipped.
 */
static
KTX_error_code ktxFileStream_skip(ktxStream* str, const ktx_size_t count)
{
    if (!str)
        return KTX_INVALID_VALUE;

    assert(str->type == eStreamTypeFile);

    for (ktx_uint32_t i = 0; i < count; i++) {
        int ret = getc(str->data.file);
        if (ret == EOF) {
            if (feof(str->data.file)) {
                return KTX_FILE_UNEXPECTED_EOF;
            } else {
                return KTX_FILE_READ_ERROR;
            }
        }
    }
    str->readpos += count;

    return KTX_SUCCESS;
}

/**
 * @~English
 * @brief Write bytes to a ktxFileStream.
 *
 * @param [in] str      pointer to the ktxStream that is the destination of the
 *                      write.
 * @param [in] src      pointer to the array of elements to be written,
 *                      converted to a const void*.
 * @param [in] size     size in bytes of each element to be written.
 * @param [in] count    number of elements, each one with a @p size of size
 *                      bytes.
 *
 * @return      KTX_SUCCESS on success, other KTX_* enum values on error.
 *
 * @exception KTX_INVALID_VALUE @p str is @c NULL or @p src is @c NULL.
 * @exception KTX_FILE_OVERFLOW the requested write would caused the file to
 *                              exceed the maximum supported file size.
 * @exception KTX_FILE_WRITE_ERROR a system error occurred while writing the
 *                                 file.
 */
static
KTX_error_code ktxFileStream_write(ktxStream* str, const void *src,
                                   const ktx_size_t size,
                                   const ktx_size_t count)
{
    if (!str || !src)
        return KTX_INVALID_VALUE;

    assert(str->type == eStreamTypeFile);

    if (fwrite(src, size, count, str->data.file) != count) {
        if (errno == EFBIG || errno == EOVERFLOW)
            return KTX_FILE_OVERFLOW;
        else
            return KTX_FILE_WRITE_ERROR;
    }

    return KTX_SUCCESS;
}

/**
 * @~English
 * @brief Get the current read/write position in a ktxFileStream.
 *
 * @param [in] str      pointer to the ktxStream to query.
 * @param [in,out] off  pointer to variable to receive the offset value.
 *
 * @return      KTX_SUCCESS on success, other KTX_* enum values on error.
 *
 * @exception KTX_FILE_ISPIPE file descriptor underlying stream is associated
 *                            with a pipe or FIFO so does not have a
 *                            file-position indicator.
 * @exception KTX_INVALID_VALUE @p str or @p pos is @c NULL.
 */
static
KTX_error_code ktxFileStream_getpos(ktxStream* str, ktx_off_t* pos)
{
    ktx_off_t ftellval;

    if (!str || !pos)
        return KTX_INVALID_VALUE;

    assert(str->type == eStreamTypeFile);

    if (str->data.file == stdin) {
        *pos = str->readpos;
    } else {
        /* The cast quiets an Xcode warning when building for "Generic iOS Device".
         * I'm not sure why.
         */
        ftellval = (ktx_off_t)ftello(str->data.file);
        if (ftellval < 0) {
            switch (errno) {
              case ESPIPE: return KTX_FILE_ISPIPE;
              case EOVERFLOW: return KTX_FILE_OVERFLOW;
            }
        }

        *pos = ftellval;
    }

    return KTX_SUCCESS;
}

/**
 * @~English
 * @brief Set the current read/write position in a ktxFileStream.
 *
 * Offset of 0 is the start of the file. This function operates
 * like Linux > 3.1's @c lseek() when it is passed a @c whence
 * of @c SEEK_DATA as it returns an error if the seek would
 * go beyond the end of the file.
 *
 * @param [in] str    pointer to the ktxStream whose r/w position is to be set.
 * @param [in] off    pointer to the offset value to set.
 *
 * @return      KTX_SUCCESS on success, other KTX_* enum values on error.
 *
 * Throws the same exceptions as ktxFileStream_getsize() for the reasons given
 * there plus the following:
 *
 * @exception KTX_INVALID_VALUE @p str is @c NULL.
 * @exception KTX_INVALID_OPERATION @p pos is > the size of the file or an
 *                                  fseek error occurred.
 */
static
KTX_error_code ktxFileStream_setpos(ktxStream* str, ktx_off_t pos)
{
    ktx_size_t fileSize;
    KTX_error_code result;

    if (!str)
        return KTX_INVALID_VALUE;

    assert(str->type == eStreamTypeFile);

    if (str->data.file == stdin) {
        if (pos > str->readpos)
            return str->skip(str, pos - str->readpos);
        else
            return KTX_FILE_ISPIPE;
    }

    result = str->getsize(str, &fileSize);

    if (result != KTX_SUCCESS) {
        // Device is likely not seekable.
        return result;
    }

    if (pos > (ktx_off_t)fileSize)
        return KTX_INVALID_OPERATION;

    if (fseeko(str->data.file, pos, SEEK_SET) < 0)
            return KTX_FILE_SEEK_ERROR;
    else
            return KTX_SUCCESS;
}

/**
 * @~English
 * @brief Get the size of a ktxFileStream in bytes.
 *
 * @param [in] str       pointer to the ktxStream whose size is to be queried.
 * @param [in,out] size  pointer to a variable in which size will be written.
 *
 * @return    KTX_SUCCESS on success, other KTX_* enum values on error.
 *
 * @exception KTX_FILE_OVERFLOW size is too large to be returned in a
 *                              @c ktx_size_t.
 * @exception KTX_FILE_ISPIPE file descriptor underlying stream is associated
 *                            with a pipe or FIFO so does not have a
 *                            file-position indicator.
 * @exception KTX_FILE_READ_ERROR a system error occurred while getting the
 *                                size.
 * @exception KTX_INVALID_VALUE @p str or @p size is @c NULL.
 * @exception KTX_INVALID_OPERATION stream is a tty.
 */
static
KTX_error_code ktxFileStream_getsize(ktxStream* str, ktx_size_t* size)
{
    struct stat statbuf;
    int statret;

    if (!str || !size)
        return KTX_INVALID_VALUE;

    assert(str->type == eStreamTypeFile);

  // Need to flush so that fstat will return the current size.
  // Can ignore return value. The only error that can happen is to tell you
  // it was a NOP because the file is read only.
#if (defined(_MSC_VER) && _MSC_VER < 1900) || defined(__MINGW64__) && !defined(_UCRT)
  // Bug in VS2013 msvcrt. fflush on FILE open for READ changes file offset
  // to 4096.
  if (str->data.file->_flag & _IOWRT)
#endif
    (void)fflush(str->data.file);
    statret = fstat(fileno(str->data.file), &statbuf);
    if (statret < 0) {
        switch (errno) {
          case EOVERFLOW: return KTX_FILE_OVERFLOW;
          case EIO:
          default:
            return KTX_FILE_READ_ERROR;
        }
    }

    mode_t ftype = statbuf.st_mode & S_IFMT;
    if (ftype == S_IFIFO || ftype == S_IFSOCK)
        return KTX_FILE_ISPIPE;

    if (statbuf.st_mode & S_IFCHR)
        return KTX_INVALID_OPERATION;

    *size = (ktx_size_t)statbuf.st_size; /* See _getpos for why this cast. */

    return KTX_SUCCESS;
}

/**
 * @~English
 * @brief Initialize a ktxFileStream.
 *
 * @param [in] str      pointer to the ktxStream to initialize.
 * @param [in] file     pointer to the underlying FILE object.
 * @param [in] closeFileOnDestruct if not false, stdio file pointer will be closed when ktxStream
 *             is destructed.
 *
 * @return      KTX_SUCCESS on success, KTX_INVALID_VALUE on error.
 *
 * @exception KTX_INVALID_VALUE @p stream is @c NULL or @p file is @c NULL.
 */
KTX_error_code ktxFileStream_construct(ktxStream* str, FILE* file,
                                       ktx_bool_t closeFileOnDestruct)
{
    if (!str || !file)
        return KTX_INVALID_VALUE;

    str->data.file = file;
    str->readpos = 0;
    str->type = eStreamTypeFile;
    str->read = ktxFileStream_read;
    str->skip = ktxFileStream_skip;
    str->write = ktxFileStream_write;
    str->getpos = ktxFileStream_getpos;
    str->setpos = ktxFileStream_setpos;
    str->getsize = ktxFileStream_getsize;
    str->destruct = ktxFileStream_destruct;
    str->closeOnDestruct = closeFileOnDestruct;

    return KTX_SUCCESS;
}

/**
 * @~English
 * @brief Destruct the stream, potentially closing the underlying FILE.
 *
 * This only closes the underyling FILE if the @c closeOnDestruct parameter to
 * ktxFileStream_construct() was not @c KTX_FALSE.
 *
 * @param [in] str pointer to the ktxStream whose FILE is to potentially
 *             be closed.
 */
void
ktxFileStream_destruct(ktxStream* str)
{
    assert(str && str->type == eStreamTypeFile);

    if (str->closeOnDestruct)
        fclose(str->data.file);
    str->data.file = 0;
}