void ReadWriteWorker::doWork(const std::vector<uint8_t> &msg) {
    //创建互斥锁保证线程安全
    std::lock_guard<std::mutex> lk(_mMsgMutex);
    //推送消息到消息队列_mMsgQueue
    _mMsgQueue.push(msg);
    //通知消息消息等待的线程（包含读写线程），检查执行条件
    _mMsgCond.notify_all();
}

//写循环
void ReadWriteWorker::writeLoop() {
    // 等待直至 main() 发送数据
    std::unique_lock<std::mutex> lk(_mMsgMutex);
    LOGE("start write loop");
    while (!isInterrupted()) {
        //这里判断当前线程没有标记退出，同时消息队列中有消息，继续运行后面的代码。
        _mMsgCond.wait(lk, [&] { return (isInterrupted() || !_mMsgQueue.empty()); });
        if (isInterrupted()) {
            break;
        }
        //从消息队列中获取消息
        std::vector<uint8_t> msg = std::move(_mMsgQueue.front());
        _serialPort->WriteBinary(msg);
        //消息出列
        _mMsgQueue.pop();
    }
    LOGE("write loop is interrupted!");
}

void ReadWriteWorker::readLoop() {
    LOGE("start read loop");
    // 等待直至收到发送数据
    std::unique_lock<std::mutex> lk(_mMsgMutex);
    //C++线程首次访问JEnv函数需要先使用AttachCurrentThread把当前线程附加到JVM上下文才能使用JEnv的函数、
    //Jni的native函数不需要是因为是Jvm线程调用函数，所以不需要附加，C++创建线程不数据Jvm，所以要进行关联附加才能使用Jni的函数
    if (LSerialPortManager::jvm->AttachCurrentThread(&_env, nullptr) != JNI_OK) {
        return THROW_EXCEPT("unable to get jvm instance");
    }
    while (!isInterrupted()) {
        //这里判断当前线程没有标记退出，同时有数据的情况下停止阻塞，继续运行后面的代码。
        _mMsgCond.wait(lk, [&] { return (isInterrupted() || _dataAvailable.load()); });
        if (isInterrupted()) {
            break;
        }
        //读取二进制
        std::vector<uint8_t> msg_vec;
        //读取数据
        _serialPort->ReadBinary(msg_vec);
        //重置标记
        _dataAvailable.store(false);
        if (msg_vec.empty()) {
            //没数据视为超时，进行下一轮循环
            continue;
        }
        //设置监听器锁
        std::lock_guard<std::mutex> llk(_mListenerMutex);
        if (_prepListener != nullptr) {
            //如果之前已经设置过了，先回收删除上一个listener
            if (_curlistener != nullptr) {
                LOGE("there is currently a listener and it is being recycled...");
                _curlistener->recycle(_env);
                delete _curlistener;
            }
            _curlistener = _prepListener;
            _prepListener = nullptr;
        }

        if (_curlistener != nullptr) {
            _curlistener->onDataReceived(_env, msg_vec);
        }

    }
    if (_prepListener != nullptr) {
        _prepListener->recycle(_env);
    }

    if (_curlistener != nullptr) {
        _curlistener->recycle(_env);
    }
    //退出当前线程
    LSerialPortManager::jvm->DetachCurrentThread();
    LOGE("read loop is interrupted!");
}

void LSerialPortDataListener::onDataReceived(JNIEnv *env, const std::vector<uint8_t> &msg) {
    if (_onDataReceivedMethod == nullptr) {
        jclass listenerClass = env->GetObjectClass(_jListener);
        _onDataReceivedMethod = env->GetMethodID(listenerClass, "onDataReceived", "([B)V");
        env->DeleteLocalRef(listenerClass);
    }

    auto size = static_cast<uint32_t>(msg.size());
    jbyteArray jData;
    if (size > static_cast<uint32_t>(std::numeric_limits<jsize>::max())) {
        LOGE("data size is too big start splite send data!");
        // 数据过大，需要分段拷贝
        constexpr uint32_t chunkSize = std::numeric_limits<jsize>::max();
        jData = env->NewByteArray(chunkSize);
        uint32_t offset = 0;
        while (offset < size) {
            const uint32_t copySize = std::min(size - offset, chunkSize);
            env->SetByteArrayRegion(jData, 0, copySize,
                                    reinterpret_cast<const jbyte *>(msg.data() + offset));
            offset += copySize;
            env->CallVoidMethod(_jListener, _onDataReceivedMethod, jData);
            env->DeleteLocalRef(jData);
        }

    } else {
        // 直接拷贝到jbyteArray中
        if (env == nullptr) {
            LOGE("JNIEnv pointer is null!");
            return;
        }
        jData = env->NewByteArray(static_cast<jsize>(size));
        env->SetByteArrayRegion(jData, 0, static_cast<jsize>(size),
                                reinterpret_cast<const jbyte *>(msg.data()));
        env->CallVoidMethod(_jListener, _onDataReceivedMethod, jData);
        env->DeleteLocalRef(jData);
    }

}

void ReadWriteWorker::checkAvailableLoop() {
    LOGE("start check available Loop");
    while (!isInterrupted()) {
        //判断串口对象状态是已打开，同时串口有数据
        if (_serialPort->GetState() == State::OPEN && _serialPort->Available() > 0) {
            //修改读取数据标记
            _dataAvailable.store(true);
            //通知消息
            _mMsgCond.notify_all();
        }
        //这里设置毫秒等待时间 等待x毫秒后再进行下一次检查
        std::this_thread::sleep_for(std::chrono::milliseconds(_checkIntervalWaitMills));
    }
    LOGE("check available Loop is interrupted!");
}

#ifndef LSERIALPORT_IWORKER_H
#define LSERIALPORT_IWORKER_H
#include "future"
/**
 * 工作类接口
 * 通过promise和future实现线程安全退出
 */
namespace LSerialPort {
    class IWorker {
    public:
        /**
         * 构造函数同时创建future
         */
        IWorker() : _interruptedFuture(_interruptSignal.get_future()) {
        }
        ~IWorker() {

        }
        //发送消息
        virtual void doWork(const std::vector<uint8_t> &msg) = 0;
        //退出
        virtual void interrupte() {
            _interruptSignal.set_value();
        }
        //是否退出
        bool isInterrupted() {
            //设置等待时间，如果当前状态非超时，则说明已经调用set_value发送数据，标记为退出状态
            return _interruptedFuture.wait_for(std::chrono::milliseconds(0)) !=
                   std::future_status::timeout;
        }
    private:
        std::promise<void> _interruptSignal;
        std::future<void> _interruptedFuture;
    };
}

#endif //LSERIALPORT_IWORKER_H

/**
 * 退出任务
 */
void interrupte() override {
     //监听器锁
      std::lock_guard<std::mutex> llk(_mListenerMutex);
      //消息锁
      std::lock_guard<std::mutex> lk(_mMsgMutex);
      //发送退出信号
      IWorker::interrupte();
      _mMsgCond.notify_all();
}

ReadWriteWorker::~ReadWriteWorker() {
    LOGE("---finishing worker---");
    ReadWriteWorker::interrupte();
    LOGE("wait for checkAvaliable thread end");
    if ((_checkAvaliableThread != nullptr) && _checkAvaliableThread->joinable()) {
        _checkAvaliableThread->join();//等待检查线程结束
    }
    LOGE("wait for write thread end");
    if ((_writeThread != nullptr) && _writeThread->joinable()) {
        _writeThread->join();//等待写线程结束
    }
    LOGE("wait for read thread end");
    if ((_readThread != nullptr) && _readThread->joinable()) {
        _readThread->join();//等待读线程结束
    }
    LOGE("cleaning msgQueue");
    //清空队列
    while (!_mMsgQueue.empty()) {
       _mMsgQueue.pop();
    }
    LOGE("cleaning thread ptr");
    delete _checkAvaliableThread;
    delete _writeThread;
    delete _readThread;
    _checkAvaliableThread = nullptr;
    _writeThread = nullptr;
    _readThread = nullptr;
    LOGE("cleaning listener ptr");
    if (_prepListener != nullptr) {
        delete _prepListener;
        _prepListener = nullptr;
    }
    if (_curlistener != nullptr) {
         delete _curlistener;
        _curlistener = nullptr;
    }
    LOGE("close SerialPort");
    if (_serialPort != nullptr) {
        LOGE("closing...");
        _serialPort->Close();
         delete _serialPort;
         _serialPort = nullptr;
        LOGE("close done!");
    }
    LOGE("finish done!");
  }
}

#ifndef LSERIALPORT_LSERIALPORTMANAGER_H
#define LSERIALPORT_LSERIALPORTMANAGER_H
#include <unordered_map>
#include <jni.h>
#include "ReadWriteWorker.h"

using namespace mn::CppLinuxSerial;

namespace LSerialPort {
    class LSerialPortManager {
    public:
        static JavaVM *jvm;

        LSerialPortManager();

        ~LSerialPortManager();

        /**
         * 添加设备
         * @param path 串口地址
         * @param baudRate 波特率
         * @param dataBits 数据位
         * @param parity 校验位
         * @param stopBits 停止位
         * @param readIntervalTimeoutMills 循环读SerialPort超时时间，超过时间就继续下一次轮循
         * @param checkIntervalWaitMills 循环检查等待时间，如果想要回复多一些数据可以适当延长
         * @return
         */
        int addDevice(
                std::string &path,
                BaudRate &baudRate,
                NumDataBits &dataBits,
                Parity &parity,
                NumStopBits &stopBits,
                int32_t &readIntervalTimeoutMills,
                long &checkIntervalWaitMills);

        /**
         * 删除设备
         * @param path 串口地址
         * @return
         */
        int removeDevice(const std::string &path);

        /**
         * 检查串口是否被加载过
         * @param path 串口地址
         * @return
         */
        bool hasDevice(const std::string &path);

        /**
         * 发送二进制消息
         * @param path 串口地址
         * @param msg 二进制消息
         * @return
         */
        int sendMessage(const std::string &path, const std::vector<uint8_t> &msg);

        /**
         * 设置串口数据监听器
         * @param path 串口地址
         * @param listener 监听器
         * @return
         */
        int setLSerialPortDataListener(const std::string &path, jobject *listener);


    private:
        //已加载的串口设备
        std::unordered_map<std::string, std::unique_ptr<ReadWriteWorker>> _mDevices;
    };
}


#endif //LSERIALPORT_LSERIALPORTMANAGER_H