#include "ThreadTemplet.h"

ThreadTemplet::ThreadTemplet(QObject *parent) : QObject(parent)
{
    running_flag = false;
    thread = new QThread();//指定父对象可以自动析构



    this->moveToThread(thread);
    connect(thread, &QThread::started, this, &ThreadTemplet::process);

    initbuff();
    start();
}

ThreadTemplet::~ThreadTemplet()
{
    stop();

    if(thread)
    {
        thread->deleteLater();
    }
}

void ThreadTemplet::setRunFrq(qreal frq)
{
    if((frq != 0)||(frq <= 1000))
    {
        running_frq = frq;
        qDebug() << "set running frquency:" <<frq <<"Hz";
    }
}

void ThreadTemplet::start()
{
    if(!thread->isRunning())
    {
        running_flag = true;
        thread->start(QThread::IdlePriority);
        qDebug() << "thread start" << thread->isRunning();
        // thread->setPriority(QThread::IdlePriority);
    }
    else
    {
        qDebug() << "thread has started";
    }
}

void ThreadTemplet::stop()
{
    disconnect(this, nullptr, nullptr, nullptr);

    if(thread)
    {
        if(!thread->isFinished())
        {
            running_flag = false;
            thread->requestInterruption();
            thread->setPriority(QThread::HighPriority);//设置成最高，让线程优先退出

            bool flag = disconnect(thread, nullptr, nullptr, nullptr);//没有完全断开

            qDebug() << "disconnect" << flag << "isInterruptionRequested" << thread->isInterruptionRequested();


            thread->quit();
            thread->wait(100);//这个地方有问题、没办法退出线程,断开之前，先断开串口连接，这样就能断开线程，否则一直在占用
        }
        else
        {
            qDebug() << "thread is not running";
        }
    }
}

void ThreadTemplet::wakeup()
{
    sleep_time = 1000/frq();
}

void ThreadTemplet::pause()
{
    sleep_time = -1;
}



void ThreadTemplet::process()//线程函数
{


    /*
    while (true)
    {
         QThread::msleep(1000/frq());

         emit error(tr("thread run base"));

         if(isInterruptionRequested())//退出
         {
             break;
         }
         //QThread::yieldCurrentThread();
    }
    */

    //stop();
}

void ThreadTemplet::setGCSID(int m_sysid, int m_compid)
{
    GCS_SysID = m_sysid;
    GCS_CompID = m_compid;
}

void ThreadTemplet::setID(int m_sysid,int m_compid)
{
    sysid  = (uint8_t)m_sysid;
    compid = (uint8_t)m_compid;
}


void ThreadTemplet::Send(mavlink_message_t msg)
{
    if(isActive())
    {
        uint8_t buff[MAVLINK_MAX_PACKET_LEN+sizeof(quint64)];
        uint16_t len = mavlink_msg_to_send_buffer(buff, &msg);

        emit SendMessageTo(0,buff, len);//使用信号和槽
    }
}


void ThreadTemplet::initbuff(void)
{
    client_buff.max_size = 1 * 1024 *1024;//10M
    client_buff.buff[0].clear();
    client_buff.buff[1].clear();
    client_buff.select = 0;

    serial_buff.max_size = 1 * 1024 *1024;
    serial_buff.buff[0].clear();
    serial_buff.buff[1].clear();
    serial_buff.select = 0;
}

void ThreadTemplet::setbuff(quint32 src,QByteArray data)
{
    QMutexLocker locker(&mutex);
    switch (src) {
    default:
    case SourceType::c_sock:
           //当前的buff超过10M字节之后就清除，防爆机制，不然buff太大后容易卡死
           if(client_buff.buff[client_buff.select].size() >= client_buff.max_size)
           {
               client_buff.buff[client_buff.select].clear();
               qDebug() << "client_buff.buff " << client_buff.select <<" OVERFLOW";
           }
           client_buff.buff[client_buff.select].append(data);

        break;
    case SourceType::s_port:
        //当前的buff超过10M字节之后就清除，防爆机制，不然buff太大后容易卡死
           if(serial_buff.buff[serial_buff.select].size() >= serial_buff.max_size)
           {
               serial_buff.buff[serial_buff.select].clear();
               qDebug() << "serial_buff.buff " << serial_buff.select <<" OVERFLOW";
           }
           serial_buff.buff[serial_buff.select].append(data);
        break;
    }
}

QByteArray ThreadTemplet::readbuff(quint32 src)
{
    QMutexLocker locker(&mutex);
    QByteArray datagram;
    switch (src) {
    default:
    case SourceType::c_sock:
           if(client_buff.select == 0)
           {
               datagram.clear();
               datagram.append(client_buff.buff[1]);
               //清除这个未选择的buff
               client_buff.buff[1].clear();
               //读取完成，可以往这个内存里面写数了
               client_buff.select = 1;
           }
           else if(client_buff.select == 1)
           {
               datagram.clear();
               datagram.append(client_buff.buff[0]);
               //清除这个未选择的buff
               client_buff.buff[0].clear();
               //读取完成，可以往这个内存里面写数了
               client_buff.select = 0;
           }
        break;
    case SourceType::s_port:
           if(serial_buff.select == 0)
           {
               datagram.clear();
               datagram.append(serial_buff.buff[1]);
               //读取完成，可以往这个内存里面写数了
               serial_buff.buff[1].clear();
               serial_buff.select = 1;
           }
           else if(serial_buff.select == 1)
           {
               datagram.clear();
               datagram.append(serial_buff.buff[0]);
               //读取完成，可以往这个内存里面写数了
               serial_buff.buff[0].clear();
               serial_buff.select = 0;
           }
        break;
    }
    return datagram;
}