#include "maindlg.h"
#include "ui_maindlg.h"
#include "includes.h"
#include <QIODeviceBase>

extern quint8 gMain_bySoftType;

MainDlg::MainDlg(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainDlg)
{
    ui->setupUi(this);

    Init();//模块初始化
}

MainDlg::~MainDlg()
{
    delete ui;
}

//窗口关闭事件
void MainDlg::closeEvent(QCloseEvent *event){
    m_pUart->CloseUart();
    event->accept();
}

//模块初始化
void MainDlg::Init(){
    m_dwDeviceType = 0;//设备类型
    m_dwTabIndex = 0;//页面

    //初始化通信包号
    m_byPacketNo = MAINDLG_DEFAULT_PACKET_NO;
    memset(m_abyTmpData, 0, PS_FRAME_MAX_LEN);

    //隐藏关闭串口
    ui->pushButtonCloseUart->setVisible(false);

    //创建串口对象
    m_pUart = new Uart(this);

    //创建协议栈对象
    m_objPs = new Ps(this);

    //创建网络对象
    m_pHttpReq = new HttpReq(this);

    //界面初始化
    initUi();

    //配置消息和槽函数
    configSignalAndSlot();

    //获得本机可用串口
    getUartNameList();

    //配置网络模块
    configHttpReq();


    //初始化定时器
    m_pTimer = new QTimer();
    m_pUpgradeTimer = new QTimer();//升级定时器
    m_pTimer->setInterval(3000);//3秒超时
    m_pUpgradeTimer->setInterval(5000);//5秒超时

    connect(this->ui->comboBoxDeviceType, &QComboBox::currentIndexChanged, this,  &MainDlg::slotDeviceTypeChanged);
    connect(this->ui->tabWidgetOamItem, &QTabWidget::currentChanged, this,  &MainDlg::slotTabSwitch);
    connect(m_pTimer, &QTimer::timeout, this, &MainDlg::Timeout2000Slot);
    connect(m_pUpgradeTimer, &QTimer::timeout, this, &MainDlg::Timeout5000Slot);

    connect(this, &this->signalNoticeUpgradeOk,m_pOamUpgrade, &m_pOamUpgrade->slotNoticeUpgradeOk);
    connect(this, &this->signalNoticeUpgradeFail,m_pOamUpgrade, &m_pOamUpgrade->slotNoticeUpgradeFail);
    connect(this, &this->signalNoticeUpgradeTimeout,m_pOamUpgrade, &m_pOamUpgrade->slotNoticeUpgradeTimeout);
}

//界面初始化
void MainDlg::initUi(){
    QString strText = "";

    //初始化设备类型下拉框
    ui->comboBoxDeviceType->addItem("声波基站", 0);
    ui->comboBoxDeviceType->addItem("同步基站", 1);

    //删除全部tap页
    while(ui->tabWidgetOamItem->count() >0){
        QWidget *pTmp = ui->tabWidgetOamItem->widget(0);
        ui->tabWidgetOamItem->removeTab(0);
        delete pTmp;
    }

    //系统参数
    m_pSysConfig = new sysconfig(this);
    ui->tabWidgetOamItem->addTab(m_pSysConfig, "系统参数");

    //设备参数
    m_pOamBaseParam = new OamBaseParam(this);
    ui->tabWidgetOamItem->addTab(m_pOamBaseParam, "设备参数");

    //网管参数
    m_pOamNetworkParam = new OamNetworkParam(this);
    ui->tabWidgetOamItem->addTab(m_pOamNetworkParam ,"网管参数");

    //同步参数
    m_pOamSyncParam = new OamSyncParam(this);
    ui->tabWidgetOamItem->addTab(m_pOamSyncParam, "同步参数");

    //同步定时参数
    m_pOamSyncTimer = new oamsynctimer(this);
    ui->tabWidgetOamItem->addTab(m_pOamSyncTimer, "同步定时");

    //配置参数
    m_pOamConfigParam = new OamConfigParam(this);
    ui->tabWidgetOamItem->addTab(m_pOamConfigParam, "增益参数");

    //安装参数
    m_pOamInstallParam = new OamInstallParam(this);
    ui->tabWidgetOamItem->addTab(m_pOamInstallParam, "安装参数");

    //基站参数
    m_pOamBtsParam = new OamBtsParam(this);
    ui->tabWidgetOamItem->addTab(m_pOamBtsParam, "基站参数");

    //软件升级
    m_pOamUpgrade = new OamUpgrade(this);
    ui->tabWidgetOamItem->addTab(m_pOamUpgrade, "软件升级");

    ui->tabWidgetOamItem->setCurrentIndex(0);

    //根据版本禁用重置参数按钮
    if(gMain_bySoftType == MAIN_SOFT_TYPE_DEV){
        ui->pushButtonResetParam->setDisabled(false);
    }else{
        ui->pushButtonResetParam->setDisabled(true);
    }
}

//配置消息和槽函数
void MainDlg::configSignalAndSlot(){
    //操作串口
    connect(ui->pushButtonOpenUart, &QPushButton::clicked, this, &this->openUart);
    connect(ui->pushButtonCloseUart, &QPushButton::clicked, this, &this->closeUart);
    connect(ui->pushButtonRefresh,&QPushButton::clicked, this, &this->getUartNameList);

    //保存参数
    connect(ui->pushButtonSaveParam, &QPushButton::clicked, m_pOamConfigParam, &m_pOamConfigParam->saveParamSlot);

    //重启设备
    connect(ui->pushButtonRestart, &QPushButton::clicked, m_pOamConfigParam, &m_pOamConfigParam->restartSlot);

    //重置设备参数
    connect(ui->pushButtonResetParam, &QPushButton::clicked, m_pOamConfigParam, &m_pOamConfigParam->resetParamSlot);
}

//获得本机可用串口列表
void MainDlg::getUartNameList(){
    quint8 byFlag = 0;
    QList<QString> strUartNameList;
    quint8 byLen = 0;
    QString strText = "";

    ui->comboBoxUart->clear();

    byFlag = m_pUart->GetUartNameList(&strUartNameList, &byLen);
    if(!byFlag){
        return;
    }

    for(quint8 i = 0; i < byLen; i++){
        strText = strUartNameList[i];
        ui->comboBoxUart->addItem(strText);
    }

    return;
}

//配置httpreq模块
void MainDlg::configHttpReq(){
    QString strHostUrl= "";
    QString strHostPort = "";

    //获得系统参数
    m_pSysConfig->getSysConfigParam(&strHostUrl, &strHostPort);

    //配置HttpReq模块参数
    if(strHostUrl.length() >0 && strHostPort.length() > 0){
        m_pHttpReq->configNetworkParam(strHostUrl, strHostPort);
        m_byHttpReqConfigOk = 1;//表示网络模块配置OK
    }
}

//打开串口
void MainDlg::openUart(){
    quint8 byFlag = 0;
    QString strUartName = "";

    //获得已选串口
    strUartName = ui->comboBoxUart->currentText();
    if(strUartName.size() <= 0){
        QMessageBox::information(this, "提示", "请选择串口");
        return;
    }

    //打开串口
    byFlag = m_pUart->OpenUart(strUartName);
    if(!byFlag){
        return;
    }

    ui->pushButtonOpenUart->setVisible(false);
    ui->pushButtonCloseUart->setVisible(true);

    return;
}

//关闭串口
void MainDlg::closeUart(){
    m_pUart->CloseUart();

    ui->pushButtonCloseUart->setVisible(false);
    ui->pushButtonOpenUart->setVisible(true);
}

//从串口接收数据的槽函数
void MainDlg::slotReceiveDataFromUart(QByteArray dataList, quint16 wLen){
    if(wLen > 0){
        //将数据发送给协议栈
        m_objPs->PsReceiveData(dataList, wLen);//把数据发送给协议栈
    }

    return;
}

//发送数据
//返回值:本次发送的字节数
qint64 MainDlg::sendDataToUart(QByteArray dataList){
    qint64 fTmp = m_pUart->SendData(dataList);
    return fTmp;
}

//协议栈上行响应信号设置成功槽函数
void MainDlg::PsUlRespSignalConfigOkSlot(quint8 *pbyData, quint16 wLen){
    quint8 *pbyOamData = NULL;
    LTV_T *pstLtv = NULL;
    quint16 wCommand = 0;// 监控命令
    quint16 wCurrentLen = 0;//当前已遍历长度
    quint8 bySaveFlag = 0;

    m_pTimer->stop();//停止定时器
    m_byPacketNo = MAINDLG_DEFAULT_PACKET_NO;

    //申请内存
    if(wLen > 0){
        pbyOamData = new quint8[wLen];
    }
    memcpy(pbyOamData, pbyData, sizeof(quint8)*wLen);//拷贝数据
    pstLtv = (LTV_T*)pbyOamData;


    // 遍历报文
    while (wCurrentLen < wLen)
    {
        wCurrentLen += pstLtv->wLen;
        wCommand = pstLtv->wTag;

        if (ORDER_CONFIG_SAVE_PARAM == wCommand){// 保存参数
            bySaveFlag = 1;
            if(pstLtv->abyData[0] == 0x01){//保存成功
                QMessageBox::StandardButton dlg;
                dlg = QMessageBox::question(this, "提示", "保存参数成功，是否重启设备", QMessageBox::Yes|QMessageBox::No);
                if (dlg == QMessageBox::Yes) {
                    delete pbyOamData;//删除内存
                    pbyOamData = NULL;
                    emit ui->pushButtonRestart->click();//重启设备
                }
            }else{//保存失败
                QMessageBox::critical(this, "提示", "保存参数失败");
            }
        }

        //移动指针
        if (wCurrentLen < wLen)
        {
            pstLtv = (LTV_T *)(pbyData + wCurrentLen); // 指针后移一个对象的长度
        }
    }

    if(!bySaveFlag){//非保存参数
        QMessageBox::information(this, "提示", "配置数据成功");
    }

    delete pbyOamData;//删除内存
    pbyOamData = NULL;

    return;
}

//协议栈上行响应信号设置失败槽函数
void MainDlg::PsUlRespSignalConfigFailSlot(){
    m_pTimer->stop();//停止定时器
    m_byPacketNo = MAINDLG_DEFAULT_PACKET_NO;
    QMessageBox::critical(this, "提示", "配置数据失败");
    return;
}

//协议栈上行查询响应成功信号槽函数
void MainDlg::PsUlRespSignaQueryOkSlot(quint8 *pbyData, quint16 wLen){
    quint8 *pbyOamData = NULL;
    LTV_T *pstLtv = NULL;
    quint16 wCommand = 0;// 监控命令
    quint16 wCurrentLen = 0;//当前已遍历长度

    m_pTimer->stop();//停止定时器
    m_byPacketNo = MAINDLG_DEFAULT_PACKET_NO;

    //申请内存
    if(wLen > 0){
        pbyOamData = new quint8[wLen];
    }
    memcpy(pbyOamData, pbyData, sizeof(quint8)*wLen);//拷贝数据
    pstLtv = (LTV_T*)pbyOamData;


    // 遍历消息，组织查询数据
    while (wCurrentLen < wLen)
    {
        wCurrentLen += pstLtv->wLen;
        wCommand = pstLtv->wTag;

        //遍历数据链表
        if (wCommand <= 0x00FF){// 查询设备信息
            m_pOamBaseParam->showBaseParam(pstLtv);
        }
        else if ((0x0100 <= wCommand) && (0x01FF >= wCommand)){// 查询网管参数
            m_pOamNetworkParam->showParam(pstLtv);
        }
        else if ((0x0200 <= wCommand) && (0x02FF >= wCommand)){// 查询告警状态

        }
        else if ((0x0300 <= wCommand) && (0x03FF >= wCommand)){// 查询配置参数
            m_pOamConfigParam->showParam(pstLtv);
        }
        else if ((0x0400 <= wCommand) && (0x04FF >= wCommand)){// 查询安装参数
            m_pOamInstallParam->showParam(pstLtv);
        }
        else if ((0x0500 <= wCommand) && (0x05FF >= wCommand)){// 查询同步参数
            m_pOamSyncParam->showParam(pstLtv);
        }
        else if ((0x0600 <= wCommand) && (0x06FF >= wCommand)){// 查询基站参数
            m_pOamBtsParam->showParam(pstLtv);
        }else if ((0x0700 <= wCommand) && (0x07FF >= wCommand)){// 查询同步定时参数
            m_pOamSyncTimer->showParam(pstLtv);
        }

        //移动指针
        if (wCurrentLen < wLen)
        {
            pstLtv = (LTV_T *)(pbyData + wCurrentLen); // 指针后移一个对象的长度
        }
    }

    delete pbyOamData;//删除内存
    pbyOamData = NULL;

    return;
}

//协议栈上行查询响应失败信号槽函数
void MainDlg::PsUlRespSignaQueryFailSlot(){
   m_pTimer->stop();//停止定时器
   m_byPacketNo = MAINDLG_DEFAULT_PACKET_NO;
   QMessageBox::critical(this, "提示", "查询数据失败");
   return;
}

//发送查询信号的槽函数
void MainDlg::slotOamSendQueryMsg(quint8 *pbyData, quint16 wLen){
    quint16 wOamMsgLen = wLen + PS_FRAME_MIN_LEN;
    QByteArray dataList;
    qint64 wSendLen = 0;
    qint16 wPacketNo = 0;

    //上一个通信包还没有返回
    if(m_byPacketNo != MAINDLG_DEFAULT_PACKET_NO){
        return;
    }

    //生成协议报文
    memset(m_abyTmpData, 0, PS_FRAME_MAX_LEN);
    wPacketNo = m_objPs->PsGenApMsg(MCP_A, MCP_A_QUERY, pbyData, wLen, m_abyTmpData, &wOamMsgLen);

    //重新组织数据
    for(quint16 i = 0; i < wOamMsgLen; i++){
        dataList.append(m_abyTmpData[i]);
    }

    //将协议报文发送到串口
    wSendLen = sendDataToUart(dataList);
    if(wSendLen != wOamMsgLen){
        QMessageBox::critical(this, "提示", "查询参数失败");
        return;
    }

    m_byPacketNo = wPacketNo;
    m_pTimer->start();

    return;
}

//pbyData:其他模块传过来的OAM消息
//wLen:OAM消息长度
//wCmd:监控命令
void MainDlg::slotOamSendConfigMsg(quint8 *pbyData, quint16 wLen, quint16 wCmd){
    quint16 wOamMsgLen = wLen + PS_FRAME_MIN_LEN;
    QByteArray dataList;
    qint64 wSendLen = 0;
    qint16 wPacketNo = 0;

    //上一个通信包还没有返回
    if(m_byPacketNo != MAINDLG_DEFAULT_PACKET_NO){
        return;
    }

    //生成协议报文
    memset(m_abyTmpData, 0, PS_FRAME_MAX_LEN);
    wPacketNo = m_objPs->PsGenApMsg(MCP_A, MCP_A_CONFIGURE, pbyData, wLen, m_abyTmpData, &wOamMsgLen);

    //重新组织数据
    for(quint16 i = 0; i < wOamMsgLen; i++){
        dataList.append(m_abyTmpData[i]);
    }

    //将协议报文发送到串口
    wSendLen = sendDataToUart(dataList);
    if(wSendLen != wOamMsgLen){
        QMessageBox::critical(this, "提示", "配置参数失败");
        return;
    }

    //非重启命令
    if(wCmd != ORDER_CONFIG_RESTART){
        m_byPacketNo = wPacketNo;
        m_pTimer->start();
    }

    return;
}

//超时槽函数
void MainDlg::Timeout2000Slot(){
    m_pTimer->stop();
    m_byPacketNo = MAINDLG_DEFAULT_PACKET_NO;
    QMessageBox::critical(this, "提示", "通信超时，请重试");
}

//升级超时槽函数
void MainDlg::Timeout5000Slot(){
    m_pUpgradeTimer->stop();
    m_byPacketNo = MAINDLG_DEFAULT_PACKET_NO;

    //向升级模块发送升级超时消息
    emit signalNoticeUpgradeTimeout();
}

//槽函数-上传基站基本参数-增加
void MainDlg::slotUploadBtsBaseParamAdd(QString strApi, QJsonObject jsonObject){
    QString strResp = "";

    //二次确认
    QMessageBox::StandardButton dlg;
    dlg = QMessageBox::question(this, "提示", "确定要上传基站参数吗", QMessageBox::Yes|QMessageBox::No);
    if (dlg == QMessageBox::No) {
        return;
    }

    //发送post消息
    if(m_byHttpReqConfigOk > 0){
        //组织项目编号
        if(m_dwProjectId <= 0){
            QMessageBox::critical(this, "提示", "请首先配置项目编号");
            return;
        }
        jsonObject["project_id"] = QJsonValue::fromVariant(QVariant(static_cast<quint64>(m_dwProjectId)));

        //设置消息源
        jsonObject["source_id"] = 3;//数据源于GUI网管;

        strResp = m_pHttpReq->sendPostReq(strApi, jsonObject);
        QMessageBox::information(this, "提示", strResp);
    }else{
        QMessageBox::critical(this, "提示", "http模块不可用，请先配置系统参数再尝试");
    }

    return;
}

//槽函数-上传基站基本参数-修改
void MainDlg::slotUploadBtsBaseParamUpdate(QString strApi, QJsonObject jsonObject){
    QString strResp = "";

    //二次确认
    QMessageBox::StandardButton dlg;
    dlg = QMessageBox::question(this, "提示", "确定要上传基站参数吗", QMessageBox::Yes|QMessageBox::No);
    if (dlg == QMessageBox::No) {
        return;
    }

    if(m_byHttpReqConfigOk > 0){
        //组织项目编号
        if(m_dwProjectId <= 0){
            QMessageBox::critical(this, "提示", "请首先配置项目编号");
            return;
        }
        jsonObject["project_id"] =  QJsonValue::fromVariant(QVariant(static_cast<quint64>(m_dwProjectId)));

        //组织基站ID
        if(m_dwBtsId < 1000){
            QMessageBox::critical(this, "提示", "请配置正确的基站编号");
            return;
        }
        jsonObject["bts_id"] = QJsonValue::fromVariant(QVariant(static_cast<quint64>(m_dwBtsId)));

        //设置消息源
        jsonObject["source_id"] = 3;//数据源于GUI网管

        //发送消息
        strResp = m_pHttpReq->sendPostReq(strApi, jsonObject);
        QMessageBox::information(this, "提示", strResp);
    }else{
        QMessageBox::critical(this, "提示", "http模块不可用，请先配置系统参数再尝试");
    }

    return;
}

//发送升级报文
//pbyData:升级模块传过来的OAM消息
//byCmdType:命令类型
//wLen:OAM消息长度
void MainDlg::slotOamSendUpgradeMsg(quint8 *pbyData, quint8 byCmdType, quint16 dataLen){
    quint16 wOamMsgLen = dataLen + PS_FRAME_MIN_LEN;
    QByteArray dataList;
    qint64 wSendLen = 0;
    quint16 wPacketNo = 0;

    //上一个通信包还没有返回
    if(m_byPacketNo != MAINDLG_DEFAULT_PACKET_NO){
        m_byPacketNo = MAINDLG_DEFAULT_PACKET_NO;
        return;
    }

    //生成协议报文
    memset(m_abyTmpData, 0, PS_FRAME_MAX_LEN);
    wPacketNo = m_objPs->PsGenApMsg(MCP_B, byCmdType, pbyData, dataLen, m_abyTmpData, &wOamMsgLen);

    //重新组织数据
    for(quint16 i = 0; i < wOamMsgLen; i++){
        dataList.append(m_abyTmpData[i]);
    }

    //将协议报文发送到串口
    wSendLen = sendDataToUart(dataList);
    if(wSendLen != wOamMsgLen){
        QMessageBox::critical(this, "提示", "升级报文发送失败");
        emit signalNoticeUpgradeFail();//通知升级模块，升级失败
    }

    m_byPacketNo = wPacketNo;
    m_pUpgradeTimer->start();

    return;
}

//协议栈上行响应信号-升级命令成功槽函数
void MainDlg::PsUlRespSignalUpgradeOkSlot(quint8 *pbyData){
    LTV_B_T *pstLtv = (LTV_B_T*)pbyData;
    quint16 wCommand = pstLtv->wTag;// 监控命令

    m_pUpgradeTimer->stop();//停止定时器
    m_byPacketNo = MAINDLG_DEFAULT_PACKET_NO;

    //通知升级模块
    emit signalNoticeUpgradeOk(wCommand);

    return;
}

//协议栈上行响应信号-升级命令失败槽函数
void MainDlg::PsUlRespSignalUpgradeFailSlot(){

    m_pUpgradeTimer->stop();//停止定时器
    m_byPacketNo = MAINDLG_DEFAULT_PACKET_NO;

    //通知升级模块
    emit signalNoticeUpgradeFail();
    return;
}

//升级模块通知需要重启启动
void MainDlg::slotUpgradeRestart(){
    emit ui->pushButtonRestart->click();//重启设备
}

//配置项目编号
void MainDlg::setProjectId(quint32 dwProjectId){
    m_dwProjectId = dwProjectId;

    QString hexStr = QString::number(dwProjectId, 16);
    hexStr = hexStr.rightJustified(8, '0');//右侧对齐，输出8位字符，不足8位的左侧用0填充
    hexStr = hexStr.toUpper();

    ui->labelPorjectId->setText(hexStr);
    return;
}

//查询项目编号
quint32 MainDlg::getPorjectId(){
    return m_dwProjectId;
}

//配置基站编号
void MainDlg::mainDlgSetBtsId(quint32 dwBtsId){
    m_dwBtsId = dwBtsId;
    ui->labelBtsId->setText(QString::number(m_dwBtsId));
    return;
}

//设备类型下拉框槽函数
void MainDlg::slotDeviceTypeChanged(int index){
    m_dwDeviceType = index;//设备类型
    if(m_dwTabIndex == 1){
        m_pOamBaseParam->updateUi();
    }else if(m_dwTabIndex == 3){
        m_pOamSyncParam->updateUi();
    }else if(m_dwTabIndex == 4){
        m_pOamSyncTimer->updateUi();
    }else if(m_dwTabIndex == 5){
        m_pOamConfigParam->updateUi();
    }else if(m_dwTabIndex == 6){
        m_pOamInstallParam->updateUi();
    }else if(m_dwTabIndex == 7){
        m_pOamBtsParam->updateUi();
    }
}

//查询设备类型
int MainDlg::getDeviceType(){
    return m_dwDeviceType;
}

//tab页面切换
void MainDlg::slotTabSwitch(int index){
    m_dwTabIndex = index;//保存tab索引

    if(index == 1){//设备基本参数
        m_pOamBaseParam->updateUi();
    }else if(index == 3){
        m_pOamSyncParam->updateUi();
    }else if(index == 4){
        m_pOamConfigParam->updateUi();
    }else if(index == 5){
        m_pOamInstallParam->updateUi();
    }else if(index == 6){
        m_pOamBtsParam->updateUi();
    }
}

void MainDlg::stopUpgradeTimer(){
    m_pUpgradeTimer->stop();
}