/*

* Copyright (c) 2021-2022  Moddable Tech, Inc.

*

*   This file is part of the Moddable SDK Runtime.

*

*   The Moddable SDK Runtime is free software: you can redistribute it and/or modify

*   it under the terms of the GNU Lesser General Public License as published by

*   the Free Software Foundation, either version 3 of the License, or

*   (at your option) any later version.

*

*   The Moddable SDK Runtime is distributed in the hope that it will be useful,

*   but WITHOUT ANY WARRANTY; without even the implied warranty of

*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

*   GNU Lesser General Public License for more details.

*

*   You should have received a copy of the GNU Lesser General Public License

*   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.

*

*/

#include "xsmc.h"

#include "xsHost.h"

#ifdef kPocoRotation

  // Moddable SDK

  #include "mc.xs.h"      // for xsID_ values

  #define VALIDATE 1

#else

  // xst, xsnap, etc

  #include <stdbool.h>

  #define xsID_ignoreBOM (xsID("ignoreBOM"))

  #define xsID_fatal (xsID("fatal"))

  #define xsID_stream (xsID("stream"))

#endif

typedef struct {

  uint8_t   ignoreBOM;

  uint8_t   fatal;

  // left over when streaming

  uint8_t   bufferLength;

  uint8_t   buffer[12];

} modTextDecoderRecord, *modTextDecoder;

static uint8_t isLegalUTF8(const uint8_t *source, int length);

void xs_textdecoder_destructor(void *data)

{

}

void xs_textdecoder(xsMachine *the)

{

  modTextDecoderRecord decoder;

  int argc = xsmcArgc;

  if (argc && c_strcmp(xsmcToString(xsArg(0)), "utf-8"))

    xsRangeError("unsupported encoding");

#if !VALIDATE

  xsmcGet(xsResult, xsTarget, xsID("prototype"));

  xsResult = xsNewHostInstance(xsResult);

  xsThis = xsResult;

  xsmcSetHostDestructor(xsThis, NULL);

  c_memset(&decoder, 0, sizeof(decoder));

#endif

  decoder.ignoreBOM = false;

  decoder.fatal = false;

  decoder.bufferLength = 0;

  if (argc >= 2) {

    xsmcVars(1);

    xsmcGet(xsVar(0), xsArg(1), xsID_ignoreBOM);

    decoder.ignoreBOM = xsmcTest(xsVar(0));

    xsmcGet(xsVar(0), xsArg(1), xsID_fatal);

    decoder.fatal = xsmcTest(xsVar(0));

  }

  xsmcSetHostChunk(xsThis, &decoder, sizeof(decoder));

}

/*

  UTF-8 BOM is sequence 0xEF,0xBB,0xBF

  Replacement character sequence in UTF-8 is 0xEF 0xBF 0xBD

  null character maps to 0xC0, 0x80

  implementation overallocates by 3 bytes if BOM is present and ignoreBOM is false

*/

void xs_textdecoder_decode(xsMachine *the)

{

  uint8_t *src, *srcEnd, *dst, *dst3;

  uint8_t *buffer;

  xsUnsignedValue srcLength, bufferLength;

  modTextDecoder td;

  uint8_t srcOffset = 0;

  uint32_t outLength = 0;

  uint8_t stream = 0;

  int argc = xsmcArgc;

  if (argc > 1) {

    xsmcVars(1);

    xsmcGet(xsVar(0), xsArg(1), xsID_stream);

    stream = xsmcToBoolean(xsVar(0));

  }

  if (argc) {

    xsmcGetBufferReadable(xsArg(0), (void **)&src, &srcLength);

    srcEnd = src + srcLength;

  }

  else

    src = srcEnd = NULL;

#if VALIDATE

  td = xsmcGetHostChunkValidate(xsThis, xs_textdecoder_destructor);

#else

  td = xsmcGetHostChunk(xsThis);

#endif

  buffer = td->buffer;

  bufferLength = td->bufferLength;

  while ((src < srcEnd) || bufferLength) {

    unsigned char first, clen, i;

    uint8_t utf8[4];

    if (bufferLength) {

      bufferLength--;

      first = *buffer++;

    }

    else

      first = c_read8(src++);

    if (first < 0x80) {

      outLength += (0 == first) ? 2 : 1;

      continue;

    }

    if (0xC0 == (first & 0xE0))

      clen = 1;

    else if (0xE0 == (first & 0xF0))

      clen = 2;

    else if (0xF0 == (first & 0xF0))

      clen = 3;

    else if (td->fatal)

      goto fatal;

    else {

      outLength += 3;

      continue;

    }

    if (clen > ((srcEnd - src) + bufferLength)) {

      if (stream)

        break; // decode to here. remainder saved below

      if (td->fatal)

        goto fatal;

      outLength += 3;

      if (!src)    // flush

        break;

      continue;

    }

    utf8[0] = first;

    for (i = 0; i < clen; i++) {

      if (i < bufferLength)

        utf8[i + 1] = buffer[i];

      else

        utf8[i + 1] = c_read8(src + i - bufferLength);

    }

    if (!isLegalUTF8(utf8, clen + 1)) {

      if (td->fatal)

        goto fatal;

      uint8_t lower = 0x80, upper = 0xBF;

      if (0xE0 == first)

        lower = 0xA0;

      else if (0xED == first)

        lower = 0x9F;

      else if (0xF0 == first)

        lower = 0x90;

      else if (0xF4 == first)

        lower = 0x8F;

      else if (first > 0xF4)  // no valid next byte

        clen = 0;

      const uint8_t *s = &utf8[1];

      while (clen-- > 0) {

        uint8_t c = *s++;

        if ((lower <= c) && (c <= upper)) {

          if (bufferLength) {

            bufferLength--;

            buffer++;

          }

          else

            src++;

        }

        else

          break;

      }

      outLength += 3;

      continue;

    }

#if mxCESU8

    outLength += (3 == clen) ? 6 : (clen + 1);

#else

    outLength += clen + 1;

#endif

    if (bufferLength) {

      if (bufferLength >= clen) {

        bufferLength -= clen;

        buffer += clen;

      }

      else {

        src += clen - bufferLength; 

        bufferLength = 0;

      }

    }

    else

      src += clen;

  }

  xsmcSetStringBuffer(xsResult, NULL, outLength + 1);

  if (argc) {

    xsmcGetBufferReadable(xsArg(0), (void **)&src, &srcLength);

    srcEnd = src + srcLength;

    src += srcOffset;

  }

  else

    src = srcEnd = NULL;

#if VALIDATE

  td = xsmcGetHostChunkValidate(xsThis, xs_textdecoder_destructor);

#else

  td = xsmcGetHostChunk(xsThis);

#endif

  buffer = td->buffer;

  bufferLength = td->bufferLength;

  dst = (uint8_t *)xsmcToString(xsResult);

  dst3 = td->ignoreBOM ? NULL : (dst + 3);

  while ((src < srcEnd) || bufferLength) {

    unsigned char first, clen, i, firstFromBuffer;

    uint8_t utf8[4];

    if (bufferLength) {

      bufferLength--;

      first = *buffer++;

      firstFromBuffer = 1;

    }

    else {

      first = c_read8(src++);

      firstFromBuffer = 0;

    }

    if (first < 0x80) {

      if (first)

        *dst++ = first;

      else {

        *dst++ = 0xC0;

        *dst++ = 0x80;

      }

      continue;

    }

    if (0xC0 == (first & 0xE0))

      clen = 1;

    else if (0xE0 == (first & 0xF0))

      clen = 2;

    else if (0xF0 == (first & 0xF0))

      clen = 3;

    else {

      *dst++ = 0xEF;

      *dst++ = 0xBF;

      *dst++ = 0xBD;

      continue;

    }

    if (clen > ((srcEnd - src) + bufferLength)) {

      if (stream) {

        // put back "first". remainder saved below.

        if (firstFromBuffer) {

          buffer--;

          bufferLength++;

        }

        else

          src--;

        break;

      }

      *dst++ = 0xEF;

      *dst++ = 0xBF;

      *dst++ = 0xBD;

      if (!src)

        break; // flush

      continue;

    }

    utf8[0] = first;

    for (i = 0; i < clen; i++) {

      if (i < bufferLength)

        utf8[i + 1] = buffer[i];

      else

        utf8[i + 1] = c_read8(src + i - bufferLength);

    }

    if (!isLegalUTF8(utf8, clen + 1)) {

      *dst++ = 0xEF;

      *dst++ = 0xBF;

      *dst++ = 0xBD;

      uint8_t lower = 0x80, upper = 0xBF;

      if (0xE0 == first)

        lower = 0xA0;

      else if (0xED == first)

        lower = 0x9F;

      else if (0xF0 == first)

        lower = 0x90;

      else if (0xF4 == first)

        lower = 0x8F;

      else if (first > 0xF4)  // no valid next byte

        clen = 0;

      const uint8_t *s = &utf8[1];

      while (clen-- > 0) {

        uint8_t c = *s++;

        if ((lower <= c) && (c <= upper)) {

          if (bufferLength) {

            bufferLength--;

            buffer++;

          }

          else

            src++;

        }

        else

          break;

      }

      continue;

    }

#if mxCESU8

    if (3 != clen) {

      *dst++ = first;

      for (i = 0; i < clen; i++)

        *dst++ = utf8[i + 1];

    }

    else {

      xsIntegerValue c;

      fxUTF8Decode((xsStringValue)utf8, &c);

      c -= 0x10000;

      fxUTF8Encode((xsStringValue)dst, 0xD800 + (c >> 10));

      dst += 3;

      fxUTF8Encode((xsStringValue)dst, 0xDC00 + (c & 0x3FF));

      dst += 3;

    }

#else

    *dst++ = first;

    for (i = 0; i < clen; i++)

      *dst++ = utf8[i + 1];

#endif

    if ((0xEF == first) && (dst == dst3)) {

      if ((0xBF == dst[-1]) && (0xBB == dst[-2]))

        dst -= 3;

    }

    if (bufferLength) {

      if (bufferLength >= clen) {

        bufferLength -= clen;

        buffer += clen;

      }

      else {

        src += clen - bufferLength; 

        bufferLength = 0;

      }

    }

    else

      src += clen;

  }

  *dst++ = 0;

  if (src) {

    c_memcpy(td->buffer, buffer, bufferLength);

    c_memcpy(td->buffer + bufferLength, src, srcEnd - src);

    td->bufferLength = bufferLength + (srcEnd - src);

  }

  else 

    td->bufferLength =  0;   // flush

  return;

fatal:

  xsTypeError("invalid utf-8");

}

void xs_textdecoder_get_encoding(xsMachine *the)

{

  xsmcSetString(xsResult, "utf-8");

}

void xs_textdecoder_get_ignoreBOM(xsMachine *the)

{

#if VALIDATE

  modTextDecoder td = xsmcGetHostChunkValidate(xsThis, xs_textdecoder_destructor);

#else

  modTextDecoder td = xsmcGetHostChunk(xsThis);

#endif

  xsmcSetBoolean(xsResult, td->ignoreBOM);

}

void xs_textdecoder_get_fatal(xsMachine *the)

{

#if VALIDATE

  modTextDecoder td = xsmcGetHostChunkValidate(xsThis, xs_textdecoder_destructor);

#else

  modTextDecoder td = xsmcGetHostChunk(xsThis);

#endif

  xsmcSetBoolean(xsResult, td->fatal);

}

#if !VALIDATE

void modInstallTextDecoder(xsMachine *the)

{

  #define kPrototype (0)

  #define kConstructor (1)

  #define kScratch (2)

  xsBeginHost(the);

  xsmcVars(3);

  xsVar(kPrototype) = xsNewHostObject(NULL);

  xsVar(kConstructor) = xsNewHostConstructor(xs_textdecoder, 2, xsVar(kPrototype));

  xsmcDefine(xsGlobal, xsID("TextDecoder"), xsVar(kConstructor), xsDontEnum);

  xsVar(kScratch) = xsNewHostFunction(xs_textdecoder_decode, 1);

  xsmcDefine(xsVar(kPrototype), xsID("decode"), xsVar(kScratch), xsDontEnum);

  xsVar(kScratch) = xsNewHostFunction(xs_textdecoder_get_encoding, 0);

  xsmcDefine(xsVar(kPrototype), xsID("encoding"), xsVar(kScratch), xsIsGetter | xsDontEnum);

  xsVar(kScratch) = xsNewHostFunction(xs_textdecoder_get_ignoreBOM, 0);

  xsmcDefine(xsVar(kPrototype), xsID("ignoreBOM"), xsVar(kScratch), xsIsGetter | xsDontEnum);

  xsVar(kScratch) = xsNewHostFunction(xs_textdecoder_get_fatal, 0);

  xsmcDefine(xsVar(kPrototype), xsID("fatal"), xsVar(kScratch), xsIsGetter | xsDontEnum);

  xsEndHost(the);

}

#endif

/*

 * Copyright 2001-2004 Unicode, Inc.

 * 

 * Disclaimer

 * 

 * This source code is provided as is by Unicode, Inc. No claims are

 * made as to fitness for any particular purpose. No warranties of any

 * kind are expressed or implied. The recipient agrees to determine

 * applicability of information provided. If this file has been

 * purchased on magnetic or optical media from Unicode, Inc., the

 * sole remedy for any claim will be exchange of defective media

 * within 90 days of receipt.

 * 

 * Limitations on Rights to Redistribute This Code

 * 

 * Unicode, Inc. hereby grants the right to freely use the information

 * supplied in this file in the creation of products supporting the

 * Unicode Standard, and to make copies of this file in any form

 * for internal or external distribution as long as this notice

 * remains attached.

 */

uint8_t isLegalUTF8(const uint8_t *source, int length) {

    uint8_t a;

    const uint8_t *srcptr = source+length;

    switch (length) {

    default: return false;

  /* Everything else falls through when "true"... */

    case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;

    case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;

    case 2: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;

  switch (*source) {

      /* no fall-through in this inner switch */

      case 0xE0: if (a < 0xA0) return false; break;

      case 0xED: if (a > 0x9F) return false; break;

      case 0xF0: if (a < 0x90) return false; break;

      case 0xF4: if (a > 0x8F) return false; break;

      default:   if (a < 0x80) return false;

  }

    case 1: if (*source >= 0x80 && *source < 0xC2) return false;

    }

    if (*source > 0xF4) return false;

    return true;

}