#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

#include <grass/raster.h>
#include "raster3d_intern.h"

static int Rast3d_xdrTile2tile(RASTER3D_Map *map, void *tile, int rows,
                               int cols, int depths, int xRedundant,
                               int yRedundant, int zRedundant, int nofNum,
                               int type)
{
    int y, z, xLength, yLength, length;

    if (!Rast3d_init_copy_from_xdr(map, type)) {
        Rast3d_error("Rast3d_xdrTile2tile: error in Rast3d_init_copy_from_xdr");
        return 0;
    }

    if (nofNum == map->tileSize) {
        if (!Rast3d_copy_from_xdr(map->tileSize, tile)) {
            Rast3d_error("Rast3d_xdrTile2tile: error in Rast3d_copy_from_xdr");
            return 0;
        }
        return 1;
    }

    length = Rast3d_length(type);
    xLength = xRedundant * length;
    yLength = map->tileX * yRedundant * length;

    if (xRedundant) {
        for (z = 0; z < depths; z++) {
            for (y = 0; y < rows; y++) {
                if (!Rast3d_copy_from_xdr(cols, tile)) {
                    Rast3d_error(
                        "Rast3d_xdrTile2tile: error in Rast3d_copy_from_xdr");
                    return 0;
                }
                tile = G_incr_void_ptr(tile, cols * length);
                Rast3d_set_null_value(tile, xRedundant, type);
                tile = G_incr_void_ptr(tile, xLength);
            }
            if (yRedundant) {
                Rast3d_set_null_value(tile, map->tileX * yRedundant, type);
                tile = G_incr_void_ptr(tile, yLength);
            }
        }
        if (!zRedundant)
            return 1;

        Rast3d_set_null_value(tile, map->tileXY * zRedundant, type);
        return 1;
    }

    if (yRedundant) {
        for (z = 0; z < depths; z++) {
            if (!Rast3d_copy_from_xdr(map->tileX * rows, tile)) {
                Rast3d_error(
                    "Rast3d_xdrTile2tile: error in Rast3d_copy_from_xdr");
                return 0;
            }
            tile = G_incr_void_ptr(tile, map->tileX * rows * length);
            Rast3d_set_null_value(tile, map->tileX * yRedundant, type);
            tile = G_incr_void_ptr(tile, yLength);
        }
        if (!zRedundant)
            return 1;

        Rast3d_set_null_value(tile, map->tileXY * zRedundant, type);
        return 1;
    }

    if (!Rast3d_copy_from_xdr(map->tileXY * depths, tile)) {
        Rast3d_error("Rast3d_xdrTile2tile: error in Rast3d_copy_from_xdr");
        return 0;
    }

    if (!zRedundant)
        return 1;

    tile = G_incr_void_ptr(tile, map->tileXY * depths * length);
    Rast3d_set_null_value(tile, map->tileXY * zRedundant, type);

    return 1;
}

/*---------------------------------------------------------------------------*/

static int Rast3d_readTileUncompressed(RASTER3D_Map *map, int tileIndex,
                                       int nofNum)
{
    size_t nofBytes;
    ssize_t res;

    nofBytes = (size_t)nofNum * map->numLengthExtern;
    nofBytes =
        RASTER3D_MIN(nofBytes, (size_t)map->fileEndPtr - map->index[tileIndex]);

    if ((res = read(map->data_fd, xdr, nofBytes)) < 0 ||
        (size_t)res != nofBytes) {
        Rast3d_error("Rast3d_readTileUncompressed: can't read file");
        return 0;
    }

    return 1;
}

/*---------------------------------------------------------------------------*/

static int Rast3d_readTileCompressed(RASTER3D_Map *map, int tileIndex,
                                     int nofNum)
{
    if (!Rast3d_fpcompress_read_xdr_nums(
            map->data_fd, xdr, nofNum, map->tileLength[tileIndex],
            map->precision, tmpCompress, map->type == FCELL_TYPE)) {
        Rast3d_error("Rast3d_readTileCompressed: error in "
                     "Rast3d_fpcompress_read_xdr_nums");
        return 0;
    }

    return 1;
}

/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/
/* EXPORTED FUNCTIONS */

/*---------------------------------------------------------------------------*/

/*!
 * \brief
 *
 *
 * Reads tile with index <em>tileIndex</em> into the <em>tile</em> buffer. The
 * cells are stored with type <em>type</em> which must be one of FCELL_TYPE and
 * DCELL_TYPE. If the tile with <em>tileIndex</em> is not stored on the file
 * corresponding to <em>map</em>, and <em>tileIndex</em> is a valid index
 * <em>tile</em> is filled with NULL-values.
 *
 *  \param map
 *  \param tileIndex
 *  \param tile
 *  \param type
 *  \return 1 ... if successful,
 *          0 ... otherwise
 */

int Rast3d_read_tile(RASTER3D_Map *map, int tileIndex, void *tile, int type)
{
    int nofNum, rows, cols, depths, xRedundant, yRedundant, zRedundant;

    if ((tileIndex >= map->nTiles) || (tileIndex < 0))
        Rast3d_fatal_error("Rast3d_read_tile: tile index out of range");

    if (map->index[tileIndex] == -1) {
        Rast3d_set_null_tile_type(map, tile, type);
        return 1;
    }

    nofNum = Rast3d_compute_clipped_tile_dimensions(map, tileIndex, &rows,
                                                    &cols, &depths, &xRedundant,
                                                    &yRedundant, &zRedundant);

    if (lseek(map->data_fd, map->index[tileIndex], SEEK_SET) == -1) {
        Rast3d_error("Rast3d_read_tile: can't position file");
        return 0;
    }

    if (map->compression == RASTER3D_NO_COMPRESSION) {
        if (!Rast3d_readTileUncompressed(map, tileIndex, nofNum)) {
            Rast3d_error(
                "Rast3d_read_tile: error in Rast3d_readTileUncompressed");
            return 0;
        }
    }
    else if (!Rast3d_readTileCompressed(map, tileIndex, nofNum)) {
        Rast3d_error("Rast3d_read_tile: error in Rast3d_readTileCompressed");
        return 0;
    }

    if (!Rast3d_xdrTile2tile(map, tile, rows, cols, depths, xRedundant,
                             yRedundant, zRedundant, nofNum, type)) {
        Rast3d_error("Rast3d_read_tile: error in Rast3d_xdrTile2tile");
        return 0;
    }

    if (Rast3d_mask_is_off(map))
        return 1;

    Rast3d_mask_tile(map, tileIndex, tile, type);
    return 1;
}

/*---------------------------------------------------------------------------*/

/*!
 * \brief
 *
 *  Is equivalent to Rast3d_read_tile (map, tileIndex, tile, FCELL_TYPE).
 *
 *  \param map
 *  \param tileIndex
 *  \param tile
 *  \return int
 */

int Rast3d_read_tile_float(RASTER3D_Map *map, int tileIndex, void *tile)
{
    if (!Rast3d_read_tile(map, tileIndex, tile, FCELL_TYPE)) {
        Rast3d_error("Rast3d_read_tile_float: error in Rast3d_read_tile");
        return 0;
    }

    return 1;
}

/*---------------------------------------------------------------------------*/

/*!
 * \brief
 *
 *  Is equivalent to Rast3d_read_tile (map, tileIndex, tile, DCELL_TYPE).
 *
 *  \param map
 *  \param tileIndex
 *  \param tile
 *  \return int
 */

int Rast3d_read_tile_double(RASTER3D_Map *map, int tileIndex, void *tile)
{
    if (!Rast3d_read_tile(map, tileIndex, tile, DCELL_TYPE)) {
        Rast3d_error("Rast3d_read_tile_double: error in Rast3d_read_tile");
        return 0;
    }

    return 1;
}

/*---------------------------------------------------------------------------*/

/* CACHE-MODE-ONLY FUNCTIONS */

/*---------------------------------------------------------------------------*/

/*!
 * \brief
 *
 *  Locks tile with <em>tileIndex</em> in cache. If after locking fewer than the
 * minimum number of unlocked tiles are unlocked, the lock request is ignored.
 *
 *  \param map
 *  \param tileIndex
 *  \return 1 ... if successful,
 *          -1 ... if request is ignored,
 *          0 ... otherwise.
 */

int Rast3d_lock_tile(RASTER3D_Map *map, int tileIndex)
{
    if (!map->useCache)
        Rast3d_fatal_error(
            "Rast3d_lock_tile: function invalid in non-cache mode");

    if (!Rast3d_cache_lock(map->cache, tileIndex)) {
        Rast3d_error("Rast3d_lock_tile: error in Rast3d_cache_lock");
        return 0;
    }

    return 1;
}

/*---------------------------------------------------------------------------*/

/*!
 * \brief
 *
 *  Unlocks tile with <em>tileIndex</em>.
 *
 *  \param map
 *  \param tileIndex
 *  \return 1 ... if successful,
 *          0 ... otherwise.
 */

int Rast3d_unlock_tile(RASTER3D_Map *map, int tileIndex)
{
    if (!map->useCache)
        Rast3d_fatal_error(
            "Rast3d_unlock_tile: function invalid in non-cache mode");

    if (!Rast3d_cache_unlock(map->cache, tileIndex)) {
        Rast3d_error("Rast3d_unlock_tile: error in Rast3d_cache_unlock");
        return 0;
    }

    return 1;
}

/*---------------------------------------------------------------------------*/

/*!
 * \brief
 *
 * Unlocks every tile in cache of <em>map</em>.
 *
 *  \param map
 *  \return 1 ... if successful,
 *          0 ... otherwise.
 */

int Rast3d_unlock_all(RASTER3D_Map *map)
{
    if (!map->useCache)
        Rast3d_fatal_error(
            "Rast3d_unlock_all: function invalid in non-cache mode");

    if (!Rast3d_cache_unlock_all(map->cache)) {
        Rast3d_error("Rast3d_unlock_all: error in Rast3d_cache_unlock_all");
        return 0;
    }

    return 1;
}

/*---------------------------------------------------------------------------*/

/*!
 * \brief
 *
 * Turns autolock mode on.
 *
 *  \param map
 *  \return void
 */

void Rast3d_autolock_on(RASTER3D_Map *map)
{
    if (!map->useCache)
        Rast3d_fatal_error(
            "Rast3d_autoLockOn: function invalid in non-cache mode");

    Rast3d_cache_autolock_on(map->cache);
}

/*---------------------------------------------------------------------------*/

/*!
 * \brief
 *
 * Turns autolock mode Off.
 *
 *  \param map
 *  \return void
 */

void Rast3d_autolock_off(RASTER3D_Map *map)
{
    if (!map->useCache)
        Rast3d_fatal_error(
            "Rast3d_autoLockOff: function invalid in non-cache mode");

    Rast3d_cache_autolock_off(map->cache);
}

/*---------------------------------------------------------------------------*/

/*!
 * \brief
 *
 * Sets the minimum
 * number of unlocked tiles to <em>minUnlocked</em>.  This function should be
 * used in combination with <tt>Rast3d_unlock_all ()</tt> in order to avoid
 * situations where the new minimum is larger than the actual number of unlocked
 * tiles. <em>minUnlocked</em> must be one of RASTER3D_USE_CACHE_X,
 * RASTER3D_USE_CACHE_Y, RASTER3D_USE_CACHE_Z, RASTER3D_USE_CACHE_XY,
 * RASTER3D_USE_CACHE_XZ, RASTER3D_USE_CACHE_YZ, RASTER3D_USE_CACHE_XYZ, the
 * result of Rast3d_cache_size_encode() (cf.{g3d:G3d.cacheSizeEncode}), or any
 * positive integer which explicitly specifies the number of tiles.
 *
 *  \param map
 *  \param minUnlocked
 *  \return void
 */

void Rast3d_min_unlocked(RASTER3D_Map *map, int minUnlocked)
{
    if (!map->useCache)
        Rast3d_fatal_error(
            "Rast3d_autoLockOff: function invalid in non-cache mode");

    Rast3d_cache_set_min_unlock(map->cache,
                                Rast3d__compute_cache_size(map, minUnlocked));
}

/*---------------------------------------------------------------------------*/

/*!
 * \brief
 *
 *  Starts a new cycle.
 *
 *  \param map
 *  \return 1 ... if successful,
 *          0 ... otherwise.
 */

int Rast3d_begin_cycle(RASTER3D_Map *map)
{
    if (!Rast3d_unlock_all(map)) {
        Rast3d_fatal_error("Rast3d_begin_cycle: error in Rast3d_unlock_all");
        return 0;
    }

    Rast3d_autolock_on(map);
    return 1;
}

/*---------------------------------------------------------------------------*/

/*!
 * \brief
 *
 * Ends a cycle.
 *
 *  \param map
 *  \return 1 ... if successful,
 *          0 ... otherwise.
 */

int Rast3d_end_cycle(RASTER3D_Map *map)
{
    Rast3d_autolock_off(map);
    return 1;
}