// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com

#include "../../include/javascript/IJavaScript.h"
#include "../../include/javascript/JS_Context.h"
#include "../../include/javascript/JS_Define.h"
#include "../../include/javascript/JS_EventHandler.h"
#include "../../include/javascript/JS_GlobalData.h"
#include "../../include/javascript/JS_Object.h"
#include "../../include/javascript/JS_Value.h"
#include "../../include/javascript/JavaScript.h"
#include "../../include/javascript/global.h"
#include "../../include/fpdfxfa/fpdfxfa_app.h"
#include "../../include/javascript/resource.h"

/* ---------------------------- global ---------------------------- */

// Helper class for compile-time calculation of hash values in order to
// avoid having global object initializers.
template <unsigned ACC, wchar_t... Ns>
struct CHash;

// Only needed to hash single-character strings.
template <wchar_t N>
struct CHash<N> {
  static const unsigned value = N;
};

template <unsigned ACC, wchar_t N>
struct CHash<ACC, N> {
  static const unsigned value = (ACC * 1313LLU + N) & 0xFFFFFFFF;
};

template <unsigned ACC, wchar_t N, wchar_t... Ns>
struct CHash<ACC, N, Ns...> {
  static const unsigned value = CHash<CHash<ACC, N>::value, Ns...>::value;
};

extern const unsigned int JSCONST_nStringHash =
    CHash<'s', 't', 'r', 'i', 'n', 'g'>::value;
extern const unsigned int JSCONST_nNumberHash =
    CHash<'n', 'u', 'm', 'b', 'e', 'r'>::value;
extern const unsigned int JSCONST_nBoolHash =
    CHash<'b', 'o', 'o', 'l', 'e', 'a', 'n'>::value;
extern const unsigned int JSCONST_nDateHash = CHash<'d', 'a', 't', 'e'>::value;
extern const unsigned int JSCONST_nObjectHash =
    CHash<'o', 'b', 'j', 'e', 'c', 't'>::value;
extern const unsigned int JSCONST_nFXobjHash =
    CHash<'f', 'x', 'o', 'b', 'j'>::value;
extern const unsigned int JSCONST_nNullHash = CHash<'n', 'u', 'l', 'l'>::value;
extern const unsigned int JSCONST_nUndefHash =
    CHash<'u', 'n', 'd', 'e', 'f', 'i', 'n', 'e', 'd'>::value;

#ifdef _DEBUG
class HashVerify {
 public:
  HashVerify();
} g_hashVerify;

HashVerify::HashVerify() {
  ASSERT(JSCONST_nStringHash ==
         JS_CalcHash(VALUE_NAME_STRING, wcslen(VALUE_NAME_STRING)));
  ASSERT(JSCONST_nNumberHash ==
         JS_CalcHash(VALUE_NAME_NUMBER, wcslen(VALUE_NAME_NUMBER)));
  ASSERT(JSCONST_nBoolHash ==
         JS_CalcHash(VALUE_NAME_BOOLEAN, wcslen(VALUE_NAME_BOOLEAN)));
  ASSERT(JSCONST_nDateHash ==
         JS_CalcHash(VALUE_NAME_DATE, wcslen(VALUE_NAME_DATE)));
  ASSERT(JSCONST_nObjectHash ==
         JS_CalcHash(VALUE_NAME_OBJECT, wcslen(VALUE_NAME_OBJECT)));
  ASSERT(JSCONST_nFXobjHash ==
         JS_CalcHash(VALUE_NAME_FXOBJ, wcslen(VALUE_NAME_FXOBJ)));
  ASSERT(JSCONST_nNullHash ==
         JS_CalcHash(VALUE_NAME_NULL, wcslen(VALUE_NAME_NULL)));
  ASSERT(JSCONST_nUndefHash ==
         JS_CalcHash(VALUE_NAME_UNDEFINED, wcslen(VALUE_NAME_UNDEFINED)));
}
#endif

BEGIN_JS_STATIC_CONST(CJS_Global)
END_JS_STATIC_CONST()

BEGIN_JS_STATIC_PROP(CJS_Global)
END_JS_STATIC_PROP()

BEGIN_JS_STATIC_METHOD(CJS_Global)
JS_STATIC_METHOD_ENTRY(setPersistent)
END_JS_STATIC_METHOD()

IMPLEMENT_SPECIAL_JS_CLASS(CJS_Global, global_alternate, global);

FX_BOOL CJS_Global::InitInstance(IFXJS_Context* cc) {
  CJS_Context* pContext = (CJS_Context*)cc;
  ASSERT(pContext != NULL);

  global_alternate* pGlobal = (global_alternate*)GetEmbedObject();
  ASSERT(pGlobal != NULL);

  pGlobal->Initial(pContext->GetReaderApp());

  return TRUE;
};

global_alternate::global_alternate(CJS_Object* pJSObject)
    : CJS_EmbedObj(pJSObject), m_pApp(NULL) {}

global_alternate::~global_alternate(void) {
  DestroyGlobalPersisitentVariables();
  CPDFXFA_App::GetInstance()->GetRuntimeFactory()->ReleaseGlobalData();
}

void global_alternate::Initial(CPDFDoc_Environment* pApp) {
  m_pApp = pApp;
  m_pGlobalData =
      CPDFXFA_App::GetInstance()->GetRuntimeFactory()->NewGlobalData(pApp);
  UpdateGlobalPersistentVariables();
}

FX_BOOL global_alternate::QueryProperty(const FX_WCHAR* propname) {
  return CFX_WideString(propname) != L"setPersistent";
}

FX_BOOL global_alternate::DelProperty(IFXJS_Context* cc,
                                      const FX_WCHAR* propname,
                                      CFX_WideString& sError) {
  js_global_data* pData = NULL;
  CFX_ByteString sPropName = CFX_ByteString::FromUnicode(propname);

  if (m_mapGlobal.Lookup(sPropName, (void*&)pData)) {
    pData->bDeleted = TRUE;
    return TRUE;
  }

  return FALSE;
}

FX_BOOL global_alternate::DoProperty(IFXJS_Context* cc,
                                     const FX_WCHAR* propname,
                                     CJS_PropValue& vp,
                                     CFX_WideString& sError) {
  if (vp.IsSetting()) {
    CFX_ByteString sPropName = CFX_ByteString::FromUnicode(propname);
    switch (vp.GetType()) {
      case VT_number: {
        double dData;
        vp >> dData;
        return SetGlobalVariables(sPropName, JS_GLOBALDATA_TYPE_NUMBER, dData,
                                  false, "", v8::Local<v8::Object>(), FALSE);
      }
      case VT_boolean: {
        bool bData;
        vp >> bData;
        return SetGlobalVariables(sPropName, JS_GLOBALDATA_TYPE_BOOLEAN, 0,
                                  bData, "", v8::Local<v8::Object>(), FALSE);
      }
      case VT_string: {
        CFX_ByteString sData;
        vp >> sData;
        return SetGlobalVariables(sPropName, JS_GLOBALDATA_TYPE_STRING, 0,
                                  false, sData, v8::Local<v8::Object>(), FALSE);
      }
      case VT_object: {
        JSObject pData;
        vp >> pData;
        return SetGlobalVariables(sPropName, JS_GLOBALDATA_TYPE_OBJECT, 0,
                                  false, "", pData, FALSE);
      }
      case VT_null: {
        return SetGlobalVariables(sPropName, JS_GLOBALDATA_TYPE_NULL, 0, false,
                                  "", v8::Local<v8::Object>(), FALSE);
      }
      case VT_undefined: {
        DelProperty(cc, propname, sError);
        return TRUE;
      }
      default:
        break;
    }
  } else {
    void* pVoid = nullptr;
    if (!m_mapGlobal.Lookup(CFX_ByteString::FromUnicode(propname), pVoid)) {
      vp.SetNull();
      return TRUE;
    }
    if (!pVoid) {
      vp.SetNull();
      return TRUE;
    }
    js_global_data* pData = (js_global_data*)pVoid;
    if (pData->bDeleted)
      return TRUE;

    switch (pData->nType) {
      case JS_GLOBALDATA_TYPE_NUMBER:
        vp << pData->dData;
        return TRUE;
      case JS_GLOBALDATA_TYPE_BOOLEAN:
        vp << pData->bData;
        return TRUE;
      case JS_GLOBALDATA_TYPE_STRING:
        vp << pData->sData;
        return TRUE;
      case JS_GLOBALDATA_TYPE_OBJECT: {
        v8::Local<v8::Object> obj =
            v8::Local<v8::Object>::New(vp.GetIsolate(), pData->pData);
        vp << obj;
        return TRUE;
      }
      case JS_GLOBALDATA_TYPE_NULL:
        vp.SetNull();
        return TRUE;
      default:
        break;
    }
  }
  return FALSE;
}

FX_BOOL global_alternate::setPersistent(IFXJS_Context* cc,
                                        const CJS_Parameters& params,
                                        CJS_Value& vRet,
                                        CFX_WideString& sError) {
  CJS_Context* pContext = static_cast<CJS_Context*>(cc);
  if (params.size() != 2) {
    sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
    return FALSE;
  }

  CFX_ByteString sName = params[0].ToCFXByteString();

  js_global_data* pData = NULL;
  if (m_mapGlobal.Lookup(sName, (void*&)pData)) {
    if (pData && !pData->bDeleted) {
      pData->bPersistent = params[1].ToBool();
      return TRUE;
    }
  }

  sError = JSGetStringFromID(pContext, IDS_STRING_JSNOGLOBAL);
  return FALSE;
}

void global_alternate::UpdateGlobalPersistentVariables() {
  ASSERT(m_pGlobalData != NULL);

  for (int i = 0, sz = m_pGlobalData->GetSize(); i < sz; i++) {
    CJS_GlobalData_Element* pData = m_pGlobalData->GetAt(i);
    ASSERT(pData != NULL);

    switch (pData->data.nType) {
      case JS_GLOBALDATA_TYPE_NUMBER:
        SetGlobalVariables(pData->data.sKey, JS_GLOBALDATA_TYPE_NUMBER,
                           pData->data.dData, false, "",
                           v8::Local<v8::Object>(), pData->bPersistent == 1);
        JS_PutObjectNumber(NULL, (JSFXObject)(*m_pJSObject),
                           pData->data.sKey.UTF8Decode().c_str(),
                           pData->data.dData);
        break;
      case JS_GLOBALDATA_TYPE_BOOLEAN:
        SetGlobalVariables(pData->data.sKey, JS_GLOBALDATA_TYPE_BOOLEAN, 0,
                           (bool)(pData->data.bData == 1), "",
                           v8::Local<v8::Object>(), pData->bPersistent == 1);
        JS_PutObjectBoolean(NULL, (JSFXObject)(*m_pJSObject),
                            pData->data.sKey.UTF8Decode().c_str(),
                            (bool)(pData->data.bData == 1));
        break;
      case JS_GLOBALDATA_TYPE_STRING:
        SetGlobalVariables(pData->data.sKey, JS_GLOBALDATA_TYPE_STRING, 0,
                           false, pData->data.sData, v8::Local<v8::Object>(),
                           pData->bPersistent == 1);
        JS_PutObjectString(NULL, (JSFXObject)(*m_pJSObject),
                           pData->data.sKey.UTF8Decode().c_str(),
                           pData->data.sData.UTF8Decode().c_str());
        break;
      case JS_GLOBALDATA_TYPE_OBJECT: {
        IJS_Runtime* pRuntime = JS_GetRuntime((JSFXObject)(*m_pJSObject));
        v8::Local<v8::Object> pObj = JS_NewFxDynamicObj(pRuntime, NULL, -1);

        PutObjectProperty(pObj, &pData->data);

        SetGlobalVariables(pData->data.sKey, JS_GLOBALDATA_TYPE_OBJECT, 0,
                           false, "", (JSObject)pObj, pData->bPersistent == 1);
        JS_PutObjectObject(NULL, (JSFXObject)(*m_pJSObject),
                           pData->data.sKey.UTF8Decode().c_str(),
                           (JSObject)pObj);
      } break;
      case JS_GLOBALDATA_TYPE_NULL:
        SetGlobalVariables(pData->data.sKey, JS_GLOBALDATA_TYPE_NULL, 0, false,
                           "", v8::Local<v8::Object>(),
                           pData->bPersistent == 1);
        JS_PutObjectNull(NULL, (JSFXObject)(*m_pJSObject),
                         pData->data.sKey.UTF8Decode().c_str());
        break;
    }
  }
}

void global_alternate::CommitGlobalPersisitentVariables() {
  ASSERT(m_pGlobalData != NULL);

  FX_POSITION pos = m_mapGlobal.GetStartPosition();
  while (pos) {
    CFX_ByteString name;
    js_global_data* pData = NULL;
    m_mapGlobal.GetNextAssoc(pos, name, (void*&)pData);

    if (pData) {
      if (pData->bDeleted) {
        m_pGlobalData->DeleteGlobalVariable(name);
      } else {
        switch (pData->nType) {
          case JS_GLOBALDATA_TYPE_NUMBER:
            m_pGlobalData->SetGlobalVariableNumber(name, pData->dData);
            m_pGlobalData->SetGlobalVariablePersistent(name,
                                                       pData->bPersistent);
            break;
          case JS_GLOBALDATA_TYPE_BOOLEAN:
            m_pGlobalData->SetGlobalVariableBoolean(name, pData->bData);
            m_pGlobalData->SetGlobalVariablePersistent(name,
                                                       pData->bPersistent);
            break;
          case JS_GLOBALDATA_TYPE_STRING:
            m_pGlobalData->SetGlobalVariableString(name, pData->sData);
            m_pGlobalData->SetGlobalVariablePersistent(name,
                                                       pData->bPersistent);
            break;
          case JS_GLOBALDATA_TYPE_OBJECT:
            // if (pData->pData)
            {
              CJS_GlobalVariableArray array;
              v8::Local<v8::Object> obj = v8::Local<v8::Object>::New(
                  GetJSObject()->GetIsolate(), pData->pData);
              ObjectToArray(obj, array);
              m_pGlobalData->SetGlobalVariableObject(name, array);
              m_pGlobalData->SetGlobalVariablePersistent(name,
                                                         pData->bPersistent);
            }
            break;
          case JS_GLOBALDATA_TYPE_NULL:
            m_pGlobalData->SetGlobalVariableNull(name);
            m_pGlobalData->SetGlobalVariablePersistent(name,
                                                       pData->bPersistent);
            break;
        }
      }
    }
  }
}

void global_alternate::ObjectToArray(v8::Local<v8::Object> pObj,
                                     CJS_GlobalVariableArray& array) {
  v8::Local<v8::Context> context = pObj->CreationContext();
  v8::Isolate* isolate = context->GetIsolate();
  v8::Local<v8::Array> pKeyList = JS_GetObjectElementNames(isolate, pObj);
  int nObjElements = pKeyList->Length();

  for (int i = 0; i < nObjElements; i++) {
    CFX_WideString ws =
        JS_ToString(isolate, JS_GetArrayElement(isolate, pKeyList, i));
    CFX_ByteString sKey = ws.UTF8Encode();

    v8::Local<v8::Value> v = JS_GetObjectElement(isolate, pObj, ws.c_str());
    FXJSVALUETYPE vt = GET_VALUE_TYPE(v);
    switch (vt) {
      case VT_number: {
        CJS_KeyValue* pObjElement = new CJS_KeyValue;
        pObjElement->nType = JS_GLOBALDATA_TYPE_NUMBER;
        pObjElement->sKey = sKey;
        pObjElement->dData = JS_ToNumber(isolate, v);
        array.Add(pObjElement);
      } break;
      case VT_boolean: {
        CJS_KeyValue* pObjElement = new CJS_KeyValue;
        pObjElement->nType = JS_GLOBALDATA_TYPE_BOOLEAN;
        pObjElement->sKey = sKey;
        pObjElement->dData = JS_ToBoolean(isolate, v);
        array.Add(pObjElement);
      } break;
      case VT_string: {
        CFX_ByteString sValue =
            CJS_Value(isolate, v, VT_string).ToCFXByteString();
        CJS_KeyValue* pObjElement = new CJS_KeyValue;
        pObjElement->nType = JS_GLOBALDATA_TYPE_STRING;
        pObjElement->sKey = sKey;
        pObjElement->sData = sValue;
        array.Add(pObjElement);
      } break;
      case VT_object: {
        CJS_KeyValue* pObjElement = new CJS_KeyValue;
        pObjElement->nType = JS_GLOBALDATA_TYPE_OBJECT;
        pObjElement->sKey = sKey;
        ObjectToArray(JS_ToObject(isolate, v), pObjElement->objData);
        array.Add(pObjElement);
      } break;
      case VT_null: {
        CJS_KeyValue* pObjElement = new CJS_KeyValue;
        pObjElement->nType = JS_GLOBALDATA_TYPE_NULL;
        pObjElement->sKey = sKey;
        array.Add(pObjElement);
      } break;
      default:
        break;
    }
  }
}

void global_alternate::PutObjectProperty(v8::Local<v8::Object> pObj,
                                         CJS_KeyValue* pData) {
  ASSERT(pData != NULL);

  for (int i = 0, sz = pData->objData.Count(); i < sz; i++) {
    CJS_KeyValue* pObjData = pData->objData.GetAt(i);
    ASSERT(pObjData != NULL);

    switch (pObjData->nType) {
      case JS_GLOBALDATA_TYPE_NUMBER:
        JS_PutObjectNumber(NULL, (JSObject)pObj,
                           pObjData->sKey.UTF8Decode().c_str(),
                           pObjData->dData);
        break;
      case JS_GLOBALDATA_TYPE_BOOLEAN:
        JS_PutObjectBoolean(NULL, (JSObject)pObj,
                            pObjData->sKey.UTF8Decode().c_str(),
                            (bool)(pObjData->bData == 1));
        break;
      case JS_GLOBALDATA_TYPE_STRING:
        JS_PutObjectString(NULL, (JSObject)pObj,
                           pObjData->sKey.UTF8Decode().c_str(),
                           pObjData->sData.UTF8Decode().c_str());
        break;
      case JS_GLOBALDATA_TYPE_OBJECT: {
        IJS_Runtime* pRuntime = JS_GetRuntime((JSFXObject)(*m_pJSObject));
        v8::Local<v8::Object> pNewObj = JS_NewFxDynamicObj(pRuntime, NULL, -1);
        PutObjectProperty(pNewObj, pObjData);
        JS_PutObjectObject(NULL, (JSObject)pObj,
                           pObjData->sKey.UTF8Decode().c_str(),
                           (JSObject)pNewObj);
      } break;
      case JS_GLOBALDATA_TYPE_NULL:
        JS_PutObjectNull(NULL, (JSObject)pObj,
                         pObjData->sKey.UTF8Decode().c_str());
        break;
    }
  }
}

void global_alternate::DestroyGlobalPersisitentVariables() {
  FX_POSITION pos = m_mapGlobal.GetStartPosition();
  while (pos) {
    CFX_ByteString name;
    js_global_data* pData = NULL;
    m_mapGlobal.GetNextAssoc(pos, name, (void*&)pData);
    delete pData;
  }

  m_mapGlobal.RemoveAll();
}

FX_BOOL global_alternate::SetGlobalVariables(const FX_CHAR* propname,
                                             int nType,
                                             double dData,
                                             bool bData,
                                             const CFX_ByteString& sData,
                                             JSObject pData,
                                             bool bDefaultPersistent) {
  if (propname == NULL)
    return FALSE;

  js_global_data* pTemp = NULL;
  m_mapGlobal.Lookup(propname, (void*&)pTemp);

  if (pTemp) {
    if (pTemp->bDeleted || pTemp->nType != nType) {
      pTemp->dData = 0;
      pTemp->bData = 0;
      pTemp->sData = "";
      pTemp->nType = nType;
    }

    pTemp->bDeleted = FALSE;

    switch (nType) {
      case JS_GLOBALDATA_TYPE_NUMBER: {
        pTemp->dData = dData;
      } break;
      case JS_GLOBALDATA_TYPE_BOOLEAN: {
        pTemp->bData = bData;
      } break;
      case JS_GLOBALDATA_TYPE_STRING: {
        pTemp->sData = sData;
      } break;
      case JS_GLOBALDATA_TYPE_OBJECT: {
        pTemp->pData.Reset(JS_GetRuntime(pData), pData);
      } break;
      case JS_GLOBALDATA_TYPE_NULL:
        break;
      default:
        return FALSE;
    }

    return TRUE;
  }

  js_global_data* pNewData = NULL;

  switch (nType) {
    case JS_GLOBALDATA_TYPE_NUMBER: {
      pNewData = new js_global_data;
      pNewData->nType = JS_GLOBALDATA_TYPE_NUMBER;
      pNewData->dData = dData;
      pNewData->bPersistent = bDefaultPersistent;
    } break;
    case JS_GLOBALDATA_TYPE_BOOLEAN: {
      pNewData = new js_global_data;
      pNewData->nType = JS_GLOBALDATA_TYPE_BOOLEAN;
      pNewData->bData = bData;
      pNewData->bPersistent = bDefaultPersistent;
    } break;
    case JS_GLOBALDATA_TYPE_STRING: {
      pNewData = new js_global_data;
      pNewData->nType = JS_GLOBALDATA_TYPE_STRING;
      pNewData->sData = sData;
      pNewData->bPersistent = bDefaultPersistent;
    } break;
    case JS_GLOBALDATA_TYPE_OBJECT: {
      pNewData = new js_global_data;
      pNewData->nType = JS_GLOBALDATA_TYPE_OBJECT;
      pNewData->pData.Reset(JS_GetRuntime(pData), pData);
      pNewData->bPersistent = bDefaultPersistent;
    } break;
    case JS_GLOBALDATA_TYPE_NULL: {
      pNewData = new js_global_data;
      pNewData->nType = JS_GLOBALDATA_TYPE_NULL;
      pNewData->bPersistent = bDefaultPersistent;
    } break;
    default:
      return FALSE;
  }

  m_mapGlobal.SetAt(propname, (void*)pNewData);

  return TRUE;
}

FXJSVALUETYPE GET_VALUE_TYPE(v8::Local<v8::Value> p) {
  const unsigned int nHash = JS_CalcHash(JS_GetTypeof(p));

  if (nHash == JSCONST_nUndefHash)
    return VT_undefined;
  if (nHash == JSCONST_nNullHash)
    return VT_null;
  if (nHash == JSCONST_nStringHash)
    return VT_string;
  if (nHash == JSCONST_nNumberHash)
    return VT_number;
  if (nHash == JSCONST_nBoolHash)
    return VT_boolean;
  if (nHash == JSCONST_nDateHash)
    return VT_date;
  if (nHash == JSCONST_nObjectHash)
    return VT_object;
  if (nHash == JSCONST_nFXobjHash)
    return VT_fxobject;

  return VT_unknown;
}