/*
 * Simple I/O abstraction and context handling layer
 * Programmed and designed by Matti 'ccr' Hamalainen
 * (C) Copyright 2012-2022 Tecnic Software productions (TNSP)
 *
 * Please read file 'COPYING' for information on license and distribution.
 */
/// @file
/// @brief Simple I/O abstraction and context handling layer
#ifndef TH_IOCTX_H
#define TH_IOCTX_H

#include "th_util.h"
#include <time.h>


#ifdef __cplusplus
extern "C" {
#endif


//
// Typedefs and structures
//
struct th_ioctx_t;
struct th_ioctx_ops_t;


/** I/O context structure
 */
typedef struct th_ioctx_t
{
    char *filename;     ///< Context filename, if any. May be NULL.
    bool fn_allocated;  ///< true if filename is allocated, false if "const"
    char *mode;         ///< Context's stdio open "mode", may also be NULL.
    bool md_allocated;  ///< true if mode string is allocated, false if "const"
    bool ctx_allocated; ///< true if this structure has been allocated

    void *data;         ///< Internal data
    time_t atime;       ///< Last access time
    int64_t size;       ///< Size in bytes
    int status;         ///< Status
    size_t line;        ///< Line number

    // Mem data
    size_t maxSize;     ///< Maximum size (0 = no limit)
    size_t memSize;     ///< Current size of data "used"
    size_t memAlloc;    ///< Amount actually allocated for data (>= memSize)
    size_t minAlloc;    ///< Minimum allocation increase (0 = default)
    off_t  memOffset;   ///< Current offset in data
    uint8_t *memData;   ///< Pointer to data
    bool   memFree;     ///< true = free the allocated memory on thfclose(), false = no
    bool   memWrite;    ///< true = memory can be written to / expanded etc. false = no

    // Message functions
    void (*error)(struct th_ioctx_t *ctx, const int err, const char *msg);
    void (*msg)(struct th_ioctx_t *ctx, const int level, const char *msg);

    const struct th_ioctx_ops_t *fops; ///< Pointer to I/O ops struct to be used with this context
} th_ioctx_t;


typedef struct th_ioctx_ops_t
{
    char    *name;                       ///< Name of this I/O ops definition

    int     (*fopen)(th_ioctx_t *ctx);
    void    (*fclose)(th_ioctx_t *ctx);

    int     (*freset)(th_ioctx_t *ctx);
    int     (*ferror)(th_ioctx_t *ctx);
    int     (*fseek)(th_ioctx_t *ctx, const off_t, const int whence);
    off_t   (*fsize)(th_ioctx_t *ctx);
    off_t   (*ftell)(th_ioctx_t *ctx);
    bool    (*feof)(th_ioctx_t *ctx);
    int     (*fgetc)(th_ioctx_t *ctx);
    int     (*fputc)(int, th_ioctx_t *ctx);
    size_t  (*fread)(void *ptr, const size_t, const size_t, th_ioctx_t *ctx);
    size_t  (*fwrite)(const void *ptr, const size_t, const size_t, th_ioctx_t *ctx);

    char *  (*fgets)(char *str, int size, th_ioctx_t *ctx);
    int     (*fputs)(const char *str, th_ioctx_t *ctx);
    int     (*vfprintf)(th_ioctx_t *ctx, const char *fmt, va_list ap);

} th_ioctx_ops_t;


//
// Some basic iops
//
extern const th_ioctx_ops_t th_stdio_io_ops, th_mem_io_ops;



//
// I/O context management functions
//
th_ioctx_t *   th_io_new(const th_ioctx_ops_t *fops, const char *filename, const char *mode);
int          th_io_fopen(th_ioctx_t **pctx, const th_ioctx_ops_t *fops, const char *filename, const char *mode);
int          th_io_reopen(th_ioctx_t *ctx, const char *mode);
void         th_io_close(th_ioctx_t *ctx);

void         th_io_init_stdio(th_ioctx_t *ctx, FILE *fh);

bool         th_io_set_handlers(th_ioctx_t *ctx,
             void (*error)(th_ioctx_t *, const int, const char *msg),
             void (*msg)(th_ioctx_t *, const int, const char *msg));

int          th_io_error_v(th_ioctx_t *ctx, const int err, const char *fmt, va_list ap);
void         th_io_msg_v(th_ioctx_t *ctx, const int level, const char *fmt, va_list ap);
int          th_io_error(th_ioctx_t *ctx, const int err, const char *fmt, ...)
             TH_ATTR_PRINTF_FMT(3, 4);
void         th_io_msg(th_ioctx_t *ctx, const int level, const char *fmt, ...)
             TH_ATTR_PRINTF_FMT(3, 4);


//
// Basic I/O operations
//
int          thfopen(th_ioctx_t *ctx);
void         thfclose(th_ioctx_t *ctx);

int          thfreset(th_ioctx_t *ctx);
int          thferror(th_ioctx_t *ctx);
int          thfseek(th_ioctx_t *ctx, const off_t, const int whence);
off_t        thfsize(th_ioctx_t *ctx);
off_t        thftell(th_ioctx_t *ctx);
bool         thfeof(th_ioctx_t *ctx);
int          thfgetc(th_ioctx_t *ctx);
int          thfputc(int ch, th_ioctx_t *ctx);
size_t       thfread(void *ptr, const size_t, const size_t, th_ioctx_t *ctx);
size_t       thfwrite(const void *, const size_t, const size_t, th_ioctx_t *ctx);
char *       thfgets(char *ptr, int size, th_ioctx_t *ctx);
int          thfputs(const char *ptr, th_ioctx_t *ctx);
int          thvfprintf(th_ioctx_t *ctx, const char *fmt, va_list ap);
int          thfprintf(th_ioctx_t *ctx, const char *fmt, ...)
             TH_ATTR_PRINTF_FMT(2, 3);

bool         thfread_str(th_ioctx_t *ctx, void *ptr, const size_t len);
bool         thfread_u8(th_ioctx_t *ctx, uint8_t *);
bool         thfwrite_str(th_ioctx_t *ctx, const void *ptr, const size_t len);
bool         thfwrite_u8(th_ioctx_t *ctx, const uint8_t);


//
// Endian-handling file read/write routines
//
bool         thfwrite_ne16(th_ioctx_t *ctx, const uint16_t v);
bool         thfwrite_ne32(th_ioctx_t *ctx, const uint32_t v);
bool         thfwrite_ne64(th_ioctx_t *ctx, const uint64_t v);
bool         thfread_ne16(th_ioctx_t *ctx, uint16_t *v);
bool         thfread_ne32(th_ioctx_t *ctx, uint32_t *v);
bool         thfread_ne64(th_ioctx_t *ctx, uint64_t *v);

bool         thfwrite_le16(th_ioctx_t *ctx, const uint16_t v);
bool         thfwrite_le32(th_ioctx_t *ctx, const uint32_t v);
bool         thfwrite_le64(th_ioctx_t *ctx, const uint64_t v);
bool         thfread_le16(th_ioctx_t *ctx, uint16_t *v);
bool         thfread_le32(th_ioctx_t *ctx, uint32_t *v);
bool         thfread_le64(th_ioctx_t *ctx, uint64_t *v);

bool         thfwrite_be16(th_ioctx_t *ctx, const uint16_t v);
bool         thfwrite_be32(th_ioctx_t *ctx, const uint32_t v);
bool         thfwrite_be64(th_ioctx_t *ctx, const uint64_t v);
bool         thfread_be16(th_ioctx_t *ctx, uint16_t *v);
bool         thfread_be32(th_ioctx_t *ctx, uint32_t *v);
bool         thfread_be64(th_ioctx_t *ctx, uint64_t *v);


#ifdef __cplusplus
}
#endif
#endif // TH_IOCTX_H