/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 <android/base/string/string_utils.h>
#include <base/ViewUtils.h>
#include <android/jsengine/api/WeexJSCoreApi.h>
#include "ExtendJSApi.h"

using namespace WeexCore;

WeexCore::FunType gCanvasFunc = nullptr;

WeexCore::FunTypeT3d t3dFunc = nullptr;

/**
* This class aim to extend JS Api
**/
ExtendJSApi::ExtendJSApi() {
}

void ExtendJSApi::initFunction(IPCHandler *handler) {
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::SETJSFVERSION),
                           handleSetJSVersion);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::REPORTEXCEPTION),
                           handleReportException);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::CALLNATIVE),
                           handleCallNative);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::CALLNATIVEMODULE),
                           handleCallNativeModule);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::CALLNATIVECOMPONENT),
                           handleCallNativeComponent);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::CALLADDELEMENT),
                           handleCallAddElement);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::SETTIMEOUT),
                           handleSetTimeout);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::NATIVELOG),
                           handleCallNativeLog);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::CALLCREATEBODY),
                           functionCallCreateBody);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::CALLUPDATEFINISH),
                           functionCallUpdateFinish);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::CALLCREATEFINISH),
                           functionCallCreateFinish);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::CALLREFRESHFINISH),
                           functionCallRefreshFinish);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::CALLUPDATEATTRS),
                           functionCallUpdateAttrs);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::CALLUPDATESTYLE),
                           functionCallUpdateStyle);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::CALLREMOVEELEMENT),
                           functionCallRemoveElement);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::CALLMOVEELEMENT),
                           functionCallMoveElement);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::CALLADDEVENT),
                           functionCallAddEvent);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::CALLREMOVEEVENT),
                           functionCallRemoveEvent);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::SETINTERVAL),
                           handleSetInterval);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::CLEARINTERVAL),
                           handleClearInterval);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::CALLGCANVASLINK),
                           handleCallGCanvasLinkNative);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::CALLT3DLINK),
                           handleT3DLinkNative);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::POSTMESSAGE),
                           handlePostMessage);
  handler->registerHandler(static_cast<uint32_t>(IPCProxyMsg::DISPATCHMESSAGE),
                           handleDispatchMessage);
}

std::unique_ptr<IPCResult> handleSetJSVersion(IPCArguments *arguments) {
  const char* version = getArumentAsCStr(arguments, 0);
  _setJSVersion(version);
  return createVoidResult();
}


std::unique_ptr<IPCResult> handleReportException(IPCArguments *arguments) {
  const char *pageId = nullptr;
  const char *func = nullptr;
  const char *exceptionInfo = nullptr;

  if (arguments->getType(0) == IPCType::BYTEARRAY) {
    const IPCByteArray *instanceIDBA = arguments->getByteArray(0);
    pageId = instanceIDBA->content;
  }

  if (arguments->getType(1) == IPCType::BYTEARRAY) {
    const IPCByteArray *funcBA = arguments->getByteArray(1);
    func = funcBA->content;
  }

  if (arguments->getType(2) == IPCType::BYTEARRAY) {
    const IPCByteArray *exceptionInfoBA = arguments->getByteArray(2);
    exceptionInfo = exceptionInfoBA->content;
  }

  LOGE(" ReportException : %s", exceptionInfo);
  _reportException(pageId, func, exceptionInfo);
  return createVoidResult();
}

std::unique_ptr<IPCResult> handle(IPCArguments *arguments) {
  const char* str_array = getArumentAsCStr(arguments, 0);
  Bridge_Impl_Android::getInstance()->callNativeLog(str_array);
  return createInt32Result(static_cast<int32_t>(true));
}

std::unique_ptr<IPCResult> handleCallNativeLog(IPCArguments *arguments) {
  const char* str_array = getArumentAsCStr(arguments, 0);
  _callNativeLog(str_array);
  return createInt32Result(static_cast<int32_t>(true));
}

std::unique_ptr<IPCResult> handleSetTimeout(IPCArguments *arguments) {
  char* callbackID = getArumentAsCStr(arguments, 0);
  char* time = getArumentAsCStr(arguments, 1);

  if (callbackID == nullptr || time == nullptr)
    return createInt32Result(static_cast<int32_t>(false));

  _setTimeout(callbackID,time);

  if (callbackID != nullptr) {
    delete[]callbackID;
    callbackID = nullptr;
  }
  if (time != nullptr) {
    delete[]time;
    time = nullptr;
  }
  return createInt32Result(static_cast<int32_t>(true));
}

std::unique_ptr<IPCResult> handleSetInterval(IPCArguments *arguments) {
  const char *pageId = getArumentAsCStr(arguments, 0);
  const char *callbackID = getArumentAsCStr(arguments, 1);
  const char *_time = getArumentAsCStr(arguments, 2);
  if (pageId == nullptr || callbackID == nullptr || _time == nullptr)
    return createInt32Result(-1);

  long time_ = atoi(_time);
  int _timerId = _setInterval(pageId,callbackID,_time);

  if (pageId != nullptr) {
    delete[]pageId;
    pageId = nullptr;
  }
  if (callbackID != nullptr) {
    delete[]callbackID;
    callbackID = nullptr;
  }
  if (_time != nullptr) {
    delete[]_time;
    _time = nullptr;
  }
  return createInt32Result(_timerId);
}

std::unique_ptr<IPCResult> handleClearInterval(IPCArguments *arguments) {
  const char *pageId = getArumentAsCStr(arguments, 0);
  const char *callbackID = getArumentAsCStr(arguments, 1);
  long id = atoi(callbackID);

  if (pageId != nullptr) {
    delete[]pageId;
    pageId = nullptr;
  }
  if (callbackID != nullptr) {
    delete[]callbackID;
    callbackID = nullptr;
  }
  return createVoidResult();
}

std::unique_ptr<IPCResult> handleCallNative(IPCArguments *arguments) {
  char* pageId = getArumentAsCStr(arguments, 0);
  char* task = getArumentAsCStr(arguments, 1);
  char* callback = getArumentAsCStr(arguments, 2);

    _callNative(pageId, task, callback);

  if (pageId != nullptr) {
    delete[]pageId;
    pageId = nullptr;
  }
  if (task != nullptr) {
    delete[]task;
    task = nullptr;
  }
  if (callback != nullptr) {
    delete[]callback;
    callback = nullptr;
  }
  return createInt32Result(0);
}

static std::unique_ptr<IPCResult> handleCallGCanvasLinkNative(IPCArguments *arguments) {
  JNIEnv *env = getJNIEnv();
  jstring jPageId = getArgumentAsJString(env, arguments, 0);
  const char *pageId = env->GetStringUTFChars(jPageId, NULL);
  int type = getArgumentAsInt32(env, arguments, 1);
  jstring val = getArgumentAsJString(env, arguments, 2);
  const char *args = env->GetStringUTFChars(val, NULL);

#if JSAPI_LOG
  LOGD("[ExtendJSApi] handleCallGCanvasLinkNative >>>> pageId: %s, type: %d, args: %s", pageId, type, args);
#endif

  const char *retVal = _callGCanvasLinkNative(pageId,type,args);

  std::unique_ptr<IPCResult> ret = createVoidResult();
  if (retVal) {
    jstring jDataStr = env->NewStringUTF(retVal);
    ret = std::move(createStringResult(env, jDataStr));
    env->DeleteLocalRef(jDataStr);
    retVal = NULL;
  }
  env->DeleteLocalRef(jPageId);
  env->DeleteLocalRef(val);
  return ret;
}

static std::unique_ptr<IPCResult> handleT3DLinkNative(IPCArguments* arguments)
{
  JNIEnv* env = getJNIEnv();
  int type = getArgumentAsInt32(env, arguments, 0);
  jstring val = getArgumentAsJString(env, arguments, 1);
  const char* args = env->GetStringUTFChars(val, NULL);

#if JSAPI_LOG
  LOGD("[ExtendJSApi] handleT3DLinkNative >>>> type: %d, args: %s", type, args);
#endif

  const char*retVal = _t3dLinkNative(type, args);

  std::unique_ptr<IPCResult> ret = createVoidResult();
  if (retVal) {
    jstring jDataStr = env->NewStringUTF(retVal);
    ret = std::move(createStringResult(env, jDataStr));
    env->DeleteLocalRef(jDataStr);
    retVal = NULL;
  }
  env->DeleteLocalRef(val);
  return ret;
}

std::unique_ptr<IPCResult> handleCallNativeModule(IPCArguments *arguments) {
  char* pageId = getArumentAsCStr(arguments, 0);
  char* module = getArumentAsCStr(arguments, 1);
  char* method = getArumentAsCStr(arguments, 2);
  char* argumentsData = getArumentAsCStr(arguments, 3);
  int   argumentsDataLength = getArumentAsCStrLen(arguments, 3);
  char* optionsData = getArumentAsCStr(arguments, 4);
  int   optionsDataLength = getArumentAsCStrLen(arguments, 4);

  std::unique_ptr<IPCResult> ret = _callNativeModule(pageId,module,method,argumentsData,
                                                     argumentsDataLength, optionsData, optionsDataLength);

  if (pageId != nullptr) {
    delete[]pageId;
    pageId = nullptr;
  }
  if (module != nullptr) {
    delete[]module;
    module = nullptr;
  }
  if (method != nullptr) {
    delete[]method;
    method = nullptr;
  }
  if (argumentsData != nullptr) {
    delete[]argumentsData;
    argumentsData = nullptr;
  }
  if (optionsData != nullptr) {
    delete[]optionsData;
    optionsData = nullptr;
  }
  return ret;
}

std::unique_ptr<IPCResult> handleCallNativeComponent(IPCArguments *arguments) {
  char* pageId = getArumentAsCStr(arguments, 0);
  char* ref = getArumentAsCStr(arguments, 1);
  char* method = getArumentAsCStr(arguments, 2);
  char* argumentsData = getArumentAsCStr(arguments, 3);
  int   argumentsDataLength = getArumentAsCStrLen(arguments, 3);
  char* optionsData = getArumentAsCStr(arguments, 4);
  int   optionsDataLength = getArumentAsCStrLen(arguments, 4);

  _callNativeComponent(pageId, ref, method, argumentsData, argumentsDataLength, optionsData, optionsDataLength);

  if (pageId != nullptr) {
    delete[]pageId;
    pageId = nullptr;
  }
  if (ref != nullptr) {
    delete[]ref;
    ref = nullptr;
  }
  if (method != nullptr) {
    delete[]method;
    method = nullptr;
  }
  if (argumentsData != nullptr) {
    delete[]argumentsData;
    argumentsData = nullptr;
  }
  if (optionsData != nullptr) {
    delete[]optionsData;
    optionsData = nullptr;
  }
  return createInt32Result(static_cast<int32_t>(true));
}

std::unique_ptr<IPCResult> functionCallCreateBody(IPCArguments *arguments) {

  char *pageId = getArumentAsCStr(arguments, 0);
  char *domStr = getArumentAsCStr(arguments, 1);

  if (pageId == nullptr || domStr == nullptr)
    return createInt32Result(0);

  _callCreateBody(pageId,domStr);

  delete[]pageId;
  delete[]domStr;
  return createInt32Result(0);
}

std::unique_ptr<IPCResult> handleCallAddElement(IPCArguments *arguments) {

  char *pageId = getArumentAsCStr(arguments, 0);
  char *parentRef = getArumentAsCStr(arguments, 1);
  char *domStr = getArumentAsCStr(arguments, 2);
  char *index_cstr = getArumentAsCStr(arguments, 3);

    _callAddElement(pageId,parentRef,domStr,index_cstr);

  delete[]pageId;
  delete[]parentRef;
  delete[]domStr;
  delete[]index_cstr;
  return createInt32Result(0);
}

std::unique_ptr<IPCResult> functionCallRemoveElement(IPCArguments *arguments) {

  char *pageId = getArumentAsCStr(arguments, 0);
  char *ref = getArumentAsCStr(arguments, 1);

  if (pageId == nullptr || ref == nullptr)
    return createInt32Result(0);

 _callRemoveElement(pageId,ref);

  delete[]pageId;
  delete[]ref;
  return createInt32Result(0);
}

std::unique_ptr<IPCResult> functionCallMoveElement(IPCArguments *arguments) {

  char *pageId = getArumentAsCStr(arguments, 0);
  char *ref = getArumentAsCStr(arguments, 1);
  char *parentRef = getArumentAsCStr(arguments, 2);
  char *index_str = getArumentAsCStr(arguments, 3);
  int index = atoi(index_str);

  if (pageId == nullptr || ref == nullptr || parentRef == nullptr || index_str == nullptr ||
      index < -1)
    return createInt32Result(0);

  _callMoveElement(pageId, ref, parentRef, index);

  delete[]pageId;
  delete[]ref;
  delete[]parentRef;
  delete[]index_str;
  return createInt32Result(0);
}

std::unique_ptr<IPCResult> functionCallAddEvent(IPCArguments *arguments) {

  char *pageId = getArumentAsCStr(arguments, 0);
  char *ref = getArumentAsCStr(arguments, 1);
  char *event = getArumentAsCStr(arguments, 2);

  if (pageId == nullptr || ref == nullptr || event == nullptr)
    return createInt32Result(0);

  _callAddEvent(pageId,ref,event);

  delete[]pageId;
  delete[]ref;
  delete[]event;
  return createInt32Result(0);
}

std::unique_ptr<IPCResult> functionCallRemoveEvent(IPCArguments *arguments) {

  char *pageId = getArumentAsCStr(arguments, 0);
  char *ref = getArumentAsCStr(arguments, 1);
  char *event = getArumentAsCStr(arguments, 2);

  if (pageId == nullptr || ref == nullptr || event == nullptr)
    return createInt32Result(0);

 _callRemoveEvent(pageId,ref,event);

  delete[]pageId;
  delete[]ref;
  delete[]event;
  return createInt32Result(0);
}

std::unique_ptr<IPCResult> functionCallUpdateStyle(IPCArguments *arguments) {

  char *pageId = getArumentAsCStr(arguments, 0);
  char *ref = getArumentAsCStr(arguments, 1);
  char *data = getArumentAsCStr(arguments, 2);

  if (pageId == nullptr || ref == nullptr || data == nullptr)
    return createInt32Result(0);

  _callUpdateStyle(pageId,ref,data);

  delete[] pageId;
  delete[] ref;
  delete[] data;
  return createInt32Result(0);
}

std::unique_ptr<IPCResult> functionCallUpdateAttrs(IPCArguments *arguments) {

  char *pageId = getArumentAsCStr(arguments, 0);
  char *ref = getArumentAsCStr(arguments, 1);
  char *data = getArumentAsCStr(arguments, 2);

  if (pageId == nullptr || ref == nullptr || data == nullptr)
    return createInt32Result(0);

 _callUpdateAttrs(pageId, ref,data);

  delete[] pageId;
  delete[] ref;
  delete[] data;
  return createInt32Result(0);
}

std::unique_ptr<IPCResult> functionCallCreateFinish(IPCArguments *arguments) {

  char *pageId = getArumentAsCStr(arguments, 0);

  if (pageId == nullptr)
    return createInt32Result(0);

 _callCreateFinish(pageId);

  delete[]pageId;
  return createInt32Result(0);
}

std::unique_ptr<IPCResult> functionCallUpdateFinish(IPCArguments *arguments) {
  char *pageId = getArumentAsCStr(arguments, 0);
  char *task = getArumentAsCStr(arguments, 1);
  char *callback = getArumentAsCStr(arguments, 2);

  int flag = 0;

  if (pageId == nullptr || task == nullptr)
    return createInt32Result(flag);

  flag = _callUpdateFinish(pageId,task,callback);

  if (pageId != nullptr) {
    delete[]pageId;
    pageId = nullptr;
  }
  if (task != nullptr) {
    delete[]task;
    task = nullptr;
  }
  if (callback != nullptr) {
    delete[]callback;
    callback = nullptr;
  }
  return createInt32Result(flag);
}

std::unique_ptr<IPCResult> functionCallRefreshFinish(IPCArguments *arguments) {
  char *pageId = getArumentAsCStr(arguments, 0);
  char *task = getArumentAsCStr(arguments, 1);
  char *callback = getArumentAsCStr(arguments, 2);

  int flag = 0;

  if (pageId == nullptr)
    return createInt32Result(flag);

  flag = _callRefreshFinish(pageId, task, callback);

  if (pageId != nullptr) {
    delete[]pageId;
    pageId = nullptr;
  }
  if (task != nullptr) {
    delete[]task;
    task = nullptr;
  }
  if (callback != nullptr) {
    delete[]callback;
    callback = nullptr;
  }
  return createInt32Result(flag);
}

std::unique_ptr<IPCResult> handlePostMessage(IPCArguments *arguments) {
  // LOGE("handlePostMessage");
  JNIEnv* env = getJNIEnv();
  jbyteArray jData = getArgumentAsJByteArray(env, arguments, 0);
  jstring jVmId = getArgumentAsJString(env, arguments, 1);
//  if (jPostMessage == NULL) {
//    jPostMessage = env->GetMethodID(jWMBridgeClazz,
//                                    "postMessage",
//                                    "(Ljava/lang/String;[B)V");
//  }
//  env->CallVoidMethod(jWMThis, jPostMessage, jVmId, jData);
  Bridge_Impl_Android::getInstance()->handlePostMessage(jVmId, jData);
  env->DeleteLocalRef(jData);
  env->DeleteLocalRef(jVmId);

  return createInt32Result(static_cast<int32_t>(true));

}

std::unique_ptr<IPCResult> handleDispatchMessage(IPCArguments *arguments) {
  // LOGE("handleDispatchMessage");
  JNIEnv* env = getJNIEnv();
  jstring jClientId = getArgumentAsJString(env, arguments, 0);
  jbyteArray jData = getArgumentAsJByteArray(env, arguments, 1);
  jstring jCallback = getArgumentAsJString(env, arguments, 2);
  jstring jVmId = getArgumentAsJString(env, arguments, 3);
//  if (jDispatchMeaasge == NULL) {
//    jDispatchMeaasge = env->GetMethodID(jWMBridgeClazz,
//                                        "dispatchMessage",
//                                        "(Ljava/lang/String;Ljava/lang/String;[BLjava/lang/String;)V");
//  }
//  env->CallVoidMethod(jWMThis, jDispatchMeaasge, jClientId, jVmId, jData, jCallback);
  Bridge_Impl_Android::getInstance()->handleDispatchMessage(jClientId, jVmId, jData, jCallback);
  env->DeleteLocalRef(jClientId);
  env->DeleteLocalRef(jData);
  env->DeleteLocalRef(jCallback);
  return createInt32Result(static_cast<int32_t>(true));
}

namespace WeexCore {

  extern "C" void Inject_GCanvasFunc(FunType fp) {
    gCanvasFunc = fp;
    LOGE("weexjsc injectGCanvasFunc gCanvasFunc");
  }

  const char *callGCanvasFun(FunType fp, const char *conextId, int x, const char *args) {
    return fp(conextId, x, args);
  }

  extern "C" void Inject_T3dFunc(FunTypeT3d fp) {
    t3dFunc = fp;
    LOGE("weexjsc Inject_T3dFunc t3d Func");
  }

const char* weexCallT3dFunc(FunTypeT3d fp, int x, const char* args) {
  return fp(x, args);
}

}