/*
 * Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland
 * Modifications (C) 2019 Paolo Jovon <paolo.jovon@gmail.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/**
 * @file picoos.h
 *
 * Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland
 * All rights reserved.
 *
 * History:
 * - 2009-04-20 -- initial version
 * - 2019-08-28 -- added picoos_uintptr_t
 *
 */
/**
 * @addtogroup picoos

 * <b> Operating system generalization module </b>\n
 *
*/

#ifndef PICOOS_H_
#define PICOOS_H_

#include "picodefs.h"
#include "picopal.h"

#ifdef __cplusplus
extern "C" {
#endif
#if 0
}
#endif


/* some "switch"  used in picopal and in picocep ... */
#define PICOOS_DIV_USE_INV PICOPAL_DIV_USE_INV

/* *************************************************/
/* types                                           */
/* *************************************************/

typedef picopal_uint8   picoos_uint8;
typedef picopal_uint16  picoos_uint16;
typedef picopal_uint32  picoos_uint32;

typedef picopal_int8    picoos_int8;
typedef picopal_int16   picoos_int16;
typedef picopal_int32   picoos_int32;

typedef picopal_double  picoos_double;
typedef picopal_single  picoos_single;

typedef picopal_char    picoos_char;
typedef picopal_uchar   picoos_uchar;

typedef picopal_uint8   picoos_bool;

typedef picopal_objsize_t picoos_objsize_t;
typedef picopal_ptrdiff_t picoos_ptrdiff_t;
typedef picopal_uintptr_t picoos_uintptr_t;

/* *************************************************/
/* functions                                       */
/* *************************************************/


picoos_int32 picoos_atoi(const picoos_char *);
picoos_int8 picoos_strcmp(const picoos_char *, const picoos_char *);
picoos_int8 picoos_strncmp(const picoos_char *a, const picoos_char *b, picoos_objsize_t siz);
picoos_uint32 picoos_strlen(const picoos_char *);
picoos_char * picoos_strchr(const picoos_char *, picoos_char);
picoos_char *picoos_strstr(const picoos_char *s, const picoos_char *substr);
picoos_int16 picoos_slprintf(picoos_char * b, picoos_uint32 bsize, const picoos_char *f, ...);
picoos_char * picoos_strcpy(picoos_char *, const picoos_char *);
picoos_char * picoos_strcat(picoos_char *, const picoos_char *);

/* copies 'length' bytes from 'src' to 'dest'. (regions may be overlapping) no error checks! */
void * picoos_mem_copy(const void * src, void * dst,  picoos_objsize_t length);

/* safe versions */
picoos_objsize_t picoos_strlcpy(picoos_char *dst, const picoos_char *src, picoos_objsize_t siz);
void * picoos_mem_set(void * dest, picoos_uint8 byte_val, picoos_objsize_t length);

picoos_double picoos_cos(const picoos_double cos_arg);
picoos_double picoos_sin(const picoos_double sin_arg);
picoos_double picoos_fabs(const picoos_double fabs_arg);

picoos_double picoos_quick_exp(const picoos_double y);


void picoos_get_sep_part_str (picoos_char string[], picoos_int32 stringlen, picoos_int32 * ind, picoos_char sepCh, picoos_char part[], picoos_int32 maxsize, picoos_uint8 * done);
pico_status_t picoos_string_to_uint32 (picoos_char str[], picoos_uint32 * res);
pico_status_t picoos_string_to_int32 (picoos_char str[], picoos_int32 * res);

/* *****************************************************************/
/* "Common"                                                        */
/* *****************************************************************/
/* picoos_common is a collection of basic functionalities that must be globally accesible from every "big" function.
 * It includes pointers to the MemoryManasger, ExceptionManager and a list of open files. */

typedef struct memory_manager * picoos_MemoryManager;
typedef struct picoos_exception_manager * picoos_ExceptionManager;
typedef struct picoos_file * picoos_File;


/**  object   : Common
 *   shortcut : common
 *
 */
typedef struct picoos_common * picoos_Common;

/* the picoos_common structure itself is exported so no access functions are needed. Handle with care! (might be changed later) */
typedef struct picoos_common {
    picoos_ExceptionManager em;
    picoos_MemoryManager mm;
    picoos_File fileList;
} picoos_common_t;

picoos_Common picoos_newCommon(picoos_MemoryManager mm);

void picoos_disposeCommon(picoos_MemoryManager mm, picoos_Common * this);


/* *****************************************************************/
/* Memory Management                                               */
/* *****************************************************************/

typedef picoos_char * byte_ptr_t;

#define PICOOS_ALIGN_SIZE 8



void * picoos_raw_malloc(byte_ptr_t raw_mem,
        picoos_objsize_t raw_mem_size, picoos_objsize_t alloc_size,
        byte_ptr_t * rest_mem, picoos_objsize_t * rest_mem_size);

/**
 * Creates a new memory manager object for the specified raw memory
 * block. 'enableProtMem' enables or disables memory protection
 * functionality; if disabled, picoos_protectMem() has no effect.
 */
picoos_MemoryManager picoos_newMemoryManager(
        void *raw_memory,
        picoos_objsize_t size,
        picoos_bool enableMemProt);



void picoos_disposeMemoryManager(picoos_MemoryManager * mm);


void * picoos_allocate(picoos_MemoryManager this, picoos_objsize_t byteSize);
void picoos_deallocate(picoos_MemoryManager this, void * * adr);

/* the following memory manager routines are for testing and
   debugging purposes */

/**
 * Same as picoos_allocate, but write access to the memory block may be
 * prohibited by a subsequent call to picoos_protectMem().
 */
void *picoos_allocProtMem(picoos_MemoryManager mm, picoos_objsize_t byteSize);

/**
 * Releases a memory block previously allocated by picoos_allocProtMem().
 */
void picoos_deallocProtMem(picoos_MemoryManager mm, void **addr);

/**
 * Enables or disables write protection of a memory block previously
 * allocated by picoos_allocProtMem(). If write protection is enabled,
 * any subsequent write access will cause a segmentation fault.
 */
void picoos_protectMem(
        picoos_MemoryManager mm,
        void *addr,
        picoos_objsize_t len,
        picoos_bool enable);

void picoos_getMemUsage(
        picoos_MemoryManager this,
        picoos_bool resetIncremental,
        picoos_int32 *usedBytes,
        picoos_int32 *incrUsedBytes,
        picoos_int32 *maxUsedBytes);

void picoos_showMemUsage(
        picoos_MemoryManager this,
        picoos_bool incremental,
        picoos_bool resetIncremental);

/* *****************************************************************/
/* Exception Management                                                */
/* *****************************************************************/
/**  object   : ExceptionManager
 *   shortcut : em
 *
 */


#define PICOOS_MAX_EXC_MSG_LEN 512
#define PICOOS_MAX_WARN_MSG_LEN 64
#define PICOOS_MAX_NUM_WARNINGS 8

void picoos_setErrorMsg(picoos_char * dst, picoos_objsize_t siz,
        picoos_int16 code, picoos_char * base, const picoos_char *fmt, ...);


picoos_ExceptionManager picoos_newExceptionManager(picoos_MemoryManager mm);

void picoos_disposeExceptionManager(picoos_MemoryManager mm,
        picoos_ExceptionManager * this);


void picoos_emReset(picoos_ExceptionManager this);

/* For convenience, this function returns the resulting exception code of 'this'
 * (as would be returned by emGetExceptionCode).
 * The return value therefore is NOT the status of raising
 * the error! */
pico_status_t picoos_emRaiseException(picoos_ExceptionManager this,
        pico_status_t exceptionCode, picoos_char * baseMessage, picoos_char * fmt, ...);

pico_status_t picoos_emGetExceptionCode(picoos_ExceptionManager this);

void picoos_emGetExceptionMessage(picoos_ExceptionManager this, picoos_char * msg, picoos_uint16 maxsize);

void picoos_emRaiseWarning(picoos_ExceptionManager this,
        pico_status_t warningCode, picoos_char * baseMessage, picoos_char * fmt, ...);

picoos_uint8 picoos_emGetNumOfWarnings(picoos_ExceptionManager this);

pico_status_t picoos_emGetWarningCode(picoos_ExceptionManager this, picoos_uint8 warnNum);

void picoos_emGetWarningMessage(picoos_ExceptionManager this, picoos_uint8 warnNum, picoos_char * msg, picoos_uint16 maxsize);




/* *****************************************************************/
/* File Access                                                     */
/* *****************************************************************/

#define picoos_MaxFileNameLen 512
#define picoos_MaxKeyLen 512
#define picoos_MaxPathLen 512
#define picoos_MaxPathListLen 2048

typedef picoos_char picoos_Key[picoos_MaxKeyLen];
typedef picoos_char picoos_FileName[picoos_MaxFileNameLen];
typedef picoos_char picoos_Path[picoos_MaxPathLen];
typedef picoos_char picoos_PathList[picoos_MaxPathListLen];


/* ***** Sequential binary file access ******/

/* Remark: 'ReadByte', 'ReadBytes' and 'ReadVar' may be mixed;
 'WriteByte', 'WriteBytes' and 'WriteVar' may be mixed. */

/* Open existing binary file for read access. */
picoos_uint8 picoos_OpenBinary(picoos_Common g, picoos_File * f, picoos_char name[]);


/* Read next byte from file 'f'. */
picoos_uint8  picoos_ReadByte(picoos_File f, picoos_uint8 * by);

/* Read next 'len' bytes from 'f' into 'bytes'; 'len' returns the
 number of bytes actually read (may be smaller than requested
 length if 'bytes' is too small to hold all bytes or at end of file).
 Remark: 'bytes' is compabtible with any variable of any size. */
picoos_uint8  picoos_ReadBytes(picoos_File f, picoos_uint8 bytes[],
        picoos_uint32 * len);


/* Create new binary file.
 If 'key' is not empty, the file is encrypted with 'key'. */
picoos_uint8 picoos_CreateBinary(picoos_Common g, picoos_File * f, picoos_char name[]);

picoos_uint8  picoos_WriteByte(picoos_File f, picoos_char by);

/* Writes 'len' bytes from 'bytes' onto file 'f'; 'len' returns
 the number of bytes actually written. */
picoos_uint8  picoos_WriteBytes(picoos_File f, const picoos_char bytes[],
        picoos_int32 * len);


/* Close previously opened binary file. */
picoos_uint8 picoos_CloseBinary(picoos_Common g, picoos_File * f);






pico_status_t picoos_read_le_int16 (picoos_File file, picoos_int16 * val);
pico_status_t picoos_read_le_uint16 (picoos_File file, picoos_uint16 * val);
pico_status_t picoos_read_le_uint32 (picoos_File file, picoos_uint32 * val);


pico_status_t picoos_read_pi_uint16 (picoos_File file, picoos_uint16 * val);
pico_status_t picoos_read_pi_uint32 (picoos_File file, picoos_uint32 * val);

pico_status_t picoos_write_le_uint16 (picoos_File file, picoos_uint16 val);
pico_status_t picoos_write_le_uint32 (picoos_File file, picoos_uint32 val);

/*
pico_status_t picoos_write_pi_uint32 (picoos_File file, const picoos_uint32 val);

pico_status_t picoos_write_pi_uint16 (picoos_File file, const picoos_uint16 val);
*/


/* **************************************************************************************/
/* *** general file routines *****/

/* Returns whether end of file was encountered in previous
 read operation. */
picoos_bool picoos_Eof(picoos_File f);

/*  sets the file pointer to
 'pos' bytes from beginning (first byte = byte 0). This
 routine should only be used for binary files. */
picoos_bool  picoos_SetPos(picoos_File f, picoos_int32 pos);

/* Get position from file 'f'. */
picoos_bool picoos_GetPos(picoos_File f, picoos_uint32 * pos);

/* Returns the length of the file in bytes. */
picoos_bool picoos_FileLength(picoos_File f, picoos_uint32 * len);

/* Return full name of file 'f'. */
picoos_bool picoos_Name(picoos_File f, picoos_char name[], picoos_uint32 maxsize);

/* Returns whether file 'name' exists or not. */
picoos_bool picoos_FileExists(picoos_Common g, picoos_char name[] /*, picoos_char ckey[] */);

/* Delete a file. */
picoos_bool  picoos_Delete(picoos_char name[]);

/* Rename a file. */
picoos_bool  picoos_Rename(picoos_char oldName[], picoos_char newName[]);


/* *****************************************************************/
/* Sampled Data Files                                                    */
/* *****************************************************************/

#define SAMPLE_FREQ_16KHZ (picoos_uint32) 16000

typedef enum {
    FILE_TYPE_WAV,
    FILE_TYPE_AU,
    FILE_TYPE_RAW,
    FILE_TYPE_OTHER
} wave_file_type_t;

typedef enum {
    FORMAT_TAG_LIN = 1, /**< linear 16-bit encoding */
    FORMAT_TAG_ALAW = 6, /**< a-law encoding, 8 bit */
    FORMAT_TAG_ULAW = 7 /**< u-law encoding, 8 bit */
    /* there are many more */
} wave_format_tag_t;


typedef enum {
    /* values corresponding RIFF wFormatTag */
    PICOOS_ENC_LIN = FORMAT_TAG_LIN,  /**< linear 16-bit encoding; standard */
    PICOOS_ENC_ALAW = FORMAT_TAG_ALAW, /**< a-law encoding, 8 bit */
    PICOOS_ENC_ULAW = FORMAT_TAG_ULAW, /**< u-law encoding, 8 bit */
    /* values outside RIFF wFormatTag values (above 4100) */
    PICOOS_ENC_OTHER = 5000  /**< other; (treated as raw) */
    }  picoos_encoding_t;

typedef struct picoos_sd_file * picoos_SDFile;

/* SDFile input functions */

/* orig. comment from SDInOut.def
             Opens sampled data file 'fileName' for input and returns
             the encoding 'enc' of the file, sampling rate 'sf',
             nr of samples 'nrSamples', and a handle to the opened file
             in 'sdFile'.

             If 'fileName' is empty, the input is taken from the direct
             acoustic input using the sampling rate specified by
             "SetRawDefaults". In this case, 'encoding' returns 'EncLin',
             and 'nrSamples' returns 0.

             The file format is taken from the file name extension:
                ".wav"           --> wav file
                ".au"            --> au file
                other extensions --> headerless files

             For wav and au files, the sampling rate and encoding are taken
             from the file header and returned in 'sf' and 'enc'. For
             headerless files, 'sf' and 'enc' are taken from the
             most recently set default values (procedure SetRawDefaults).

             'done' returns whether the sampled data file was successfully
             opened. */
extern picoos_bool picoos_sdfOpenIn (picoos_Common g, picoos_SDFile * sdFile, picoos_char fileName[], picoos_uint32 * sf, picoos_encoding_t * enc, picoos_uint32 * nrSamples);


extern picoos_bool picoos_sdfGetSamples (picoos_SDFile sdFile, picoos_uint32 start, picoos_uint32 * nrSamples, picoos_int16 samples[]);


extern picoos_bool picoos_sdfCloseIn (picoos_Common g, picoos_SDFile * sdFile);


/* SDFile output functions*/

extern picoos_bool picoos_sdfOpenOut (picoos_Common g, picoos_SDFile * sdFile, picoos_char fileName[], int sf, picoos_encoding_t enc);


extern picoos_bool picoos_sdfPutSamples (picoos_SDFile sdFile, picoos_uint32 nrSamples, picoos_int16 samples[]);

/*
extern picoos_bool picoos_AbortOutput (picoos_SDFile sdFile);


extern picoos_bool picoos_ResumeOutput (picoos_SDFile sdFile);


extern picoos_bool picoos_FlushOutput (picoos_SDFile sdFile);
*/

extern picoos_bool picoos_sdfCloseOut (picoos_Common g, picoos_SDFile * sdFile);


/* *****************************************************************/
/* File Headers                                                    */
/* *****************************************************************/

#define PICOOS_MAX_FIELD_STRING_LEN 32 /* including terminating char */

#define PICOOS_MAX_NUM_HEADER_FIELDS 10
#define PICOOS_NUM_BASIC_HEADER_FIELDS 5

#define PICOOS_HEADER_NAME 0
#define PICOOS_HEADER_VERSION 1
#define PICOOS_HEADER_DATE 2
#define PICOOS_HEADER_TIME 3
#define PICOOS_HEADER_CONTENT_TYPE 4

#define PICOOS_MAX_HEADER_STRING_LEN (PICOOS_MAX_NUM_HEADER_FIELDS * (2 * PICOOS_MAX_FIELD_STRING_LEN))

typedef picoos_char picoos_field_string_t[PICOOS_MAX_FIELD_STRING_LEN];

typedef picoos_char picoos_header_string_t[PICOOS_MAX_HEADER_STRING_LEN];

typedef enum {PICOOS_FIELD_IGNORE, PICOOS_FIELD_EQUAL, PICOOS_FIELD_COMPAT} picoos_compare_op_t;

/* private */
typedef struct picoos_file_header_field {
    picoos_field_string_t key;
    picoos_field_string_t value;
    picoos_compare_op_t op;
} picoos_file_header_field_t;

/* public */
typedef struct picoos_file_header * picoos_FileHeader;
typedef struct picoos_file_header {
    picoos_uint8 numFields;
    picoos_file_header_field_t  field[PICOOS_MAX_NUM_HEADER_FIELDS];
} picoos_file_header_t;


pico_status_t picoos_clearHeader(picoos_FileHeader header);

pico_status_t picoos_setHeaderField(picoos_FileHeader header, picoos_uint8 index, picoos_char * key, picoos_char * value, picoos_compare_op_t op);

/* caller has to make sure allocated space at key and value are large enough to hold a picoos_field_string */
pico_status_t picoos_getHeaderField(picoos_FileHeader header, picoos_uint8 index, picoos_field_string_t key, picoos_field_string_t value, picoos_compare_op_t * op);

/* caller has to make sure allocated space at str is large enough to hold the header in question */
/*
pico_status_t picoos_hdrToString(picoos_FileHeader header, picoos_header_string_t str);
*/

pico_status_t picoos_hdrParseHeader(picoos_FileHeader header, picoos_header_string_t str);

pico_status_t picoos_getSVOXHeaderString(picoos_char * str, picoos_uint8 * len, picoos_uint32 maxlen);

pico_status_t picoos_readPicoHeader(picoos_File f, picoos_uint32 * headerlen);



/* *****************************************************************/
/* String search and compare operations                            */
/* *****************************************************************/


picoos_uint8 picoos_has_extension(const picoos_char *str, const picoos_char *suf);

/* *****************************************************************/
/* String/Number Manipulations  (might be moved to picopal)          */
/* *****************************************************************/

pico_status_t picoos_string_to_int32(picoos_char str[],
        picoos_int32 * res);

pico_status_t picoos_string_to_uint32(picoos_char str[],
        picoos_uint32 * res);

/* 'stringlen' is the part of input string to be considered, possibly not containing NULLC (e.g. result of strlen).
 *  'maxsize' is the maximal size of 'part' including a byte for the terminating NULLC! */
void picoos_get_sep_part_str(picoos_char string[],
        picoos_int32 stringlen, picoos_int32 * ind, picoos_char sepCh,
        picoos_char part[], picoos_int32 maxsize, picoos_uint8 * done);

/* searches for the first contiguous string of printable characters (> ' ') inside fromStr, possibly skipping
 * chars <= ' ') and returns it in toStr.
 * fromStr is assumed to be NULLC terminated and toStr is forced to be NULLC terminated within maxsize.
 * The search is started at *pos inside fromStr and at return, *pos is the position within fromStr after the
 * found string, or the position after the end of fromStr, if no string was found.
 * the function returns TRUE if a string was found and fitted toStr, or FALSE otherwise. */
picoos_uint8 picoos_get_str (picoos_char * fromStr, picoos_uint32 * pos, picoos_char * toStr, picoos_objsize_t maxsize);


pico_status_t picoos_read_mem_pi_uint16 (picoos_uint8 * data, picoos_uint32 * pos, picoos_uint16 * val);

pico_status_t picoos_read_mem_pi_uint32 (picoos_uint8 * data, picoos_uint32 * pos, picoos_uint32 * val);

pico_status_t picoos_write_mem_pi_uint16 (picoos_uint8 * data, picoos_uint32 * pos, picoos_uint16 val);


/* *****************************************************************/
/* timer function          */
/* *****************************************************************/

void picoos_get_timer(picopal_uint32 * sec, picopal_uint32 * usec);

#ifdef __cplusplus
}
#endif


#endif /*PICOOS_H_*/