/*

* 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_read (xsID("read"))

  #define xsID_String (xsID("String"))

  #define xsID_Uint8Array (xsID("Uint8Array"))

  #define xsID_written (xsID("written"))

#endif

#if !VALIDATE

void xs_textencoder(xsMachine *the)

{

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

  xsResult = xsNewHostInstance(xsResult);

}

#endif

/*

  null character maps to 0xC0, 0x80

  surrogate pair pattern: ED Ax xx ED Bx xx

*/

void xs_textencoder_encode(xsMachine *the)

{

  uint8_t *src, *dst;

  int length = 0;

  uint8_t remap = false;

  xsArg(0) = xsCall1(xsGlobal, xsID_String, xsArg(0));

  src = (uint8_t *)xsmcToString(xsArg(0));

  while (true) {

    uint8_t c = c_read8(src++);

    if (!c) break;

    if ((0xED == c) &&

      (0xA0 == (0xF0 & c_read8(src))) &&

      (0xED == c_read8(src + 2)) &&

      (0xB0 == (0xF0 & c_read8(src + 3)))) {

      src += 5;

      length += 4;

      remap = true;

      continue;

    }

    length += 1;

    if ((0xC0 == c) && (0x80 == c_read8(src))) {

      src += 1;

      remap = true;

    }

  }

  xsmcSetArrayBuffer(xsResult, NULL, length);

  src = (uint8_t *)xsmcToString(xsArg(0));

  dst = xsmcToArrayBuffer(xsResult);

  if (remap) {

    while (true) {

      uint8_t c = c_read8(src++);

      if (!c) break;

      if ((0xED == c) &&

        (0xA0 == (0xF0 & c_read8(src))) &&

        (0xED == c_read8(src + 2)) &&

        (0xB0 == (0xF0 & c_read8(src + 3)))) {

        xsIntegerValue high, low;

        fxUTF8Decode((xsStringValue)(src - 1), &high);

        fxUTF8Decode((xsStringValue)(src + 2), &low);

        fxUTF8Encode((xsStringValue)dst, 0x10000 + ((high & 0x3FF) << 10) + (low & 0x3FF));

        src += 5;

        dst += 4;

        continue;

      }

      if ((0xC0 == c) && (0x80 == c_read8(src))) {

        *dst++ = 0;

        src += 1;

      }

      else

        *dst++ = c;

    }

  }

  else

    c_memcpy(dst, src, length);

  xsResult = xsNew1(xsGlobal, xsID_Uint8Array, xsResult);

}

void xs_textencoder_encodeInto(xsMachine *the)

{

  uint8_t *src, *dst;

  xsUnsignedValue dstTotal, dstRemaining;

  int read = 0;

  if (!xsmcIsInstanceOf(xsArg(1), xsTypedArrayPrototype))    //@@ limit to Uint8Array

    xsUnknownError("Uint8Array only");

  xsArg(0) = xsCall1(xsGlobal, xsID_String, xsArg(0));

  xsmcGetBufferWritable(xsArg(1), (void **)&dst, &dstTotal);

  dstRemaining = dstTotal; 

  src = (uint8_t *)xsmcToString(xsArg(0));

  while (dstRemaining) {

    uint8_t first = c_read8(src++);

    if (!first) break;

    if (first < 0x80) {

      *dst++ = first;

      dstRemaining -= 1;

    }

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

      if ((0xC0 == first) && (0x80 == c_read8(src))) {

        *dst++ = 0;

        dstRemaining -= 1;

        src += 1;

        read += 1;

        continue;

      }

      if (dstRemaining < 2)

        break;

      *dst++ = first;

      *dst++ = c_read8(src++);

      dstRemaining -= 2;

    }

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

      if ((0xED == first) &&

        (0xA0 == (0xF0 & c_read8(src))) &&

        (0xED == c_read8(src + 2)) &&

        (0xB0 == (0xF0 & c_read8(src + 3)))) {

        xsIntegerValue high, low;

        if (dstRemaining < 4)

          break;

        fxUTF8Decode((xsStringValue)(src - 1), &high);

        fxUTF8Decode((xsStringValue)(src + 2), &low);

        fxUTF8Encode((xsStringValue)dst, 0x10000 + ((high & 0x3FF) << 10) + (low & 0x3FF));

        src += 5;

        dst += 4;

        dstRemaining -= 4;

        read += 2;

        continue;

      }

      if (dstRemaining < 3)

        break;

      *dst++ = first;

      *dst++ = c_read8(src++);

      *dst++ = c_read8(src++);

      dstRemaining -= 3;

    }

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

      if (dstRemaining < 4)

        break;

      *dst++ = first;

      *dst++ = c_read8(src++);

      *dst++ = c_read8(src++);

      *dst++ = c_read8(src++);

      dstRemaining -= 4;

    }

    else

      fxAbort(the, xsFatalCheckExit);

    read += 1;

  }

  xsmcSetNewObject(xsResult);

  xsmcVars(1);

  xsmcSetInteger(xsVar(0), read);

  xsmcSet(xsResult, xsID_read, xsVar(0));

  xsmcSetInteger(xsVar(0), dstTotal - dstRemaining);

  xsmcSet(xsResult, xsID_written, xsVar(0));

}

#if !VALIDATE

void modInstallTextEncoder(xsMachine *the)

{

  #define kPrototype (0)

  #define kConstructor (1)

  #define kScratch (2)

  xsBeginHost(the);

  xsmcVars(3);

  xsmcSetNewObject(xsVar(kPrototype));

  xsVar(kConstructor) = xsNewHostConstructor(xs_textencoder, 1, xsVar(kPrototype));

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

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

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

  xsVar(kScratch) = xsNewHostFunction(xs_textencoder_encodeInto, 2);

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

  xsEndHost(the);

}

#endif