#ifndef __NAPI_TEST_H__
#define __NAPI_TEST_H__

#include "napi/native_api.h"
#include <js_native_api_types.h>

#include <iostream>

#define NAPI_CLASS_NAME "NapiTestClass"

class NapiTest {
public:
  NapiTest() : mEnv(nullptr), mRef(nullptr) {
  }
    
  NapiTest(napi_env env) : mEnv(env), mRef(nullptr){
  }
  ~NapiTest();
    
    // 創(chuàng)建NapiTest類的實(shí)體，并將實(shí)體返回到應(yīng)用端，該方法為js創(chuàng)建一個類實(shí)體，因此需要將該接口對外導(dǎo)出
  static napi_value Create(napi_env env, napi_callback_info info);
    
    // 初始化js類并設(shè)置對應(yīng)屬性并將其導(dǎo)出   
  static napi_value Init(napi_env env, napi_value exports);         
private:
    
    // 設(shè)置數(shù)據(jù)，此方法給到j(luò)s直接調(diào)用，因此需要將該接口對外導(dǎo)出
  static napi_value SetMsg(napi_env env, napi_callback_info info);
    
    // 獲取數(shù)據(jù)，此方法給到j(luò)s直接調(diào)用，因此需要將該接口對外導(dǎo)出    
    static napi_value GetMsg(napi_env env, napi_callback_info info);
    
    // 定義js結(jié)構(gòu)體時(shí)實(shí)際的構(gòu)建函數(shù)
    static napi_value Constructor(napi_env env, napi_callback_info info);     

    // 釋放資源的函數(shù)(類似類的析構(gòu)函數(shù))    
    static void Destructor(napi_env env, void *nativeObject, void *finalize); 

    // 生命周期變量    
    static napi_ref sConstructor_;  

    // 設(shè)置和獲取數(shù)據(jù)的變量    
    static std::string _msg;        

    // 記錄環(huán)境變量    
    napi_env mEnv = nullptr;        

    // 記錄生命周期變量    
    napi_ref mRef = nullptr;        

};

#endif  /* __NAPI_TEST_H__ */

// 在定義js類之前，需要先設(shè)置類對外導(dǎo)出的方法
    napi_property_descriptor desc[] = {
        { "getMsg", nullptr, NapiTest::GetMsg, nullptr, nullptr, nullptr, napi_default, nullptr },
        { "setMsg", nullptr, NapiTest::SetMsg, nullptr, nullptr, nullptr, napi_default, nullptr },
        { "create", nullptr, NapiTest::Create, nullptr, nullptr, nullptr, napi_default, nullptr }
    };

typedef struct {
  // utf8name和name其中一個必須是NULL
  const char* utf8name;
  napi_value name;

  napi_callback method;
  napi_callback getter;
  napi_callback setter;
  napi_value value;

  napi_property_attributes attributes;
  void* data;
} napi_property_descriptor;

napi_value constructor = nullptr;

    // 定義與C++類相對應(yīng)的JavaScript類
    if (napi_define_class(env, NAPI_CLASS_NAME, NAPI_AUTO_LENGTH, Constructor, nullptr, sizeof(desc) / sizeof(desc[0]),
                          desc, &constructor) != napi_ok) {
        // "!="用來檢查兩個操作數(shù)的值是否相等，如果不相等則條件為真
        return nullptr;
    }

napi_status napi_define_class(napi_env env,
                          const char* utf8name,
                          size_t length,
                          napi_callback constructor,
                          void* data,
                          size_t property_count,
                          const napi_property_descriptor* properties,
                          napi_value* result);

napi_value NapiTest::Constructor(napi_env env, napi_callback_info info)
{
    napi_value undefineVar = nullptr, thisVar = nullptr;
    napi_get_undefined(env, &undefineVar);

    // 獲取傳入的參數(shù)對象，對象不為空，根據(jù)該參數(shù)創(chuàng)建實(shí)例并并綁定到該對象
    if (napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr) == napi_ok && thisVar != nullptr) {

        // 創(chuàng)建NapiTest 實(shí)例
        NapiTest *reference = new NapiTest(env);

        // 綁定實(shí)例到對象并獲取對象的生命周期
        if (napi_wrap(env, thisVar, reinterpret_cast<void *>(reference), NapiTest::Destructor, nullptr, &(reference->mRef)) == napi_ok) {
            return thisVar;
        }

        return thisVar;
    }
    
    return undefineVar;
}

void NapiTest::Destructor(napi_env env, void *nativeObject, void *finalize)
{
    // 釋放資源
    NapiTest *test = reinterpret_cast<NapiTest*>(nativeObject);
    test->~NapiTest();
}

void NapiTest::Destructor(napi_env env, void *nativeObject, void *finalize)
{
    // 類析構(gòu)函數(shù)，釋放資源
    NapiTest *test = reinterpret_cast<NapiTest*>(nativeObject);
    test->~NapiTest();
}

napi_status napi_wrap(napi_env env,
                  napi_value js_object,
                  void* native_object,
                  napi_finalize finalize_cb,
                  void* finalize_hint,
                  napi_ref* result);

napi_status napi_get_cb_info(napi_env env,              
                             napi_callback_info cbinfo, 
                             size_t* argc,                          
                             napi_value* argv,     
                             napi_value* this_arg, 
                             void** data)

// 創(chuàng)建生命周期，初始引用計(jì)數(shù)設(shè)為1
    if (napi_create_reference(env, constructor, 1, &sConstructor_) != napi_ok) {
        return nullptr;
    }

    // 設(shè)置NapiTest對象相關(guān)屬性并綁定到導(dǎo)出變量exports
    if (napi_set_named_property(env, exports, NAPI_CLASS_NAME, constructor) != napi_ok) {
        return nullptr;
    }

if (napi_create_reference(env, constructor , 1, &sConstructor_) != napi_ok) {
    return nullptr;
}

NAPI_EXTERN napi_status napi_create_reference(napi_env env,
                                              napi_value value,
                                              uint32_t initial_refcount,
                                              napi_ref* result);

//  設(shè)置constructor對象相關(guān)屬性并綁定到導(dǎo)出變量exports
if (napi_set_named_property(env, exports, NAPI_CLASS_NAME, constructor) !=  napi_ok) {
    return nullptr;
}

napi_status napi_set_named_property(napi_env env,
                                    napi_value object,
                                    const char* utf8Name,
                                    napi_value value);

napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);

napi_status napi_define_properties(napi_env env,
                                   napi_value object,
                                   size_t property_count,
                                   const napi_property_descriptor* properties);

napi_value NapiTest::Create(napi_env env, napi_callback_info info) {
    napi_status status;
    napi_value constructor = nullptr, result = nullptr;
    // 獲取生命周期變量
    status = napi_get_reference_value(env, sConstructor_, &constructor);

    // 創(chuàng)建生命周期內(nèi)的實(shí)例對象并將其返回
    status = napi_new_instance(env, constructor, 0, nullptr, &result);
    auto napiTest = new NapiTest();
    // 綁定實(shí)例類創(chuàng)建NapiTest到導(dǎo)出的對象result
    if (napi_wrap(env, result, reinterpret_cast<void *>(napiTest), Destructor,
        nullptr, &(napiTest->mRef)) == napi_ok) {
        return result;
    }
    
    return nullptr;
}

NAPI_EXTERN napi_status napi_get_reference_value(napi_env env,
                                                 napi_ref ref,
                                                 napi_value* result);

napi_status napi_new_instance(napi_env env,
                              napi_value cons,
                              size_t argc,
                              napi_value* argv,
                              napi_value* result)

export const create : () => NapiTest;
export class  NapiTest {
    setMsg(msg: string): void;
    getMsg(): string;
}

export class  NapiTest {
    create()；
    setMsg(msg: string): void;
    getMsg(): string;
}

# the minimum version of CMake.
cmake_minimum_required(VERSION 3.4.1)
project(ObjectWrapTest)

set(NATIVERENDER_ROOT_PATH ${CMAKE_CURRENT_SOURCE_DIR})

# 頭文件路徑
include_directories(${NATIVERENDER_ROOT_PATH}
                    ${NATIVERENDER_ROOT_PATH}/include)
# 動態(tài)庫源文件
add_library(entry SHARED hello.cpp NapiTest.cpp)
# 依賴libace_napi.z.so動態(tài)庫
target_link_libraries(entry PUBLIC libace_napi.z.so )

// 讓IDE不檢查文件語法
// @ts-nocheck 
import testNapi from "libentry.so";

@Entry
@Component

struct Index {
  @State message: string = '導(dǎo)出對象'
  @State nativePointer:number = 0

// 創(chuàng)建對象tt
  tt = testNapi.create();

  build() {
    Row() {
      Column() {
        Text(this.message)
          .fontSize(50)
          .fontWeight(FontWeight.Bold)
          .onClick(() => {
            console.info("[NapiTest] Test NAPI 2 + 3 = " + testNapi.add(2, 3));
            try{
              if (this.nativePointer == 0) {
                // log打印,在程序中添加 log
                console.info("[NapiTest] Test NAPI add(2, 3) 1");
                this.nativePointer = testNapi.add(2, 3)
                console.info("[NapiTest] Test NAPI add(2, 3) 2");

                this.tt.setMsg("2+3")
                console.info("[NapiTest] Test NAPI add(2, 3) 3");

              } else {

                console.info("[NapiTest] Test NAPI add(0, 0) 1");

                this.nativePointer = testNapi.add(0, 0)
                console.info("[NapiTest] Test NAPI add(0, 0) 2");

                this.tt.setMsg("4+5")
                console.info("[NapiTest] Test NAPI add(0, 0) 3");
              }
            } catch(e) {
              console.info("[NapiTest]Test NAPI error" + JSON.stringify(e));
            }
            console.info("[NapiTest]Test NAPI " + this.tt.getMsg() + " = " + this.nativePointer);
          })
      }
      .width('100%')
    }
    .height('100%')
  }

}