// 解题思路：找到数量最多的数字 
// 1. 可以用map ， 放进去每一个元素，然后更新这个元素的个数，最后查找map 中元素的第二位数值。（肯定可行，但是 时间复杂度 控件复杂度不合适）
// 如果只需要一次遍历 ， 就得找一个数值用来记录最大的数量，还得有一个标识，用来记录当前这个最大数量指向的是哪个数值
class Solution {
public:
    int majorityElement(vector<int>& nums) {
        int resultNum = nums[0]; // 保存当前最大的数值，默认第一位就是最多的    [1,2,3,4,2,2,3]
        int count = 0; // 保存最多的数据被记录了多少次
        for(int i = 0; i < nums.size(); i++) // 正常遍历操作
        {
            if(nums[i] == resultNum)  // 如果相等，那么 计数器加一
            {
                count ++;
            }else  // 如果不相等
            {
                count --;  // 计数器减少 一
                if(count == 0)  //当计数器归零的时候，更换一下最多的记录
                {
                    resultNum = nums[i];  // 认为当前的是最多的
                    count ++;  // 计数器自增
                }
            }
        }
        return resultNum;  // 返回当前认为记录最多的
    }
};

//解题思路：删除重复 ， 索引 index ， 然后判断下一个是不是跟当前的相同，如果相同，就不管，如果不相同 ，索引向后移动一位，当前放在当前的位置 
class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int length = nums.size(); // 获得长度
        if(length <= 1)
        {
            return length; // 小于等于 1 ，肯定就返回了
        }
        int i = 0; // 索引
        for(int j = 1 ; j < nums.size();++j) // 遍历
        {
            if(nums[i] != nums[j]) // 如果不相同
            {
                i++; // 索引后移动
                nums[i] = nums[j]; //当前的放在这个位置
            }
        }
        return i+1; // i 为索引 从 0 开始， 返回个数是 需要加一
    }
};

//解题思路：在没有看清要求的时候就在考虑，取出最后一节，然后逐个拼接在最前面的， 但是 o(1)的限制貌似不太好
//思路二 ， 最后几位逆序，然后逐个插入在数组最前面 ， （方法可行，但是每次插入一个数子，整个数组移动，不合适）
// 非常要注意一点 ， K 是移动的次数， 不是第几位 
// 先分模块儿 ， 再分
class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int numLen = nums.size(); // 获取nums 的长度
        if(k > numLen) // 如果超过数组本身长度
        {
            k = k % numLen; // 超过本身的就没必要去旋转
        }
      	// [1,2,3,4,5,6,7] 3 
      	// A [1,2,3,4]   B [5,6,7]
      	// 分为 A   B  两节 ，  第一节 ， 从 0 开始 到 numLen - 1 - k 长度结
        myRotate(nums, 0, numLen - 1 - k); // 处理以后是 [4,3,2,1]
        myRotate(nums, numLen - k, nums.size() - 1); // 第二节 从 上面长度结尾 后面的一位开始 ， 到整个数组的结尾 处理以后是 [7,6,5]
        myRotate(nums,0,nums.size() - 1); // 原本 [4,3,2,1,7,6,5]  整个翻转之后就变成了 [5,6,7,1,2,3,4]  符合需求
    }
    void myRotate(vector<int>& nums, int start, int end)  // 使用双指针 ，头结点和尾节点，然后两者之间交换
    {
        while(start < end)
        {
            int tmp  = nums[start];
            nums[start] = nums[end];
            nums[end] = tmp;
            start ++;
            end --;
        }
    }
};

//解题思路：一开始在没看清楚题目的时候就直接去写了， 因为看到类似的题目，另外一个是需要得到数组中存在最多的数字，但是忽略了一个点，没法记录多少次
// 回来继续考虑，因为知道map 存在两个数据 ，第一个可以作为key ， 第二个用来存放存在的数量，当然对于本题来讲，返回True 就可以了。于是代码如下

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        if(nums.size() <= 1) // 如果只有一个，或者这个数组就没内容，那么必须没有重复的
        {
            return false;
        }
        std::map <int ,int> myMap; // 定义用来存放的map  key 作为 数值 value 作为出现的次数
        std::map<int,int>::iterator it;  // 定义it ，服务于map
        for(int i = 0; i < nums.size();i++) // 一次遍历
        {
            it = myMap.find(nums[i]); // 查询是否存在
            if(it != myMap.end()) // 如果已经存在 ， 那么肯定这次是重复的
            {
                return true;
            }else{
                myMap[nums[i]] = 1; // 这里用来存放次数，这里是错误的，主要有用的是key
            }
        }
        return false;
    }
};

//解题思路：因为是从后面往前开始去处理 ， 竟然还是写了 i++  ， 真的是头大了。
// 解题思路是 ， 从最后一位开始，如果是 9，那么 设置数值为0，再往前遍历，如果数字小于 9 ， 那么自增，然后直接返回数组
// 对于最后的，如果变成了 00000 , 那么需要用一个新vector ，放入 当前的内容和最头部的 1
class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        int m_size = digits.size(); // 拿到vector 的length
        for(int i = m_size - 1; i >= 0 ; i--) // 倒叙遍历， 逐个获取
        {
            if(digits[i] != 9) // 如果当前数值不是  9 ， 那么 自增，然后返回数组
            {
                digits[i] += 1;
                return digits;
            }
            digits[i] = 0; // 如果是 9 ，还没返回出去 ，那么置为0
        }
        vector<int> vec(m_size + 1); // 都变成 0 了之后 ，返回 当前vector 
        vec[0] = 1; // 首位方置为 1
        return vec;
    }
};

// C++ 侧
// 按照规则要求需要先提供一个可以被JavaScript 调用的 getNewBuffer 函数
Nan::SetPrototypeMethod(tpl, "getNewBuffer", getNewBuffer); // 暴露JavaScript调用接口  在Init 函数中

void MyBuffer::getNewBuffer(const Nan::FunctionCallbackInfo<v8::Value> &info)
{
    Isolate *isolate = info.GetIsolate();  // 获取当前isolate
    v8::HandleScope scope(isolate);  // 持有当前 isolate
  // 获取 getNewBuffer 调用时候 第一个参数 并且转化为 V8local Onject
    v8::Local<v8::Object> infoObj = v8::Local<v8::Object>::Cast(info[0]); 
    unsigned char *buffer = (unsigned char *)node::Buffer::Data(infoObj); // 获取熟知的 char * buffer
    size_t size = node::Buffer::Length(infoObj); // 获取传递的buffer 长度
		// 对 buffer 长度的后半段进行数据 ‘ + 1’ 操作
    for (int i = 0; i < size; i++)
    {
        if (i > size / 2)
        {
            buffer[i] += 1;
        }
    }
  	// 在使用 Nan::NewBuffer 的时候一定要注意内存管理 ， 这里使用了 Nan::CopyBuffer  直接在这里返回处理后的buffer 
    info.GetReturnValue().Set(Nan::CopyBuffer((char *)buffer, size).ToLocalChecked());
}

// 用于保存和设置 JavaScript 回调函数
void MyBuffer::setCallback(const Nan::FunctionCallbackInfo<v8::Value> &info)
{
    v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext(); // get context
    Isolate *isolate = info.GetIsolate(); // get isolate
    Nan::HandleScope mscope;  // HandleScope
    v8::HandleScope scope(isolate); 
    Local<Value> arg = info[0]; // get input JavaScript callback
    if (!arg->IsFunction()) // 类型判断
    {
        return;
    }
    // 持久化存储 JavaScript callback
    v8::Local<v8::Function> func = v8::Local<v8::Function>::Cast(info[0]); // to Local function
    MyBuffer::getInstance()->callback.Reset(func); //放在 Nan::Persistent  持久化 JavaScript
    uv_async_init(uv_default_loop(), &MyBuffer::getInstance()->m_callback_async, async_on_callback);  // libuv init
    // 这里为了测试先在这里启动timer  多次调用请注意合理关闭timer
    MTimer *t = new MTimer();   // 这里timer 中开启了新的线程，所以需要考虑线程安全的内容  于是回调就绕不开 Libuv
    t->setInterval([&]() {
        MyBuffer::getInstance()->m_counter++;
        cout << "time is : " << MyBuffer::getInstance()->m_counter << endl;
        // 构造假数据
        string dataStr = "TimerCallBack count is " + to_string(MyBuffer::getInstance()->m_counter) + " hello ";
        MyCallbackData *m_data = new MyCallbackData();
        m_data->data = new char[strlen(dataStr.c_str()) + 1];
        strncpy(m_data->data, dataStr.c_str(), strlen(dataStr.c_str()));
        m_data->data[strlen(dataStr.c_str())] = '\0';
        m_data->size = strlen(dataStr.c_str());  // 目的 ， copy 这里构造的假数据，用于回调给JavaScript
        // 数据入队   线程安全方式入队
        MyBuffer::getInstance()->m_BufferData_l.enqueue(m_data);
      	// 通知libuv  异步句柄允许用户“唤醒”事件循环并获取从另一个线程调用的回调。
        uv_async_send(&MyBuffer::getInstance()->m_callback_async);  // 线程安全
    },
   20); // 20 Ms 回调一次
}

// 真正用于异步执行JavaScript 存放在C++ 中的回调函数。 由libuv 触发
void async_on_callback(uv_async_t *handle)
{   
    v8::Isolate *isolate = v8::Isolate::GetCurrent();  // isolate
    v8::HandleScope scope(isolate); // HandleScope 
    MyCallbackData *m_bufferData; // 数据出队
    while (MyBuffer::getInstance()->m_BufferData_l.try_dequeue(m_bufferData))
    {
        // 留意这个 copy 字段 ， 存在内存重新分配 使用时候要小心  v8 data 不在C++ 也不在JavaScript
        v8::Local<v8::Object> buferObj = Nan::CopyBuffer(m_bufferData->data, m_bufferData->size).ToLocalChecked();
        //std::string msg = std::string(m_bufferData->data,m_bufferData->size); //用于debug 输出
        //std::cout << "---" <<  msg << std::endl; // 用于debug 输出
        delete [](m_bufferData->data);  // 记得销毁之前分配的buffer
        delete(m_bufferData); // delete 之前new 出来的对象
        m_bufferData = nullptr; // 指针置空
				//准备返回 JavaScript 数据
        const unsigned argc = 1;  
        v8::Local<v8::Value> argv[argc] = {buferObj};
        try
        {		// C++ 方式try catch （不是很必要）  // 下面这一行是从 Nan::Persistent function 转化为  local function 
            v8::Local<v8::Function> m_call = v8::Local<v8::Function>::New(isolate, MyBuffer::getInstance()->callback);
            Nan::Call(m_call, isolate->GetCurrentContext()->Global(), argc, argv); // 执行回调
        }
        catch (const std::exception &e)
        {
            std::cerr << e.what() << '\n';
        }
    }
}

// Libuv 需要以下
uv_async_init(); // 初始化异步回调
uv_async_send(); // 子线程发起事件
void async_on_callback(uv_async_t *handle); // 执行异步回调

 // 用于主线程监听，在收到libuv 回调之后在合适时机执行
 static void async_on_message(uv_async_t *handle);
// 用 Nan::Persistent 来持久化 JavaScript 提供的CallBack
 Nan::Persistent<v8::Function> m_callBack;
// Async handle 用于触发，唤起 回调函数， 可以从其他线程触发
 uv_async_t m_async;

// libuv 回调
void BeautyFaceInterface::async_on_message(uv_async_t *handle)
{
    Nan::HandleScope m_scope;
  	// isolate 需要临时获取，一定不要存储
    v8::Isolate *isolate = v8::Isolate::GetCurrent();
    v8::HandleScope scope(isolate);
  	//get finalResult
  	...
    ...
  
  	v8::Local<v8::Integer> v8_width = v8::Integer::New(isolate, (int)finalResult.cols);
  	v8::Local<v8::Integer> v8_height = v8::Integer::New(isolate, (int)finalResult.rows);
  	// CopyBuffer 注意内存， 深度拷贝， 因为nan 使用了 c++ 跟 JavaScript Buffer 共享， 需要在 JavaScript 使用完成Buffer 之后置空操作，让内存释放
  	v8::Local<v8::Object> buffer = Nan::CopyBuffer((char *)finalResult.data, len).ToLocalChecked();
  	v8::Local<v8::Value> argv[] = {v8_width, v8_height, buffer};
  	const unsigned argc = 3;
  
    v8::Local<v8::Function> m_call = Nan::New(BeautyFaceInterface::getInstance()->m_callBack);
	  TryCatch try_catch;
    m_call->Call(isolate->GetCurrentContext()->Global(), argc, argv);
    if (try_catch.HasCaught()) 
    {
        FatalException(try_catch);
    }
}

// libuv Callback 初始化和 回调函数设置
void BeautyFaceInterface::start(const Nan::FunctionCallbackInfo<v8::Value> &args)
{
    Isolate *isolate = args.GetIsolate();
    v8::HandleScope scope(isolate);
    Local<Value> arg = args[0];
    if (!arg->IsFunction())
    {
        return;
    }
  	//构造 持久化 JavaScript function 
    v8::Local<v8::Function> func = v8::Local<v8::Function>::Cast(args[0]);
    BeautyFaceInterface::getInstance()->m_callBack.Reset(func);
  	// libuv uv_async_init 设置回调函数
    uv_async_init(uv_default_loop(), &BeautyFaceInterface::getInstance()->m_async, BeautyFaceInterface::async_on_message);
}

/*
	下面是在任意的函数内部执行，目的是为了启动和唤醒 async_on_message
*/

	// 设置timer
    Timer *t = new Timer();
    t->setInterval([&]() {
      	//新的子线程中 fire m_async    uv_async_send 线程安全   这里可能会出现多次fire ，但是 回调地方只会有一次的现象，这里不能使用 m_async 来进行传值，需要在这里交给主线程数据的话需要使用线程安全的队列来执行。
        uv_async_send(&BeautyFaceInterface::getInstance()->m_async);
    },
    30); // 30 Ms

0x0eccee98 {isolate_=0xdddddddd {...} context_={...} m_callBack=0xdddddddd {handle_={...} } ...}
Nan::ObjectWrap:{refs_=-572662307 handle_={...} }