/*****************************************************************************/
/*  LibreDWG - free implementation of the DWG file format                    */
/*                                                                           */
/*  Copyright (C) 2009-2025 Free Software Foundation, Inc.                   */
/*                                                                           */
/*  This library is free software, licensed under the terms of the GNU       */
/*  General Public License as published by the Free Software Foundation,     */
/*  either version 3 of the License, or (at your option) any later version.  */
/*  You should have received a copy of the GNU General Public License        */
/*  along with this program.  If not, see <http://www.gnu.org/licenses/>.    */
/*****************************************************************************/

/*
 * bits.c: low level read and write function prototypes
 * written by Felipe Castro
 * modified by Felipe Corrêa da Silva Sances
 * modified by Rodrigo Rodrigues da Silva
 * modified by Reini Urban
 */

/**
 The position of bits within bytes is numerically ordered as depicted below:

\code
 position: 01234567 01234567 01234567 ...
 bits:     76543210 76543210 76543210 ...
           \______/ \______/ \______/
            byte 1   byte 2   byte 3  ...
\endcode
(i.e. little endian)
 */

#ifndef BITS_H
#define BITS_H

#include "config.h"
#ifdef HAVE_WCHAR_H
// cross-compilation problem:
// /usr/lib/gcc/arm-linux-gnueabi/9/include-fixed/limits.h defines it as 1
#  if defined(MB_LEN_MAX) && MB_LEN_MAX != 16 && MB_LEN_MAX != 32
#    undef MB_LEN_MAX
#    define MB_LEN_MAX 16
#  endif
#  include <wchar.h>
#endif
#include <stdio.h>
#include <string.h>
#include <stddef.h>
#include <stdbool.h>
#include "common.h"
#include "dwg.h"

// DWG size limitations, invalid sizes and offsets
#if SIZEOF_SIZE_T == 8
#  define MAX_MEM_ALLOC 0x10000000000
#else
#  define MAX_MEM_ALLOC 0xF0000000
#endif

// avoid double linkage on windows with unit-testing
#if defined(BITS_TEST_C) || defined(DECODE_TEST_C) || defined(DXF_TEST_C)
#  undef EXPORT
#  define EXPORT
#endif

/**
 Structure for DWG-files raw data streams.
 */
typedef struct _bit_chain
{
  unsigned char *chain;
  size_t size;
  size_t byte;
  unsigned char bit;
  unsigned char opts; // from dwg->opts, see DWG_OPTS_*
  Dwg_Version_Type version;
  Dwg_Version_Type from_version;
  FILE *fh;
  BITCODE_RS codepage;
} Bit_Chain;

#define EMPTY_CHAIN(size)                                                     \
  {                                                                           \
    NULL, size, 0UL, 0, 0, R_INVALID, R_INVALID, NULL, 0                      \
  }

// only if from r2007+ DWG. not JSON, DXF (FIXME TABLE.name).
// add API converts to TU
#define IS_FROM_TU(dat)                                                       \
  ((dat->from_version >= R_2007) && !(dat->opts & DWG_OPTS_IN))
#define IS_FROM_TU_DWG(dwg)                                                   \
  ((dwg->header.from_version >= R_2007) && !(dwg->opts & DWG_OPTS_IN))
#define TU_to_int(b) le16toh (((uint16_t)b[1] << 8) + b[0])

/* Functions for raw data manipulations.
 */
void bit_advance_position (Bit_Chain *dat, long advance);
size_t bit_position (Bit_Chain *dat);
void bit_set_position (Bit_Chain *dat, size_t bitpos);
void bit_reset_chain (Bit_Chain *dat);

BITCODE_B bit_read_B (Bit_Chain *dat);
void bit_write_B (Bit_Chain *dat, unsigned char value);

BITCODE_BB bit_read_BB (Bit_Chain *dat);
void bit_write_BB (Bit_Chain *dat, unsigned char value);

BITCODE_4BITS bit_read_4BITS (Bit_Chain *dat);
void bit_write_4BITS (Bit_Chain *dat, unsigned char value);

BITCODE_RC bit_read_RC (Bit_Chain *dat);
void bit_write_RC (Bit_Chain *dat, unsigned char value);

BITCODE_RS bit_read_RS (Bit_Chain *dat);
void bit_write_RS (Bit_Chain *dat, BITCODE_RS value);
BITCODE_BS bit_read_RS_BE (Bit_Chain *dat);
void bit_write_RS_BE (Bit_Chain *dat, BITCODE_BS value);

BITCODE_RL bit_read_RL (Bit_Chain *dat);
BITCODE_RL bit_read_RL_BE (Bit_Chain *dat);
void bit_write_RL (Bit_Chain *dat, BITCODE_RL value);
void bit_write_RL_BE (Bit_Chain *dat, BITCODE_RL value);

BITCODE_RLL bit_read_RLL (Bit_Chain *dat);
BITCODE_RLL bit_read_RLL_BE (Bit_Chain *dat);
#define bit_read_RLLd(dat) (BITCODE_RLLd) bit_read_RLL (dat)
void bit_write_RLL (Bit_Chain *dat, BITCODE_RLL value);
#define bit_write_RLLd(dat, value) bit_write_RLL (dat, (BITCODE_RLL)value)
void bit_write_RLL_BE (Bit_Chain *dat, BITCODE_RLL value);

BITCODE_RD bit_read_RD (Bit_Chain *dat);
void bit_write_RD (Bit_Chain *dat, BITCODE_RD value);

/* Functions for manipulating compacted data
 */
BITCODE_BS bit_read_BS (Bit_Chain *dat);
void bit_write_BS (Bit_Chain *dat, BITCODE_BS value);

BITCODE_BL bit_read_BL (Bit_Chain *dat);
void bit_write_BL (Bit_Chain *dat, BITCODE_BL value);
#define bit_read_BLd(dat) (BITCODE_BLd) bit_read_BL (dat)
void bit_write_BLd (Bit_Chain *dat, BITCODE_BLd value);

BITCODE_BS bit_read_BOT (Bit_Chain *dat);
void bit_write_BOT (Bit_Chain *dat, BITCODE_BS value);

BITCODE_BLL bit_read_BLL (Bit_Chain *dat);
void bit_write_BLL (Bit_Chain *dat, BITCODE_BLL value);

#if 0
BITCODE_3B bit_read_3B (Bit_Chain *dat);
void bit_write_3B (Bit_Chain *dat, unsigned char value);
BITCODE_BLL bit_read_3BLL (Bit_Chain *dat); /*unused but as documented*/
void bit_write_3BLL (Bit_Chain *dat, BITCODE_BLL value);
#endif

BITCODE_BD bit_read_BD (Bit_Chain *dat);
void bit_write_BD (Bit_Chain *dat, BITCODE_BD value);

BITCODE_MC bit_read_MC (Bit_Chain *dat);
void bit_write_MC (Bit_Chain *dat, BITCODE_MC value);

BITCODE_UMC bit_read_UMC (Bit_Chain *dat);
void bit_write_UMC (Bit_Chain *dat, BITCODE_UMC value);

BITCODE_MS bit_read_MS (Bit_Chain *dat);
void bit_write_MS (Bit_Chain *dat, BITCODE_MS value);

void bit_read_BE (Bit_Chain *restrict dat, double *restrict x,
                  double *restrict y, double *restrict z);
void bit_write_BE (Bit_Chain *dat, double x, double y, double z);
void normalize_BE (BITCODE_3BD ext);

BITCODE_DD bit_read_DD (Bit_Chain *dat, double default_value);
BITCODE_BB bit_write_DD (Bit_Chain *dat, double value, double default_value);
int bit_eq_DD (double value, double default_value);

BITCODE_BT bit_read_BT (Bit_Chain *dat);
void bit_write_BT (Bit_Chain *dat, double value);

int bit_read_H (Bit_Chain *restrict dat, Dwg_Handle *restrict handle);
void bit_write_H (Bit_Chain *restrict dat, Dwg_Handle *restrict handle);
void bit_H_to_dat (Bit_Chain *restrict dat, Dwg_Handle *restrict handle);

uint16_t bit_read_CRC (Bit_Chain *dat);

int bit_check_CRC (Bit_Chain *dat, size_t start_address, const uint16_t seed);
uint16_t bit_write_CRC (Bit_Chain *dat, size_t start_address,
                        const uint16_t seed);
// object-map only
uint16_t bit_write_CRC_BE (Bit_Chain *dat, size_t start_address,
                           const uint16_t seed);

uint16_t bit_calc_CRC (const uint16_t seed, unsigned char *adr, size_t len);
uint32_t bit_calc_CRC32 (const uint32_t seed, unsigned char *adr, size_t len);

int bit_read_fixed (Bit_Chain *restrict dat, BITCODE_RC *restrict dest,
                    size_t length);

/* read fixed-length ASCII string */
BITCODE_TF bit_read_TF (Bit_Chain *dat, size_t length) ATTRIBUTE_MALLOC;
BITCODE_TF bit_read_bits (Bit_Chain *dat, size_t bits) ATTRIBUTE_MALLOC;
void bit_write_bits (Bit_Chain *restrict dat, BITCODE_TF restrict bits,
                     size_t numbits);

void bit_write_TF (Bit_Chain *restrict dat, BITCODE_TF restrict chain,
                   size_t length);
/** Write fixed-length text from variable length string
    (possibly downgraded from shorter string).
 */
void bit_write_TFv (Bit_Chain *restrict dat, BITCODE_TF restrict chain,
                    size_t length);

/* read ASCII string, with length as BS */
BITCODE_TV bit_read_TV (Bit_Chain *restrict dat);

void bit_write_TV (Bit_Chain *restrict dat, BITCODE_TV restrict value);

/* read UCS-2 string, with length as BS */
BITCODE_TU bit_read_TU (Bit_Chain *restrict dat) ATTRIBUTE_MALLOC;
BITCODE_TU bit_read_TU_len (Bit_Chain *restrict dat,
                            unsigned int *lenp) ATTRIBUTE_MALLOC;
BITCODE_TU bit_read_TU_size (Bit_Chain *restrict dat,
                             unsigned int len) ATTRIBUTE_MALLOC;

/* read ASCII string, with length as RS */
BITCODE_T16 bit_read_T16 (Bit_Chain *restrict dat) ATTRIBUTE_MALLOC;
/* read UCS-2 string, with length as RS */
BITCODE_TU bit_read_TU16 (Bit_Chain *restrict dat) ATTRIBUTE_MALLOC;
/* read ASCII/UCS-2 string, with length as RL */
BITCODE_T32 bit_read_T32 (Bit_Chain *restrict dat) ATTRIBUTE_MALLOC;
/* read ASCII/UCS-4 string, with length as RL */
BITCODE_TU32 bit_read_TU32 (Bit_Chain *restrict dat) ATTRIBUTE_MALLOC;

void bit_write_TU (Bit_Chain *restrict dat, BITCODE_TU restrict value);
void bit_write_TU16 (Bit_Chain *restrict dat, BITCODE_TU restrict value);
void bit_write_T16 (Bit_Chain *restrict dat, BITCODE_T16 restrict value);
void bit_write_T32 (Bit_Chain *restrict dat, BITCODE_T32 restrict value);
void bit_write_TU32 (Bit_Chain *restrict dat, BITCODE_TU32 restrict value);

BITCODE_T bit_read_T (Bit_Chain *restrict dat) ATTRIBUTE_MALLOC;
void bit_write_T (Bit_Chain *restrict dat, BITCODE_T restrict chain);

/* Converts UCS-2 to ASCII (with \U+XXXX), returning a copy. */
EXPORT char *bit_embed_TU (BITCODE_TU restrict wstr) ATTRIBUTE_MALLOC;
EXPORT char *bit_embed_TU_size (BITCODE_TU restrict wstr,
                                const int len) ATTRIBUTE_MALLOC;

#ifdef HAVE_NATIVE_WCHAR2
#  define bit_wcs2len(wstr) wcslen (wstr)
#  ifdef HAVE_WCSNLEN
#    define bit_wcs2nlen(wstr, maxlen) wcsnlen (wstr, maxlen)
#  else
size_t bit_wcs2nlen (const BITCODE_TU restrict wstr, const size_t maxlen);
#  endif
#  define bit_wcs2cpy(dest, src) wcscpy (dest, src)
#  ifdef _WIN32
#    define bit_wcs2dup(src) _wcsdup (src)
#  else
#    define bit_wcs2dup(src) wcsdup (src)
#  endif
#  define bit_wcs2cmp(dest, src) wcscmp (s1, s2)
#else
/* length of UCS-2 string */
size_t bit_wcs2len (const BITCODE_TU restrict wstr);
/* bounded length of UCS-2 string. stops scanning at maxlen.
   Beware: might overflow to negative lengths */
size_t bit_wcs2nlen (const BITCODE_TU restrict wstr, const size_t maxlen);
BITCODE_TU bit_wcs2cpy (BITCODE_TU restrict dest,
                        const BITCODE_TU restrict src);
BITCODE_TU bit_wcs2dup (const BITCODE_TU restrict src);
int bit_wcs2cmp (BITCODE_TU restrict s1, const BITCODE_TU restrict s2);
#endif

#ifndef HAVE_STRNLEN
size_t bit_strnlen (const char *restrict str, const size_t maxlen);
#  define strnlen(str, maxlen) bit_strnlen (str, maxlen)
#endif

/* Convert UCS-2LE to UTF-8, returning a copy. */
EXPORT char *bit_convert_TU (const BITCODE_TU restrict wstr) ATTRIBUTE_MALLOC;
EXPORT char *bit_convert_TU_len (const BITCODE_TU restrict wstr,
                                 const size_t max_wchars) ATTRIBUTE_MALLOC;
EXPORT char *bit_TU_to_utf8_len (const BITCODE_TU restrict wstr,
                                 const int len) ATTRIBUTE_MALLOC;

/** Converts UTF-8 (dxf,json) to ASCII TV.
    \uxxxx or other unicode => \U+XXXX if not representable in this codepage.
    If cquoted unquotes \" to ", undo json_cquote(),
    Returns NULL if not enough room in dest. */
EXPORT char *bit_utf8_to_TV (char *restrict dest,
                             const unsigned char *restrict src,
                             const size_t destlen, const size_t srclen,
                             const unsigned cquoted,
                             const BITCODE_RS codepage);
/** converts old codepage'd strings to UTF-8.
    convert \U+XXXX or \MnXXXX also if representable.
    returns NULL on errors, or the unchanged src string, or a copy.
 */
EXPORT
/* NOTE: not ATTRIBUTE_MALLOC — function may return the input `src`
   pointer unchanged (codepage 0, CP_UTF8 without \U+/\M+ markers,
   iconv EINVAL fallback, empty src). Marking it malloc lets -O2 elide
   the `u8 != value` aliasing guard in VALUE_TV → free() of caller's
   stack buffer. */
char *bit_TV_to_utf8 (const char *restrict src, const BITCODE_RS codepage);

/** Converts UTF-8 to UCS-2. Returns a copy.
    Needed by dwg importers, writers (e.g. dxf2dwg)
    cquoted is needed by in_json, to unquote \"
 */
EXPORT BITCODE_TU bit_utf8_to_TU (char *restrict str,
                                  const unsigned cquoted) ATTRIBUTE_MALLOC;
// convert all \\U+XXXX and \\M+nXXXX sequences to UTF-8
const char *bit_u_expand (const char *src);

/* compare an ASCII/TU string to ASCII name */
int bit_eq_T (Bit_Chain *restrict dat, const BITCODE_T restrict str1,
              const char *restrict str2);
/* compare an ASCII/utf-8 string to a r2007+ name */
int bit_eq_TU (const char *str, BITCODE_TU restrict wstr);
/* check if the string (ascii or unicode) is empty */
int bit_empty_T (Bit_Chain *restrict dat, BITCODE_T restrict str);
BITCODE_T bit_set_T (Bit_Chain *restrict dat, const char *restrict src);

BITCODE_TIMEBLL bit_read_TIMEBLL (Bit_Chain *dat);
void bit_write_TIMEBLL (Bit_Chain *dat, BITCODE_TIMEBLL date);

BITCODE_TIMERLL bit_read_TIMERLL (Bit_Chain *dat);
void bit_write_TIMERLL (Bit_Chain *dat, BITCODE_TIMERLL date);

int bit_read_CMC (Bit_Chain *dat, Bit_Chain *str_dat,
                  Dwg_Color *restrict color);
void bit_write_CMC (Bit_Chain *dat, Bit_Chain *str_dat,
                    Dwg_Color *restrict color);
// Convert from truecolor (r2004+) to palette (-r2000)
void bit_downconvert_CMC (Bit_Chain *dat, Dwg_Color *restrict color);
void bit_upconvert_CMC (Bit_Chain *dat, Dwg_Color *restrict color);

void bit_read_ENC (Bit_Chain *dat, Bit_Chain *hdl_dat, Bit_Chain *str_dat,
                   Dwg_Color *restrict color);
void bit_write_ENC (Bit_Chain *dat, Bit_Chain *hdl_dat, Bit_Chain *str_dat,
                    Dwg_Color *restrict color);

int bit_search_sentinel (Bit_Chain *dat, const unsigned char sentinel[16]);

void bit_chain_init (Bit_Chain *dat, const size_t size);
void bit_chain_init_dat (Bit_Chain *restrict dat, const size_t size,
                         const Bit_Chain *restrict from_dat);
void bit_chain_alloc (Bit_Chain *dat);
void bit_chain_alloc_size (Bit_Chain *dat, const size_t size);
void bit_chain_free (Bit_Chain *dat);
// after bit_chain_init
#define bit_chain_set_version(to, from)                                       \
  (to)->opts = (from)->opts;                                                  \
  (to)->version = (from)->version;                                            \
  (to)->from_version = (from)->from_version;                                  \
  (to)->fh = (from)->fh;                                                      \
  (to)->codepage = (from)->codepage

void bit_print (Bit_Chain *dat, size_t size);

void bit_write_bits1 (Bit_Chain *restrict dat, const char *restrict bits);
long bit_write_hexbits (Bit_Chain *restrict dat, const char *restrict bytes);
void bit_print_bits (unsigned char *bits, size_t bitsize);
void bit_fprint_bits (FILE *fp, unsigned char *bits, size_t bitsize);
void bit_explore_chain (Bit_Chain *dat, size_t from, size_t size);

BITCODE_BD bit_nan (void);
int bit_isnan (BITCODE_BD number);

// which would require different text sizes and recalc.
bool does_cross_unicode_datversion (Bit_Chain *restrict dat);
/* Copy the whole content of tmp_data to dat, and reset tmp_dat */
void bit_copy_chain (Bit_Chain *restrict orig_dat,
                     Bit_Chain *restrict tmp_dat);

// for in_dxf and in_json
size_t in_hex2bin (unsigned char *restrict dest, char *restrict src,
                   size_t destlen) __nonnull_all;

// if there's a high char (> 0x7f)
bool bit_TF_contains_high (char *s, size_t len);

#endif // BITS_H
