#include "lzh.h"

#include <string.h>

#define BUFSIZE (1024 * 4)

typedef unsigned char  uchar;
typedef unsigned short ushort;
typedef unsigned int   uint;
typedef unsigned long  ulong;

#ifndef CHAR_BIT
#define CHAR_BIT	8
#endif

#ifndef UCHAR_MAX
#define UCHAR_MAX	255
#endif

typedef ushort BITBUFTYPE;

#define BITBUFSIZ	(CHAR_BIT * sizeof(BITBUFTYPE))
#define DICBIT		13	/* 12(-lh4-) or 13(-lh5-) */
#define DICSIZ		(1U << DICBIT)
#define MAXMATCH	256	/* formerly F (not more than UCHAR_MAX + 1) */
#define THRESHOLD	3	/* choose optimal value */
#define NC		(UCHAR_MAX + MAXMATCH + 2 - THRESHOLD)	/* alphabet = {0, 1, 2, ..., NC - 1} */
#define CBIT		9	/* $\lfloor \log_2 NC \rfloor + 1$ */
#define CODE_BIT	16	/* codeword length */

#define MAX_HASH_VAL	(3 * DICSIZ + (DICSIZ / 512 + 1) * UCHAR_MAX)

#define NP 		(DICBIT + 1)
#define NT		(CODE_BIT + 3)
#define	PBIT		4	/* smallest integer such that (1U << PBIT) > NP */
#define	TBIT		5	/* smallest integer such that (1U << TBIT) > NT */
#if NT > NP
#define NPT		NT
#else
#define NPT		NP
#endif

uchar *m_pSrc;
int m_srcSize;
uchar *m_pDst;
int m_dstSize;

int DataIn(void *pBuffer, int nBytes);
int DataOut(void *pOut, int nBytes);

void fillbuf(int n);
ushort getbits(int n);
void init_getbits(void);
int make_table(int nchar, uchar *bitlen, int tablebits, ushort *table);
void read_pt_len(int nn, int nbit, int i_special);
void read_c_len(void);
ushort decode_c(void);
ushort decode_p(void);
void huf_decode_start(void);
void decode_start(void);
void decode(uint count, uchar buffer[]);

int fillbufsize;
uchar buf[BUFSIZE];
uchar outbuf[DICSIZ];
ushort left[2 * NC - 1];
ushort right[2 * NC - 1];
BITBUFTYPE bitbuf;
uint subbitbuf;
int bitcount;
int decode_j;		/* remaining bytes to copy */
uchar c_len[NC];
uchar pt_len[NPT];
uint blocksize;
ushort c_table[4096];
ushort pt_table[256];
int with_error;

uint fillbuf_i;		/* NOTE: these ones are not initialized at constructor time but inside the fillbuf and decode func. */
uint decode_i;

/* Additions */

int DataIn(void *pBuffer, int nBytes)
{
  const int np = (nBytes <= m_srcSize) ? nBytes : m_srcSize;
  if (np > 0) {
    memcpy(pBuffer, m_pSrc, np);
    m_pSrc += np;
    m_srcSize -= np;
  }
  return np;
}

int DataOut(void *pBuffer, int nBytes)
{
  const int np = (nBytes <= m_dstSize) ? nBytes : m_dstSize;
  if (np > 0) {
    memcpy(m_pDst, pBuffer, np);
    m_pDst += np;
    m_dstSize -= np;
  }
  return np;
}

/* io.c */

/* Shift bitbuf n bits left, read n bits */
void fillbuf(int n)
{
  bitbuf = (bitbuf << n) & 0xffff;
  while (n > bitcount) {
    bitbuf |= subbitbuf << (n -= bitcount);
    if (fillbufsize == 0) {
      fillbuf_i = 0;
      fillbufsize = DataIn(buf, BUFSIZE - 32);
    }
    if (fillbufsize > 0)
      fillbufsize--, subbitbuf = buf[fillbuf_i++];
    else
      subbitbuf = 0;
    bitcount = CHAR_BIT;
  }
  bitbuf |= subbitbuf >> (bitcount -= n);
}

ushort getbits(int n)
{
  ushort x;
  x = bitbuf >> (BITBUFSIZ - n);
  fillbuf(n);
  return x;
}

void init_getbits(void)
{
  bitbuf = 0;
  subbitbuf = 0;
  bitcount = 0;
  fillbuf(BITBUFSIZ);
}

/* maketbl.c */

int make_table(int nchar, uchar * bitlen, int tablebits, ushort * table)
{
  ushort count[17], weight[17], start[18], *p;
  uint jutbits, avail, mask;
  int i, ch, len, nextcode;

  for (i = 1; i <= 16; i++)
    count[i] = 0;
  for (i = 0; i < nchar; i++)
    count[bitlen[i]]++;

  start[1] = 0;
  for (i = 1; i <= 16; i++)
    start[i + 1] = start[i] + (count[i] << (16 - i));
  if (start[17] != (ushort) (1U << 16))
    return (1);			/* error: bad table */

  jutbits = 16 - tablebits;
  for (i = 1; i <= tablebits; i++) {
    start[i] >>= jutbits;
    weight[i] = 1U << (tablebits - i);
  }
  while (i <= 16) {
    weight[i] = 1U << (16 - i);
    i++;
  }

  i = start[tablebits + 1] >> jutbits;
  if (i != (ushort) (1U << 16)) {
    int k = 1U << tablebits;
    while (i != k)
      table[i++] = 0;
  }

  avail = nchar;
  mask = 1U << (15 - tablebits);
  for (ch = 0; ch < nchar; ch++) {
    if ((len = bitlen[ch]) == 0)
      continue;
    nextcode = start[len] + weight[len];
    if (len <= tablebits) {
      for (i = start[len]; i < nextcode; i++)
	table[i] = ch;
    } else {
      uint k = start[len];
      p = &table[k >> jutbits];
      i = len - tablebits;
      while (i != 0) {
	if (*p == 0) {
	  right[avail] = left[avail] = 0;
	  *p = avail++;
	}
	if (k & mask)
	  p = &right[*p];
	else
	  p = &left[*p];
	k <<= 1;
	i--;
      }
      *p = ch;
    }
    start[len] = nextcode;
  }
  return (0);
}

/* huf.c */

void read_pt_len(int nn, int nbit, int i_special)
{
  int i, n;
  short c;
  ushort mask;

  n = getbits(nbit);
  if (n == 0) {
    c = getbits(nbit);
    for (i = 0; i < nn; i++)
      pt_len[i] = 0;
    for (i = 0; i < 256; i++)
      pt_table[i] = c;
  } else {
    i = 0;
    while (i < n) {
      c = bitbuf >> (BITBUFSIZ - 3);
      if (c == 7) {
	mask = 1U << (BITBUFSIZ - 1 - 3);
	while (mask & bitbuf) {
	  mask >>= 1;
	  c++;
	}
      }
      fillbuf((c < 7) ? 3 : c - 3);
      pt_len[i++] = (unsigned char) (c);
      if (i == i_special) {
	c = getbits(2);
	while (--c >= 0)
	  pt_len[i++] = 0;
      }
    }
    while (i < nn)
      pt_len[i++] = 0;
    make_table(nn, pt_len, 8, pt_table);
  }
}

void read_c_len(void)
{
  short i, c, n;
  ushort mask;

  n = getbits(CBIT);
  if (n == 0) {
    c = getbits(CBIT);
    for (i = 0; i < NC; i++)
      c_len[i] = 0;
    for (i = 0; i < 4096; i++)
      c_table[i] = c;
  } else {
    i = 0;
    while (i < n) {
      c = pt_table[bitbuf >> (BITBUFSIZ - 8)];
      if (c >= NT) {
	mask = 1U << (BITBUFSIZ - 1 - 8);
	do {
	  if (bitbuf & mask)
	    c = right[c];
	  else
	    c = left[c];
	  mask >>= 1;
	} while (c >= NT);
      }
      fillbuf(pt_len[c]);
      if (c <= 2) {
	if (c == 0)
	  c = 1;
	else if (c == 1)
	  c = getbits(4) + 3;
	else
	  c = getbits(CBIT) + 20;
	while (--c >= 0)
	  c_len[i++] = 0;
      } else
	c_len[i++] = c - 2;
    }
    while (i < NC)
      c_len[i++] = 0;
    make_table(NC, c_len, 12, c_table);
  }
}

ushort decode_c(void)
{
  ushort j, mask;

  if (blocksize == 0) {
    blocksize = getbits(16);
    read_pt_len(NT, TBIT, 3);
    read_c_len();
    read_pt_len(NP, PBIT, -1);
  }
  blocksize--;
  j = c_table[bitbuf >> (BITBUFSIZ - 12)];
  if (j >= NC) {
    mask = 1U << (BITBUFSIZ - 1 - 12);
    do {
      if (bitbuf & mask)
	j = right[j];
      else
	j = left[j];
      mask >>= 1;
    }
    while (j >= NC);
  }
  fillbuf(c_len[j]);
  return j;
}

ushort decode_p(void)
{
  ushort j, mask;

  j = pt_table[bitbuf >> (BITBUFSIZ - 8)];
  if (j >= NP) {
    mask = 1U << (BITBUFSIZ - 1 - 8);
    do {
      if (bitbuf & mask)
	j = right[j];
      else
	j = left[j];
      mask >>= 1;
    } while (j >= NP);
  }
  fillbuf(pt_len[j]);
  if (j != 0)
    j = (1U << (j - 1)) + getbits(j - 1);
  return j;
}

void huf_decode_start(void)
{
  init_getbits();
  blocksize = 0;
}

/* decode.c */

void decode_start(void)
{
  fillbufsize = 0;
  huf_decode_start();
  decode_j = 0;
}

/*
 * The calling function must keep the number of bytes to be processed.  This
 * function decodes either 'count' bytes or 'DICSIZ' bytes, whichever is
 * smaller, into the array 'buffer[]' of size 'DICSIZ' or more. Call
 * decode_start() once for each new file before calling this function.
 */
void decode(uint count, uchar buffer[])
{
  uint r, c;

  r = 0;
  while (--decode_j >= 0) {
    buffer[r] = buffer[decode_i];
    decode_i = (decode_i + 1) & (DICSIZ - 1);
    if (++r == count)
      return;
  }
  for (;;) {
    c = decode_c();
    if (c <= UCHAR_MAX) {
      buffer[r] = c;
      if (++r == count)
	return;
    } else {
      decode_j = c - (UCHAR_MAX + 1 - THRESHOLD);
      decode_i = (r - decode_p() - 1) & (DICSIZ - 1);
      while (--decode_j >= 0) {
	buffer[r] = buffer[decode_i];
	decode_i = (decode_i + 1) & (DICSIZ - 1);
	if (++r == count)
	  return;
      }
    }
  }
}

int LzUnpack(void *pSrc, int srcSize, void *pDst, int dstSize)
{
  with_error = 0;

  m_pSrc = (uchar *) pSrc;
  m_srcSize = srcSize;
  m_pDst = (uchar *) pDst;
  m_dstSize = dstSize;

  decode_start();

  unsigned int origsize = dstSize;
  while (origsize != 0) {
    int n = (uint) ((origsize > DICSIZ) ? DICSIZ : origsize);
    decode(n, outbuf);
    if (with_error)
      break;

    DataOut(outbuf, n);
    origsize -= n;
    if (with_error)
      break;
  }

  return (with_error);
}