/*

 * Copyright (c) 2016-2017  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/>.

 *

 * This file incorporates work covered by the following copyright and  

 * permission notice:  

 *

 *       Copyright (C) 2010-2016 Marvell International Ltd.

 *       Copyright (C) 2002-2010 Kinoma, Inc.

 *

 *       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.

 */

#include "xsAll.h"

txSlot* fxLastProperty(txMachine* the, txSlot* slot)

{

  txSlot* property;

  while ((property = slot->next))

    slot = property;

  return slot;

}

#ifndef mxLink

txSlot* fxNextHostAccessorProperty(txMachine* the, txSlot* property, txCallback get, txCallback set, txID id, txFlag flag)

{

  txSlot *getter = NULL, *setter = NULL, *home = the->stack, *slot;

  if (get) {

    getter = fxBuildHostFunction(the, get, 0, XS_NO_ID);

    slot = mxFunctionInstanceHome(getter);

    slot->value.home.object = home->value.reference;

    fxRenameFunction(the, getter, id, 0, XS_NO_ID, "get ");

  }

  if (set) {

    setter = fxBuildHostFunction(the, set, 1, XS_NO_ID);

    slot = mxFunctionInstanceHome(setter);

    slot->value.home.object = home->value.reference;

    fxRenameFunction(the, setter, id, 0, XS_NO_ID, "set ");

  }

  property = property->next = fxNewSlot(the);

  property->flag = flag;

  property->ID = id;

  property->kind = XS_ACCESSOR_KIND;

  property->value.accessor.getter = getter;

  property->value.accessor.setter = setter;

  if (set)

    mxPop();

  if (get)

    mxPop();

  return property;

}

txSlot* fxNextHostFunctionProperty(txMachine* the, txSlot* property, txCallback call, txInteger length, txID id, txFlag flag)

{

  txSlot *function, *home = the->stack, *slot;

  function = fxNewHostFunction(the, call, length, id, XS_NO_ID);

  slot = mxFunctionInstanceHome(function);

  slot->value.home.object = home->value.reference;

  property = property->next = fxNewSlot(the);

  property->flag = flag;

  property->ID = id;

  property->kind = the->stack->kind;

  property->value = the->stack->value;

  mxPop();

  return property;

}

#endif

txSlot* fxNextUndefinedProperty(txMachine* the, txSlot* property, txID id, txFlag flag)

{

  property = property->next = fxNewSlot(the);

  property->flag = flag;

  property->ID = id;

  property->kind = XS_UNDEFINED_KIND;

  return property;

}

txSlot* fxNextNullProperty(txMachine* the, txSlot* property, txID id, txFlag flag)

{

  property = property->next = fxNewSlot(the);

  property->flag = flag;

  property->ID = id;

  property->kind = XS_NULL_KIND;

  return property;

}

txSlot* fxNextBooleanProperty(txMachine* the, txSlot* property, txBoolean boolean, txID id, txFlag flag)

{

  property = property->next = fxNewSlot(the);

  property->flag = flag;

  property->ID = id;

  property->kind = XS_BOOLEAN_KIND;

  property->value.boolean = boolean;

  return property;

}

txSlot* fxNextIntegerProperty(txMachine* the, txSlot* property, txInteger integer, txID id, txFlag flag)

{

  property = property->next = fxNewSlot(the);

  property->flag = flag;

  property->ID = id;

  property->kind = XS_INTEGER_KIND;

  property->value.integer = integer;

  return property;

}

txSlot* fxNextNumberProperty(txMachine* the, txSlot* property, txNumber number, txID id, txFlag flag)

{

  property = property->next = fxNewSlot(the);

  property->flag = flag;

  property->ID = id;

  property->kind = XS_NUMBER_KIND;

  property->value.number = number;

  return property;

}

txSlot* fxNextReferenceProperty(txMachine* the, txSlot* property, txSlot* slot, txID id, txFlag flag)

{

  property = property->next = fxNewSlot(the);

  property->flag = flag;

  property->ID = id;

  property->kind = XS_REFERENCE_KIND;

  property->value.reference = slot;

  return property;

}

txSlot* fxNextSlotProperty(txMachine* the, txSlot* property, txSlot* slot, txID id, txFlag flag)

{

  property = property->next = fxNewSlot(the);

  property->flag = flag;

  property->ID = id;

  property->kind = slot->kind;

  property->value = slot->value;

  return property;

}

txSlot* fxNextStringProperty(txMachine* the, txSlot* property, txString string, txID id, txFlag flag)

{

  property = property->next = fxNewSlot(the);

  property->flag = flag;

  property->ID = id;

  fxCopyStringC(the, property, string);

  return property;

}

txSlot* fxNextStringXProperty(txMachine* the, txSlot* property, txString string, txID id, txFlag flag)

{

  property = property->next = fxNewSlot(the);

  property->flag = flag;

  property->ID = id;

#ifdef mxSnapshot

  fxCopyStringC(the, property, string);

#else

  property->kind = XS_STRING_X_KIND;

  property->value.string = string;

#endif

  return property;

}

txSlot* fxNextSymbolProperty(txMachine* the, txSlot* property, txID symbol, txID id, txFlag flag)

{

  property = property->next = fxNewSlot(the);

  property->flag = flag;

  property->ID = id;

  property->kind = XS_SYMBOL_KIND;

  property->value.symbol = symbol;

  return property;

}

txSlot* fxNextTypeDispatchProperty(txMachine* the, txSlot* property, txTypeDispatch* dispatch, txTypeAtomics* atomics, txID id, txFlag flag)

{

  property = property->next = fxNewSlot(the);

  property->flag = flag;

  property->ID = id;

  property->kind = XS_TYPED_ARRAY_KIND;

  property->value.typedArray.dispatch = dispatch;

  property->value.typedArray.atomics = atomics;

  return property;

}

txSlot* fxQueueKey(txMachine* the, txID id, txIndex index, txSlot* keys)

{

  keys = keys->next = fxNewSlot(the);

  keys->kind = XS_AT_KIND;

  keys->value.at.id = id;

  keys->value.at.index = index;

  return keys;

}

txSlot* fxQueueIDKeys(txMachine* the, txSlot* first, txFlag flag, txSlot* keys)

{

  if (flag & XS_EACH_NAME_FLAG) {

    txSlot* property = first;

    while (property) {

      if (!(property->flag & XS_INTERNAL_FLAG) && fxIsKeyName(the, property->ID))

        keys = fxQueueKey(the, property->ID, 0, keys);

      property = property->next;

    }

  }

  if (flag & XS_EACH_SYMBOL_FLAG) {

    txSlot* property = first;

    while (property) {

      if (!(property->flag & XS_INTERNAL_FLAG) && fxIsKeySymbol(the, property->ID))

        keys = fxQueueKey(the, property->ID, 0, keys);

      property = property->next;

    }

  }

  return keys;

}

// INDEX

static txSize fxSizeToCapacity(txMachine* the, txSize size)

{

  return fxAddChunkSizes(the, size, size / 3);

}

txBoolean fxDeleteIndexProperty(txMachine* the, txSlot* array, txIndex index) 

{

  txSlot* address = array->value.array.address;

  if (address) {

    txIndex length = array->value.array.length;

    txIndex size = (((txChunk*)(((txByte*)address) - sizeof(txChunk)))->size) / sizeof(txSlot);

    txSlot* result = address;

    txSlot* limit = result + size;

    if (length == size)

      result = address + index;

    else {

      txIndex at;

      while (result < limit) {

        at = *((txIndex*)result);

        if (at == index)

          break;

        if (at > index)

          return 1;

        result++;

      }

    }

    if (result < limit) {

      if (result->flag & XS_DONT_DELETE_FLAG)

        return 0;

      index = (txIndex)(result - address);

      size--;

      if (size > 0) {

        txSlot* chunk = (txSlot*)fxNewChunk(the, size * sizeof(txSlot));

        address = array->value.array.address;

        if (index > 0)

          c_memcpy(chunk, address, index * sizeof(txSlot));

        if (index < size)

          c_memcpy(chunk + index, address + index + 1, (size - index) * sizeof(txSlot));

        array->value.array.address = chunk;

      }

      else

        array->value.array.address = C_NULL;

    }

  }

  return 1;

}

txSlot* fxGetIndexProperty(txMachine* the, txSlot* array, txIndex index) 

{

  txSlot* address = array->value.array.address;

  if (address) {

    txIndex length = array->value.array.length;

    txIndex size = (((txChunk*)(((txByte*)address) - sizeof(txChunk)))->size) / sizeof(txSlot);

    if (length == size) {

      if (index < length)

        return address + index;

    }

    else {

      txSlot* result = address;

      txSlot* limit = result + size;

      txIndex at;

      while (result < limit) {

        at = *((txIndex*)result);

        if (at == index)

          return result;

        result++;

      }

    }

  }

  return C_NULL;

}

txIndex fxGetIndexSize(txMachine* the, txSlot* array)

{

  txSlot* address = array->value.array.address;

  if (address)

    return (((txChunk*)(((txByte*)address) - sizeof(txChunk)))->size) / sizeof(txSlot);

  return 0;

}

txSlot* fxQueueIndexKeys(txMachine* the, txSlot* array, txFlag flag, txSlot* keys)

{

  if (flag & XS_EACH_NAME_FLAG) {

    if (array->value.array.address) {

      txSize offset = 0;

      txSize size = (((txChunk*)(((txByte*)array->value.array.address) - sizeof(txChunk)))->size) / sizeof(txSlot);

      while (offset < size) {

        txSlot* slot = array->value.array.address + offset;

        txIndex index = *((txIndex*)slot);

        keys = fxQueueKey(the, 0, index, keys);

        offset++;

      }

    }

  }

  return keys;

}

txSlot* fxSetIndexProperty(txMachine* the, txSlot* instance, txSlot* array, txIndex index) 

{

  txSlot* address = array->value.array.address;

  txSlot* chunk = address;

  txIndex length = array->value.array.length;

  txIndex current;

  txSize size;

  txSlot* result;

  txSlot* limit;

  txIndex at;

  if (address) {

    current = (((txChunk*)(((txByte*)chunk) - sizeof(txChunk)))->size) / sizeof(txSlot);

    if (length == current) {

      if (index < length) 

        return address + index;

      if (instance->flag & XS_DONT_PATCH_FLAG)

        return C_NULL;

      if (array->flag & XS_DONT_SET_FLAG)

        return C_NULL;

      current++;

      size = fxMultiplyChunkSizes(the, current, sizeof(txSlot));

      chunk = (txSlot*)fxRenewChunk(the, address, size);

      if (!chunk) {

      #ifndef mxNoArrayOverallocation

        if (array->ID == XS_ARRAY_BEHAVIOR) {

          txSize capacity = fxSizeToCapacity(the, size);

          chunk = (txSlot*)fxNewGrowableChunk(the, size, capacity);

        }

        else

      #endif

          chunk = (txSlot*)fxNewChunk(the, size);

        address = array->value.array.address;

        c_memcpy(chunk, address, length * sizeof(txSlot));

      }

      result = chunk + length;

    }

    else {

      result = address;

      limit = result + current;

      while (result < limit) {

        at = *((txIndex*)result);

        if (at == index)

          return result;

        if (at > index)

          break;

        result++;

      }

      if (instance->flag & XS_DONT_PATCH_FLAG)

        return C_NULL;

      if ((array->flag & XS_DONT_SET_FLAG) && (index >= length))

        return C_NULL;

      at = mxPtrDiff(result - address);

      current++;

      size = fxMultiplyChunkSizes(the, current, sizeof(txSlot));

      chunk = (txSlot*)fxNewChunk(the, size);

      address = array->value.array.address;

      result = address + at;

      limit = address + current - 1;

      if (result > address)

        c_memcpy(chunk, address, (result - address) * sizeof(txSlot));

      if (result < limit)

        c_memcpy(chunk + (result - address) + 1, result, (limit - result) * sizeof(txSlot));

      result = chunk + (result - address);

    }

  }

  else {

        if (instance->flag & XS_DONT_PATCH_FLAG)

            return C_NULL;

    if ((array->flag & XS_DONT_SET_FLAG) && (index >= length))

      return C_NULL;

    current = 1;

    chunk = (txSlot*)fxNewChunk(the, sizeof(txSlot));

    result = chunk;

  }

  result->next = C_NULL;

  result->ID = XS_NO_ID;

  result->flag = XS_NO_FLAG;

  result->kind = XS_UNDEFINED_KIND;

  *((txIndex*)result) = index;  

  array->value.array.address = chunk;

  if (index >= length) {

    array->value.array.length = index + 1;

  }

  return result;

}

void fxSetIndexSize(txMachine* the, txSlot* array, txIndex target, txBoolean growable)

{

  txSlot* address = array->value.array.address;

  txSlot* chunk = C_NULL;

  txIndex current = (address) ? (((txChunk*)(((txByte*)address) - sizeof(txChunk)))->size) / sizeof(txSlot) : 0;

  txSize size;

  if (current != target) {

    if (array->flag & XS_DONT_SET_FLAG)

      mxTypeError("set length: not writable");

    size = fxMultiplyChunkSizes(the, target, sizeof(txSlot));

    if (address) {

      if (target) {

        chunk = (txSlot*)fxRenewChunk(the, address, size);

        if (!chunk) {

        #ifndef mxNoArrayOverallocation

          if (growable) {

            txSize capacity = fxSizeToCapacity(the, size);

            chunk = (txSlot*)fxNewGrowableChunk(the, size, capacity);

          }

          else

        #endif

            chunk = (txSlot*)fxNewChunk(the, size);

          address = array->value.array.address;

          if (current < target)

            c_memcpy(chunk, address, current * sizeof(txSlot));

          else

            c_memcpy(chunk, address, size);

        }

      }

    }

    else {

    #ifndef mxNoArrayOverallocation

      if (growable) {

        txSize capacity = fxSizeToCapacity(the, size);

        chunk = (txSlot*)fxNewGrowableChunk(the, size, capacity);

      }

      else

    #endif

        chunk = (txSlot*)fxNewChunk(the, size);

    }

    if (current < target)

      c_memset(chunk + current, 0, (target - current) * sizeof(txSlot));

    array->value.array.length = target;

    array->value.array.address = chunk;

  }

}

txBoolean fxDefinePrivateProperty(txMachine* the, txSlot* instance, txSlot* check, txID id, txSlot* slot, txFlag mask) 

{

  txSlot** address;

  txSlot* property;

  mxCheck(the, instance->kind == XS_INSTANCE_KIND);

#if mxAliasInstance

  if (instance->ID) {

    txSlot* alias = the->aliasArray[instance->ID];

    if (alias)

      instance = alias;

    else

      instance = fxAliasInstance(the, instance);

  }

  if (instance->flag & XS_MARK_FLAG)

    return 0;

#else

  if (instance->flag & XS_DONT_MARSHALL_FLAG)

    return 0;

#endif

  if (mxIsModule(instance)) {

    instance = mxModuleInstanceExports(instance)->value.reference;

  }

  address = &(instance->next);

  while ((property = *address)) {

    if (!(property->flag & XS_INTERNAL_FLAG)) {

      property = C_NULL;

      break;

    }

    if (property->kind == XS_PRIVATE_KIND) {

      if (property->value.private.check == check) {

        break;

      }

    }

    address = &(property->next);

  }

  if (!property) {

    property = fxNewSlot(the);

    property->next = *address;

    property->flag = XS_INTERNAL_FLAG;

    property->kind = XS_PRIVATE_KIND;

    property->value.private.check = check;

    property->value.private.first = C_NULL;

    *address = property;

  }

  address = &(property->value.private.first);

  while ((property = *address)) {

    if (property->ID == id)

      break;

    address = &(property->next);

  }

  if (mask & XS_ACCESSOR_FLAG) {

    if (property) {

      if (property->kind != XS_ACCESSOR_KIND)

        return 0;

    }

    else {

      *address = property = fxNewSlot(the);

      property->ID = id;

      property->kind = XS_ACCESSOR_KIND;

      property->value.accessor.getter = C_NULL;

      property->value.accessor.setter = C_NULL;

    }

    if (mask & XS_GETTER_FLAG) {

      txSlot* function = slot->value.accessor.getter;

      if (property->value.accessor.getter)

        return 0;

      property->value.accessor.getter = function;

      if (mxIsFunction(function)) {

        if (((mask & XS_METHOD_FLAG) && (function->flag & XS_MARK_FLAG) == 0)) {

          txSlot* home = mxFunctionInstanceHome(function);

          home->value.home.object = instance;

        }

        if ((mask & XS_NAME_FLAG) && ((function->flag & XS_MARK_FLAG) == 0))

          fxRenameFunction(the, function, id, 0, mxID(_get), "get ");

      }

    }

    else {

      txSlot* function = slot->value.accessor.setter;

      if (property->value.accessor.setter)

        return 0;

      property->value.accessor.setter = function;

      if (mxIsFunction(function)) {

        if (((mask & XS_METHOD_FLAG) && (function->flag & XS_MARK_FLAG) == 0)) {

          txSlot* home = mxFunctionInstanceHome(function);

          home->value.home.object = instance;

        }

        if ((mask & XS_NAME_FLAG) && ((function->flag & XS_MARK_FLAG) == 0))

          fxRenameFunction(the, function, id, 0, mxID(_set), "set ");

      }

    }

  }

  else {

    if (property)

      return 0;

    *address = property = fxNewSlot(the);

    property->flag = (mask & XS_METHOD_FLAG) ? XS_DONT_SET_FLAG : XS_NO_FLAG;

    property->ID = id;

    property->kind = slot->kind;

    property->value = slot->value;

    if (property->kind == XS_REFERENCE_KIND) {

      txSlot* function = slot->value.reference;

      if (mxIsFunction(function)) {

        if ((mask & XS_METHOD_FLAG) && ((function->flag & XS_MARK_FLAG) == 0)) {

          txSlot* home = mxFunctionInstanceHome(function);

          home->value.home.object = instance;

        }

        if ((mask & XS_NAME_FLAG) && ((function->flag & XS_MARK_FLAG) == 0))

          fxRenameFunction(the, function, id, 0, mxID(_value), C_NULL);

      }

    }

  }

  return 1;

}

txSlot* fxGetPrivateProperty(txMachine* the, txSlot* instance, txSlot* check, txID id) 

{

    txSlot* result;

  mxCheck(the, instance->kind == XS_INSTANCE_KIND);

#if mxAliasInstance

  if (instance->ID) {

    txSlot* alias = the->aliasArray[instance->ID];

    if (alias)

      instance = alias;

  }

#endif

  if (mxIsModule(instance)) {

    instance = mxModuleInstanceExports(instance)->value.reference;

  }

  result = instance->next;

  while (result) {

    if (result->kind == XS_PRIVATE_KIND) {

      if (result->value.private.check == check)

        break;

    }

    result = result->next;

  }

  if (result) {

    result = result->value.private.first;

    while (result) {

      if (result->ID == id)

        break;

      result = result->next;

    }

  }

  if (result) {

    if ((result->kind == XS_ACCESSOR_KIND) && (result->value.accessor.getter == C_NULL))

      result = C_NULL;

  }

  return result;

}

txSlot* fxSetPrivateProperty(txMachine* the, txSlot* instance, txSlot* check, txID id) 

{

    txSlot* result;

  mxCheck(the, instance->kind == XS_INSTANCE_KIND);

#if mxAliasInstance

  if (instance->ID) {

    txSlot* alias = the->aliasArray[instance->ID];

    if (alias)

      instance = alias;

    else

      instance = fxAliasInstance(the, instance);

  }

#endif

  if (mxIsModule(instance)) {

    instance = mxModuleInstanceExports(instance)->value.reference;

  }

  result = instance->next;

  while (result) {

    if (result->kind == XS_PRIVATE_KIND) {

      if (result->value.private.check == check)

        break;

    }

    result = result->next;

  }

  if (result) {

    result = result->value.private.first;

    while (result) {

      if (result->ID == id)

        break;

      result = result->next;

    }

  }

  if (result) {

    if ((result->kind == XS_ACCESSOR_KIND) && (result->value.accessor.setter == C_NULL))

      result = C_NULL;

  }

  return result;

}

void fxGroupBy(txMachine* the, txCallback aux) 

{

  txSlot *function, *iterable, *iterator, *next, *value, *slot;

  txNumber k = 0;

  if ((mxArgc < 1) || mxIsUndefined(mxArgv(0)) || mxIsUndefined(mxArgv(1)))

    mxTypeError("items: not an object");

  if ((mxArgc < 2) || (!fxIsCallable(the, mxArgv(1))))

    mxTypeError("callback: not a function");

  function = mxArgv(1);

  iterable = mxArgv(0);

  mxTemporary(iterator);

  mxTemporary(next);

  fxGetIterator(the, iterable, iterator, next, 0);

  mxTemporary(value);

  while (fxIteratorNext(the, iterator, next, value)) {

    mxTry(the) {

      if (k > C_MAX_SAFE_INTEGER)

        mxTypeError("unsafe integer");

      mxPushUndefined();

      mxPushSlot(function);

      mxCall();

      mxPushSlot(value);

      mxPushNumber(k);

      mxRunCount(2);

      aux(the);

      slot = the->stack->value.reference->next;

      slot->value.array.length++;

      while (slot->next)

        slot = slot->next;

      slot->next = fxDuplicateSlot(the, value);

      mxPop();

      mxPop();

      k++;

    }

    mxCatch(the) {

      fxIteratorReturn(the, iterator, 1);

      fxJump(the);

    }

  }

  mxPop();

  mxPop();

  mxPop();

}