ts/TransmitterSwitch/transmitterswitch.cpp

#include "transmitterswitch.h"
#include "importtemplate.h"
#include "ui_transmitterswitch.h"


#include <QFile>
#include <QList>
#include <memory>
#include <QLayout>


#include "LHQLogAPI.h"
#include "widgetitems.h"
#include "pBtnUserData2.h"
#include "WebAPI/FromWebAPI.h"
#include "TransmitterSwitchInfo.h"
#include "timewidget.h"
#include "cdate.h"
#include "savetotemplate.h"
#include "importtemplate.h"
#include "warning.h"
#include "tipwidget.h"
#include "UIStyleManager.h"
#include "PlanData.h"
#include "PlanCard.h"



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

    /* 创建一个布局 */
    QVBoxLayout* layout = new QVBoxLayout(parent);
    layout->setMargin(0);
    layout->setSpacing(0);
    layout->addWidget(this);

    /* 创建WebAPI实例 */
    m_fromWebAPI = new FromWebAPI;

    /* 设置“默认计划”按钮可点击 */
    ui->pBtn_defaultPlan->setCheckable(true);
    ui->pBtn_allFrequency->setCheckable(true);
    connect(ui->pBtn_allFrequency, &QPushButton::clicked, this, &TransmitterSwitch::do_selectFrequencyBtn);
    

    /* 设置提示文本 */
    m_tipText = new QLabel(this);
    m_tipText->resize(936,56);
    m_tipText->setObjectName("label_TipText");
    m_tipText->setText(R"(按时刻执行模式：即以时刻点为单位进行执行，若某日既为普通日和特殊日，在某一时刻皆有执行动作，将优先执行特殊日在此时刻所计划的动作。
按天执行模式：即以天为单位进行执行，若某日既为普通日和特殊日，则当日一整天优先执行特殊日所计划的动作，普通日计划当日不再执行。)");
    m_tipText->hide();
    QPoint pos = ui->label_Tip->mapTo(this, ui->label_Tip->pos());
    m_tipText->move(pos.x() + 2, pos.y() + 2 );     /* 去掉阴影的宽度和高度 */
    ui->label_Tip->installEventFilter(this);

    /* 设置默认值 */
    ui->pBtn_defaultPlan->setChecked(true);
    ui->rBtn_moment->setChecked(true);


    /* 连接信号和槽 */
    connect(ui->pBtn_addPlan, &QPushButton::clicked, this, &TransmitterSwitch::do_pBtnAddExecPlan);
    connect(ui->pBtn_importPlan, &QPushButton::clicked, this, &TransmitterSwitch::do_importData);
    connect(ui->pBtn_exportPlan, &QPushButton::clicked, this, &TransmitterSwitch::do_exportData);
    connect(ui->pBtn_clearPlan, &QPushButton::clicked, this, &TransmitterSwitch::do_clearCurrentPage);

    /* 设置QSS */
    connect(&EPUIStyle, &UIStyleManager::signal_qssChanged, this, &TransmitterSwitch::do_setUIStyle);
    /* 设置默认的皮肤 */
    EPUIStyle.setUIStyle(enum_UIStyle::UI_Dark);

    /* 设置默认点击的按钮 */
    ui->pBtn_allFrequency->setChecked(true);

}

TransmitterSwitch::~TransmitterSwitch()
{
    if(m_tipText != nullptr)
    {
        delete m_tipText;
        m_tipText = nullptr;
    }
    delete ui;
}


/* 设置样式表路径，给弹窗页面使用，不需要包含最后的white，black */
void TransmitterSwitch::setQSSPath(const QString &qssPath)
{
    if(qssPath.isEmpty())
    {
        return;
    }
    /* 去掉最后的“/” */
    // if(qssPath.endsWith("/"))
    // {
    //     EPUIStyle.setQSSPath(qssPath.left(qssPath.length() - 1));
    // } else
    // {
    //     EPUIStyle.setQSSPath(qssPath);
    // }
}

/**
 * @brief 设置WebAPI信息
 * 
 * @param url WebAPI地址
 * @param serID 数据库ID
 * @param serKey 限制的关键字
 */
void TransmitterSwitch::setWebAPIInfo(const QString &url, const QString &serverID, const QString &serverKey)
{
    if(m_fromWebAPI == nullptr)
    {
        m_fromWebAPI = new FromWebAPI;
    }
    if(url.isEmpty() || serverID.isEmpty() || serverKey.isEmpty())
    {
        LH_WRITE_ERROR("WebAPI info is empty");
        return;
    }
    m_fromWebAPI->initWebApi(url, serverID, serverKey);
    /* 获取支持的设备 */
    m_fromWebAPI->getDeviceInfo(DeviceContainer.getMapDevice());
    m_fromWebAPI->getChannelInfo(ChnContainer.getMapChannel());

    /* 创建获取到的卡片信息 */
    createAllCard();
}

/* 初始化webAPI，重载版 */
void TransmitterSwitch::setWebAPIInfo(const InitData& data)
{
    setWebAPIInfo(data.url, data.serverID, data.serverKey);
}

/* 获取EQM数据库计划 */
void TransmitterSwitch::getExecPlanFromEQM()
{
    /* 清空本地的计划数据 */


    /* 获取页面的配置信息 */
    if(m_fromWebAPI->getConfigData(CfgData.getMapConfigData()))
    {
        // TipWidget::display(TipWidget::OPERATOR_OK, "获取配置成功", this);
    }else {
        TipWidget::display(TipWidget::OPERATOR_FAIL, "获取配置失败", this);
        return;
    }
    /* 设置计划配置 */
    auto& mapConfig = CfgData.getMapConfigData();
    for(auto begin = mapConfig.begin(), end = mapConfig.end(); begin != end; begin++)
    {
        if(begin->key == static_cast<int>(enum_ExecPlanConfig::DefaultPlan))
        {
            ui->pBtn_defaultPlan->setChecked(begin->value == 1 ? true : false);
        }
        else if(begin->key == static_cast<int>(enum_ExecPlanConfig::ExecMode))
        {
            if(begin->value == 0)
            {
                ui->rBtn_moment->setChecked(true);
            }else {
                ui->rBtn_day->setChecked(true);
            }
        }
    }

    /* 获取计划 */
    QList<ExecPlanItemInfo> list;
    if(m_fromWebAPI->getExecPlanData(list))
    {
        TipWidget::display(TipWidget::OPERATOR_OK, "获取计划成功", this);
    }else {
        TipWidget::display(TipWidget::OPERATOR_FAIL, "获取计划失败", this);
        return;
    }

    /* 添加计划项 */
    for(const auto& it : list)
    {
        
    }
    /* 排序 */
    for(int i = 0; i < 8; ++i)
    {
        
    }
    /* 获取数据插入到全局变量中，会将更新标志位置true，这里需要手动置为false */

    
    /* 调用回调函数 */
    if(m_trackCB != nullptr)
    {
        m_trackCB(2, g_mapTrack.value(2));
    }
}

/* 将计划保存到EQM数据库 */
void TransmitterSwitch::saveExecPlanToEQM()
{
    QList<ExecPlanItemInfo> list;
    /* 获取当前计划的执行模式 */
    int execType = 0;
    if(ui->rBtn_moment->isChecked())
    {
        execType = 0;
    } else
    {
        execType = 1;
    }
    // for(const auto& it : IData.getMapItem())
    // {
    //     for(const auto& it1 : *it)
    //     {
    //         ExecPlanItemInfo info;
    //         info.ExecType = execType;
    //         info.devName = it1->getDevName();
    //         info.actionID = it1->getActionNum();
    //         info.actionName = it1->getActionName();
    //         info.execTime = it1->getExecTime();
    //         info.date = it1->getDate();
    //         info.WeekDay = it1->getWeekDay() + 1;
    //         list.push_back(info);
    //     }
    // }
    /* 写入数据库 */
    if(m_fromWebAPI->insertData(list))
    {
        TipWidget::display(TipWidget::OPERATOR_OK, "保存计划成功", this);
    }else {
        TipWidget::display(TipWidget::OPERATOR_FAIL, "保存计划失败", this);
    }

    /* 保存“默认计划”和“执行模式” */
    ConfigData config1;
    config1.key = static_cast<int>(enum_ExecPlanConfig::DefaultPlan);
    config1.value = ui->pBtn_defaultPlan->isChecked() ? 1 : 0;
    config1.updateTime = QDateTime::currentDateTime();
    CfgData.updateConfigData(config1);
    
    ConfigData config2;
    config2.key = static_cast<int>(enum_ExecPlanConfig::ExecMode);
    config2.value = ui->rBtn_moment->isChecked() ? 0 : 1;
    config2.updateTime = QDateTime::currentDateTime();
    CfgData.updateConfigData(config2);

    /* 更新“计划是否更新”标志位，在更新前需要先获取数据库的标志位，如果依旧为1，那么本地是否更改都设置为1 */
    ConfigData config3;
    if(!m_fromWebAPI->getConfigData(static_cast<int>(enum_ExecPlanConfig::IsChanged), config3))
    {
        config3.key = static_cast<int>(enum_ExecPlanConfig::IsChanged);
    }
    /* 只要数据库和本地更新标志位有一个为true，说明还未被读走，则设置标志位为true */
    // if((config3.value == 1) || IData.isUpdate())
    // {
    //     config3.value = 1;
    // }
    config3.updateTime = QDateTime::currentDateTime();
    CfgData.updateConfigData(config3);

    /* 将配置写入数据库 */
    m_fromWebAPI->insertConfigData(CfgData.getMapConfigData());

    /* 调用回调函数 */
    if(m_trackCB != nullptr)
    {
        m_trackCB(1, g_mapTrack.value(1));
    }

}

/* 亮/暗换肤，0是亮色，1是暗色 */
void TransmitterSwitch::setUIStyle(int style)
{
    if(style == 0)
    {
        EPUIStyle.setUIStyle(enum_UIStyle::UI_Light);
    }
    else if(style == 1)
    {
        EPUIStyle.setUIStyle(enum_UIStyle::UI_Dark);
    }else {
        LH_WRITE_ERROR(QString("错误的样式类型: %1").arg(style));
    }
}

/* 设置回调函数 */
void TransmitterSwitch::setTrackCallBack(trackCallBack cb)
{
    if(cb == nullptr)
    {
        return;
    }
    m_trackCB = cb;
}


/* 点击了添加计划按钮 */
void TransmitterSwitch::do_pBtnAddExecPlan()
{
    
}





/* 导入数据 */
void TransmitterSwitch::do_importData()
{
    
}

/* 导出数据 */
void TransmitterSwitch::do_exportData()
{
    // /* 先获取所有的模板名称 */
    // QMap<QString, int> tabList;
    // m_fromWebAPI->getTemplateList(tabList);
    // /* 弹出导出页面 */
    // std::shared_ptr<SaveToTemplate> stt = std::make_shared<SaveToTemplate>(this);
    // stt->setQSS(EPUIStyle.getQSSPath());
    // /* 注册事件过滤器 */
    // stt->installEventFilter(this);
    // int weekDay = ui->stackedWidget_items->currentIndex();
    // /* 设置周几 */
    // stt->setWeekDay(weekDay);
    // /* 判断当前页是否有计划 */
    // if(IData.getOneDay(weekDay)->size() == 0)
    // {
    //     stt->setItemEmpty(true);
    // }else
    // {
    //     stt->setItemEmpty(false);
    // }
    // /* 判断当前是正常日还是特殊日 */
    // int type = -1;
    // if(weekDay < 7 && weekDay >= 0)
    // {
    //     type = 0;
    // }else if(weekDay == 7)
    // {
    //     type = 1;
    // }
    // /* 获取所有的模板名称，并设置 */
    // stt->setTemplateName(tabList, type);

    // stt->exec();
    // if(stt->isOk())
    // {
    //     /* 获取一天的数据 */
    //     auto list = IData.getOneDayExecPlan(weekDay);
    //     /* 保存到模板 */
    //     if(m_fromWebAPI->saveTemplate(stt->getTemplateName(), type, list))
    //     {
    //         TipWidget::display(TipWidget::OPERATOR_OK, "保存模版成功", this);
    //     }else {
    //         TipWidget::display(TipWidget::OPERATOR_FAIL, "保存模版失败", this);
    //     }
    //     /* 调用回调函数 */
    //     if(m_trackCB != nullptr)
    //     {
    //         m_trackCB(3, g_mapTrack.value(3));
    //     }
    // }
}

/* 清空当前页计划 */
void TransmitterSwitch::do_clearCurrentPage()
{
    /* 跳出弹窗警告 */
    Warning w(this);
    w.setQSS(EPUIStyle.getQSSPath());
    w.setText("是否清空当前页计划？");
    bool flag = false;
    connect(&w,&Warning::signal_ok,this,[&](){
        flag = true;
    });
    w.exec();
    if(!flag)
    {
        return;
    }
    // int weekDay = ui->stackedWidget_items->currentIndex();
    // IData.clearOneDay(weekDay);
    // sortLayout(weekDay);
    // LH_WRITE_LOG_DEBUG(QString("计划剩余数目:%1").arg(IData.getOneDay(weekDay)->size()));
}

/* 删除一个模板 */
void TransmitterSwitch::do_deleteTemplate(QString name)
{
    m_fromWebAPI->deleteTemplate(name);
}

/* 保存计划到EQM数据库 */
void TransmitterSwitch::do_pBtn_savePlan()
{
    /* 跳出弹窗提示 */
    Warning w(this);
    w.setQSS(EPUIStyle.getQSSPath());
    w.setText("将计划保存到数据库？");
    w.exec();
    if(!w.isOk())
    {
        return;
    }
    saveExecPlanToEQM();
}

/* 从EQM数据库获取计划 */
void TransmitterSwitch::do_pBtn_getPlan()
{
    /* 跳出弹窗提示 */
    Warning w(this);
    w.setQSS(EPUIStyle.getQSSPath());
    w.setText("从数据库获取计划，将清空当前所有的计划，请注意保存当前计划!");
    w.exec();
    if(!w.isOk())
    {
        return;
    }
    getExecPlanFromEQM();
}

/* 切换亮色/暗色外观 */
void TransmitterSwitch::do_setUIStyle()
{
    
    this->setStyleSheet(EPUIStyle.StrQSS_TransmitterSwitch);

    /* 给所有的按钮设置样式 */
    ui->pBtn_allFrequency->setStyleSheet(EPUIStyle.StrQSS_PBtnFrequency);
    // LH_WRITE_LOG(QString("频率按钮设置样式:%1").arg(EPUIStyle.StrQSS_PBtnFrequency));
}

/* 选择了一个频率按钮，取消其他的选择 */
void TransmitterSwitch::do_selectFrequencyBtn()
{
    /* 获取信号发送者 */
    auto btn = qobject_cast<QPushButton*>(sender());
    if(btn == nullptr)
    {
        return;
    }
    if(btn != ui->pBtn_allFrequency)
    {
        ui->pBtn_allFrequency->setChecked(false);
    }
    /* 取消其他按钮的选择 */
    for(auto& it : m_listFrequencyBtn)
    {
        if(it != btn)
        {
            it->setChecked(false);
        }
    }
    /* 设置当前按钮的选择状态 */
    btn->setChecked(true);
}




/* 添加一个频率，包括左侧按钮和右侧卡片 */
void TransmitterSwitch::createOneCard(const ChannelInfo& chnInfo)
{
    /* 创建按钮 */
    QPushButton* pBtn = new QPushButton(this);
    pBtn->setObjectName(chnInfo.ChannelName);
    pBtn->setText(chnInfo.ChannelName);
    pBtn->setCheckable(true);
    pBtn->setMinimumHeight(40);

    PBtnUserData2* userData = new PBtnUserData2();
    userData->setChannelInfo(chnInfo);
    pBtn->setUserData(1, userData);

    /* 设置按钮的样式表 */
    pBtn->setStyleSheet(EPUIStyle.StrQSS_PBtnFrequency);
    /* 连接信号和槽 */
    connect(pBtn, &QPushButton::clicked, this, &TransmitterSwitch::do_selectFrequencyBtn);
    m_listFrequencyBtn.push_back(pBtn);

    auto vLayout = qobject_cast<QVBoxLayout*>(ui->widget_frequency->layout());
    /* 减1是去掉最下面的弹簧 */
    vLayout->insertWidget(vLayout->count() - 1, pBtn);

    /* 创建卡片 */
    PlanCard* pCard = PData.createOneCard(chnInfo);
    pCard->setParent(ui->widget_planContent);
    /* 排序 */
}

/* 删除一个频率 */
void TransmitterSwitch::deleteOneCard(int channelID)
{
    /* 删除按钮 */
    for(auto it = m_listFrequencyBtn.begin(); it != m_listFrequencyBtn.end(); ++it)
    {
        auto userData = static_cast<PBtnUserData2*>((*it)->userData(1));
        if(userData != nullptr && userData->getChannelInfo().ChannelID == channelID)
        {
            delete *it;
            m_listFrequencyBtn.erase(it);
            break;
        }
    }

    /* 删除卡片 */
    PData.deleteOneCard(channelID);
}

/* 创建所有频率卡片 */
void TransmitterSwitch::createAllCard()
{
    for(const auto& it : ChnContainer.getMapChannel())
    {
        /* 创建一个按钮和卡片 */
        createOneCard(it);
    }
}

/* 事件过滤器 */
bool TransmitterSwitch::eventFilter(QObject *watched, QEvent *event)
{
    if(watched == ui->label_Tip)
    {
        if(event->type() == QEvent::Enter)
        {
            m_tipText->show();
            return true;
        }else if(event->type() == QEvent::Leave)
        {
            m_tipText->hide();
        }
    }
    return QWidget::eventFilter(watched,event);
}


/* 窗口缩放事件 */
void TransmitterSwitch::resizeEvent(QResizeEvent *event)
{
    /* 设置提示文本的位置 */
    // if(m_tipText != nullptr)
    // {
    //     QPoint pos = ui->label_Tip->mapTo(this, ui->label_Tip->pos());
    //     m_tipText->move(pos.x() + 2, pos.y() + 2 );
    // }
    QWidget::resizeEvent(event);
}