#include "myserial.h"
#include "fft.h"
#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include <QQmlContext>




MySerial::MySerial(QObject *parent)
    : QObject{parent}
    ,portNamelList(0)
    ,serialPort_cnt(0)
    ,serial_status(false)
{
    qDebug() << "initial mySerial class";

    timer.start(10);
    timer_fft.start(100);
    //10ms中断来处理串口数据

    connect(&timer,&QTimer::timeout,this,&MySerial::AnalyseSerialPackage);
    connect(&timer_fft,&QTimer::timeout,this,&MySerial::FFT);


}


MySerial::~MySerial()
{


}

void MySerial::FFT(void)
{
//    fft_process(50);
//    QVariantList tmp;
//    tmp.clear();
    //clear temporary list
//    fft_get_amp(tmp);
//                qDebug()<<"amp"<<tmp;
    //get fft amp
//    if( tmp.size() != 0 )
//    {
//        setMyArray(tmp);
//    }
//    this->data++;
//    emit testChanged();
    //set and emit the signal
}


void MySerial::openPort(void)
{
    if(serialPort_cnt==0)
    {
        setPortStatus(false);
        return;
    }
    if(serial.isOpen())
    {
        serial.clear();
        serial.close();
        setPortStatus(false);
    }
    else
    {
        serial.setPortName(currentPortName);
        if( !serial.open(QIODevice::ReadWrite))
        {
            setPortStatus(false);
            return;
        }
        serial.setBaudRate(QSerialPort::Baud115200,QSerialPort::AllDirections);
        //设置波特率和读写方向
        serial.setDataBits(QSerialPort::Data8);
        //设置数据长度
        serial.setFlowControl(QSerialPort::NoFlowControl);
        //设置无流控制
        serial.setParity(QSerialPort::NoParity);
        //设置奇偶校验
        serial.setStopBits(QSerialPort::OneStop);
        //设置停止位1位
        setPortStatus(true);
        serial.flush();
        connect(&serial,&QSerialPort::readyRead,this,&MySerial::SerialRecvCallback);
    }
}

void MySerial::searchPort(void)
{
    portNamelList.clear();
    foreach(const QSerialPortInfo &info,QSerialPortInfo::availablePorts())
    {
        portNamelList << info.portName();
    }

    if(portNamelList.length() != serialPort_cnt)
    {
        setPortCnt(portNamelList.length());       
    }
    setSerialPortName(portNamelList);
}

QVariantMap MySerial::getRealStatus(void)
{
    QVariantMap map;
    map.clear();

    map.insert("yaw",flight_real_info.yaw);
    map.insert("pit",flight_real_info.pitch);
    map.insert("rol",flight_real_info.roll);

    return map;
}




QStringList MySerial::serialPortName() const
{
    return portNamelList;
}

void MySerial::setSerialPortName(const QStringList & name)
{
    portNamelList = name;
    emit serialPortNameChanged(portNamelList);
}


QVariantList MySerial::myArray() const {
    return m_myArray;
}

void MySerial::setMyArray(const QVariantList &array) {

    m_myArray = array;
    emit myArrayChanged();
}

QString MySerial::portName() const
{
    return currentPortName;
}
void MySerial::setPortName(const QString &name)
{
    currentPortName = name;
    emit portNameChanged(currentPortName);
}


uint16_t MySerial::portCnt()const
{
    return serialPort_cnt;
}

void MySerial::setPortCnt(const uint16_t &cnt)
{
    serialPort_cnt = cnt;
    emit portCntChanged(serialPort_cnt);
}


bool MySerial::portStatus() const
{
    return serial_status;
}
void MySerial::setPortStatus(const bool &status)
{
    serial_status=status;
    emit portStatusChanged(serial_status);
}

bool MySerial::realUpdate() const
{
    return real_update_flag;
}
void MySerial::setRealUpdate(const bool &flag)
{
    real_update_flag=flag;
    emit realUpdateChanged(real_update_flag);
}


void MySerial::SerialRecvCallback(void)
{
    QByteArray recvInfo = serial.readAll();
//    parse_info.recv_callback(recvInfo);
    uint16_t length = recvInfo.length();

    for(uint16_t i=0;i<length;i++)
    {
        serial_recv_queue.enqueue((std::byte)recvInfo[i]);
    }
}


void MySerial::AnalyseSerialPackage(void)
{
    static bool reset_flag = true;
    static uint16_t cnt = 0;
    std::byte tmp;
    static QByteArray buf;

    union
    {
        uint8_t u8_[4];
        float float_;
    }float2uint8;

    if(reset_flag)
    {
        reset_flag = false;
        buf.clear();
        cnt = 0;
    }
    //initial static variable

    while( !serial_recv_queue.isEmpty() )
    {
        tmp = serial_recv_queue.dequeue();

        if(cnt)
        {
            //已经找到头了
            cnt+=1;
            buf.append((char)tmp);
            if(cnt >= 13)
            {
                memcpy(float2uint8.u8_,&buf[1],4);
                flight_real_info.yaw = (int)float2uint8.float_;
                memcpy(float2uint8.u8_,&buf[5],4);
                flight_real_info.pitch = (int)float2uint8.float_;
                memcpy(float2uint8.u8_,&buf[9],4);
                flight_real_info.roll = (int)float2uint8.float_;

//                fft_update(flight_real_info.roll);

//                qDebug()<<"roll:"<<flight_real_info.roll<<"  pitch:"<<flight_real_info.pitch;
                reset_flag = true;
                emit realUpdateChanged(real_update_flag);
            }
        }
        else if(tmp == (std::byte)0xAB)
        {
            //刚找到头
            cnt+=1;
            buf.append((char)tmp);
        }
    }
}