#include "mainwindow.h"

#include <QDateTime>
#include <QMessageBox>
#include <QtConcurrent>
#include <QtCore/QVariant>
#include <QtSerialPort/QSerialPort>
#include <QtSerialPort/QSerialPortInfo>
#include <QtWidgets/QLineEdit>

#include "./ui_mainwindow.h"
#include "iflytop_canbus/iflytop_canbus_master.hpp"
#include "logger.hpp"
#include "qt_serial_datachannel.hpp"
#include "reglist.hpp"
#include "zexception.hpp"
#include "zui/z_function_list_box.hpp"
#include "zui/zq_vtab_page.hpp"
//
#include <thread>

#include "zui/zui.hpp"

using namespace std;
using namespace iflytop;

static MainWindow   *m_mainWindow;
static QTDataChannel G_QTDataChannel;

static int PublicState_DeviceIDVal = 0;

QT_REQUIRE_CONFIG(groupbox);

#define TAG "MainWindow"

static const char *fmt(const char *fmt, ...) {
  va_list args;
  va_start(args, fmt);
  static char buf[1024] = {0};
  vsnprintf(buf, sizeof(buf), fmt, args);
  va_end(args);
  return buf;
}

void MainWindow::log_output(QtMsgType type, const QMessageLogContext &context, const QString &msg) {}
void MainWindow::doinui_slot(QFunction func) {
  if (func.get()) func.get()();
}

/***********************************************************************************************************************
 *                                                     PreviewShow                                                     *
 ***********************************************************************************************************************/

void MainWindow::ishow(QString text) {
  QString info;
  info.append(QDateTime::currentDateTime().toString("hh:mm:ss.zzz "));
  info.append(" |");
  info.append(text);
  emit doinui_signal(QFunction([this, info]() { ui->instructionPreview->append(info); }));
}
void MainWindow::reportPreviewShow(QString text) {
  QString info;

  info.append(QDateTime::currentDateTime().toString("hh:mm:ss.zzz "));
  info.append(text);
  emit doinui_signal(QFunction([this, info]() {
    if (ui->reportPreview->document()->lineCount() > 1000) {
      ui->reportPreview->document()->clear();
    }
    ui->reportPreview->append(info);
  }));
}
void MainWindow::exceptionUploadPreviewShow(QString text) {
  QString info;

  info.append(QDateTime::currentDateTime().toString("hh:mm:ss.zzz "));
  info.append(text);
  emit doinui_signal(QFunction([this, info]() {
    if (ui->uploadDataPreview->document()->lineCount() > 1000) {
      ui->uploadDataPreview->document()->clear();
    }
    ui->uploadDataPreview->append(info);
  }));
}
void MainWindow::rawDataPreviewShow(QString text) {
  QString info;

  info.append(QDateTime::currentDateTime().toString("hh:mm:ss.zzz"));
  info.append(text);
  emit doinui_signal(QFunction([this, info]() {
    if (ui->rawDataPreview->document()->lineCount() > 1000) {
      ui->rawDataPreview->document()->clear();
    }
    ui->rawDataPreview->append(info);
  }));
}

void MainWindow::instructionPreviewClear() {
  doinui_signal(QFunction([this]() { ui->instructionPreview->clear(); }));
}

#pragma pack(push, 1)
typedef struct {
  uint16_t header;
  int16_t  wave1;
  int16_t  wave2;
  int16_t  wave3;
  int16_t  wave4;
  int16_t  wave5;
  uint8_t  check;
  uint16_t tail;
} Wave_t;
#pragma pack(pop)

/***********************************************************************************************************************
 *                                                     UI相关构造                                                      *
 ***********************************************************************************************************************/

void MainWindow::constructBaseUI() {
  /**
   * @brief 指令串口UI
   */
  {
    const auto infos = QSerialPortInfo::availablePorts();
    for (const QSerialPortInfo &info : infos) {
      ui->serialPortCB->addItem(info.portName());
    }
  }

  ui->serialBaudrateCB->addItem("9600");
  ui->serialBaudrateCB->addItem("14400");
  ui->serialBaudrateCB->addItem("19200");
  ui->serialBaudrateCB->addItem("38400");
  ui->serialBaudrateCB->addItem("57600");
  ui->serialBaudrateCB->addItem("115200");
  ui->serialBaudrateCB->addItem("460800");
  ui->serialBaudrateCB->addItem("500000");
  ui->serialBaudrateCB->addItem("2000000");
  ui->serialBaudrateCB->setCurrentIndex(8);

  connect(ui->serialPortRefreshKey, &QPushButton::clicked, this, [this](bool check) {
    ui->serialPortCB->clear();
    const auto infos = QSerialPortInfo::availablePorts();
    for (const QSerialPortInfo &info : infos) {
      ui->serialPortCB->addItem(info.portName());
    }
  });

  connect(ui->serialOpenKey, &QPushButton::clicked, this, [=](bool check) {
    // 打开串口
    if (ui->serialOpenKey->text() == "打开") {
      G_QTDataChannel.setPortName(ui->serialPortCB->currentText().toStdString());
      G_QTDataChannel.setBaudRate(ui->serialBaudrateCB->currentText().toInt());
      G_QTDataChannel.setDataBits(QSerialPort::Data8);
      G_QTDataChannel.setParity(QSerialPort::NoParity);
      G_QTDataChannel.setFlowControl(QSerialPort::NoFlowControl);
      G_QTDataChannel.setStopBits(QSerialPort::OneStop);

      /**
       * @brief 串口打开时，初始化相应参数
       */

      if (!G_QTDataChannel.open()) {
        QMessageBox::about(NULL, "提示", "串口无法打开，串口不存在或已被占??");
        return;
      }
      ui->serialOpenKey->setText("关闭");
      // 下拉菜单控件使能
      ui->serialBaudrateCB->setEnabled(false);
      ui->serialPortCB->setEnabled(false);
      ui->serialPortRefreshKey->setEnabled(false);

      IflytopCanbusMaster::ins()->updateChannelConfig();
    } else {
      G_QTDataChannel.close();
      ui->serialOpenKey->setText("打开");
      ui->serialBaudrateCB->setEnabled(true);
      ui->serialPortCB->setEnabled(true);
      ui->serialPortRefreshKey->setEnabled(true);
    }
  });
}

void MainWindow::displayInfo(bool suc, QString info) {}

MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) {
  /**
   * @brief QT初始化
   */
  ui->setupUi(this);
  m_mainWindow = this;
  qRegisterMetaType<int32_t>("int32_t");
  qRegisterMetaType<uint32_t>("uint32_t");
  qRegisterMetaType<float>("float");
  qRegisterMetaType<function<void()>>("function<void()>");
  qRegisterMetaType<QFunction>("QFunction");
  connect(this, SIGNAL(doinui_signal(QFunction)), this, SLOT(doinui_slot(QFunction)));
  ZQUI::ins()->initialize();
  ZQUI::ins()->setexceptionUploadPreviewShow([this](QString text) { exceptionUploadPreviewShow(text); });
  ZQUI::ins()->setishow([this](QString text) { ishow(text); });
  ZQUI::ins()->setReportPreviewShow([this](QString text) { reportPreviewShow(text); });
  ZQUI::ins()->setRawDataPreviewShow([this](QString text) { rawDataPreviewShow(text); });
  ZQUI::ins()->setInstructionPreviewClear([this]() { instructionPreviewClear(); });

  /**
   * @brief 页面逻辑初始化
   */
  constructBaseUI();
  constructAppUI();

  /**
   * @brief 业务逻辑构造
   */
  G_QTDataChannel.init();
  IflytopCanbusMaster::ins()->initialize(&G_QTDataChannel);

  IflytopCanbusMaster::ins()->regOnRawData([this](packet_type_t type, uint8_t from, uint8_t to, uint8_t *hex, uint32_t hexlen) {
    if (type == kcmd) {
      zcanbus_packet_t *frame = (zcanbus_packet_t *)hex;
      ZQUI::ins()->rawDataPreviewShow("[CMD      ] [%d->%d],%s", from, to, zhex2str(hex, hexlen).c_str());  //
    } else if (type == kerror_receipt) {
      ZQUI::ins()->rawDataPreviewShow("[E-RECEIPT] [%d->%d],%s", from, to, zhex2str(hex, hexlen).c_str());  //
    } else if (type == kreceipt) {
      ZQUI::ins()->rawDataPreviewShow("[RECEIPT  ] [%d->%d],%s", from, to, zhex2str(hex, hexlen).c_str());  //
    } else if (type == kreport) {
      ZQUI::ins()->rawDataPreviewShow("[REPORT   ] [%d->%d],%s", from, to, zhex2str(hex, hexlen).c_str());  //
    }
    processReportPacket(type, from, to, hex, hexlen);
  });
}
MainWindow::~MainWindow() { delete ui; }

void MainWindow::processException(const zexception &e) {  //
  ZQUI::ins()->ishow("%s", e.what());
}
int32_t MainWindow::getDeviceId() { return PublicState_DeviceIDVal; }

/***********************************************************************************************************************
 *                                                    泵机控制接口                                                     *
 ***********************************************************************************************************************/
void MainWindow::constructPumpControlUI(ZQFunctionListBox *box, int targetDeviceId) {
  // ZQFunctionListBox *box = new ZQFunctionListBox(tab, "泵机指令", 4);

  box->newFunc("pump_rotate", {"subid", "rpm"}, [this, targetDeviceId](int argn, const char **args) {  //
    IflytopCanbusMaster::ins()->pump_rotate(targetDeviceId, atoi(args[0]), atoi(args[1]));
  });

  box->newFunc("pump_stop", {"subid"}, [this, targetDeviceId](int argn, const char **args) {  //
    IflytopCanbusMaster::ins()->pump_stop(targetDeviceId, atoi(args[0]));
  });

  box->newFunc("pump_set_ihold_irun_idelay", {"subid", "ihold", "irun", "idelay"}, [this, targetDeviceId](int argn, const char **args) {  //
    IflytopCanbusMaster::ins()->pump_set_ihold_irun_idelay(targetDeviceId, atoi(args[0]), atoi(args[1]), atoi(args[2]), atoi(args[3]));
  });

  box->newFunc("pump_set_acc", {"subid", "acc"}, [this, targetDeviceId](int argn, const char **args) {  //
    IflytopCanbusMaster::ins()->pump_set_acc(targetDeviceId, atoi(args[0]), atoi(args[1]));
  });

  box->newFunc("pump_set_subic_reg", {"subid", "regadd", "val"}, [this, targetDeviceId](int argn, const char **args) {  //
    IflytopCanbusMaster::ins()->pump_set_subic_reg(targetDeviceId, atoi(args[0]), atoi(args[1]), atoi(args[2]));
  });

  box->newFunc("pump_get_subic_reg", {"subid", "regadd"}, [this, targetDeviceId](int argn, const char **args) {  //
    int val = IflytopCanbusMaster::ins()->pump_get_subic_reg(targetDeviceId, atoi(args[0]), atoi(args[1]));
    ZQUI::ins()->ishow("val:%x", val);
  });

  box->newFunc("pump_get_subic_reg", {"subid", "regadd"}, [this, targetDeviceId](int argn, const char **args) {  //
    int val = IflytopCanbusMaster::ins()->pump_get_subic_reg(targetDeviceId, atoi(args[0]), atoi(args[1]));
    ZQUI::ins()->ishow("val:%x", val);
  });
}

/***********************************************************************************************************************
 *                                                  通用操作接口页面                                                   *
 ***********************************************************************************************************************/
void MainWindow::constructCommonOperationTab() {
  ZQVTabPage *tab = new ZQVTabPage(ui->buttonTabWidget, "通用接口");
  // static
  {
    ZQFunctionListBox *box = new ZQFunctionListBox(tab, "通用方法", 4);
    box->newFunc("读板卡信息", {"id"}, [this](int argn, const char **args) {  //
      ack_read_board_info_data_t ack = IflytopCanbusMaster::ins()->readboardinfo(atoi(args[0]));
      ZQUI::ins()->ishow("boardType        :%s(%d)", BoardTypeToString(ack.boardType), ack.boardType);
      ZQUI::ins()->ishow("projectId        :%s(%d)", ProjectIDToString(ack.projectId), ack.projectId);
      ZQUI::ins()->ishow("protcol_version  :%d", ack.protcol_version);
      ZQUI::ins()->ishow("software_version :%d", ack.software_version);
      ZQUI::ins()->ishow("hardware_version :%d", ack.hardware_version);
    });

    box->newFunc("读内存信息", {"id"}, [this](int argn, const char **args) {  //
      ack_sysinfo_t  ack = IflytopCanbusMaster::ins()->readsysinfo(atoi(args[0]));
      ask_taskinfo_t task[20];
      for (int i = 0; i < ack.taskNum; i++) {
        task[i] = IflytopCanbusMaster::ins()->readtaskinfo(atoi(args[0]), i);
      }
      ZQUI::ins()->ishow("=========================== sys  info ===========================");
      ZQUI::ins()->ishow("total_heap_size :%d", ack.total_heap_size);
      ZQUI::ins()->ishow("free_heap_size  :%d", ack.free_heap_size);
      ZQUI::ins()->ishow("sysHasRun       :%d", ack.sysHasRun);
      ZQUI::ins()->ishow("=");

      ZQUI::ins()->ishow("=========================== task info ===========================");
      ZQUI::ins()->ishow("taskoff   name   state    stackRemainSize  priority");
      for (int i = 0; i < ack.taskNum; i++) {
        ZQUI::ins()->ishow("%d    %10s    %c    %d    %d", i, task[i].taskName, task[i].state, task[i].stackRemindSize, task[i].priority);
      }
      ZQUI::ins()->ishow("=");
    });

    box->newFunc("PingAllBoard", {}, [this](int argn, const char **args) {  //
      IflytopCanbusMaster::ins()->pingAllBoard();
    });

    box->newFunc("clear_reset_flag", {"id"}, [this](int argn, const char **args) {  //
      IflytopCanbusMaster::ins()->clear_reset_flag(atoi(args[0]));
    });
  }
}
/***********************************************************************************************************************
 *                                                   消毒拉杆箱界面                                                    *
 ***********************************************************************************************************************/
void MainWindow::constructDrawBarDisinfectionBoxTab() {  //

  ZQVTabPage *tab = new ZQVTabPage(ui->buttonTabWidget, "消毒拉杆箱");

  {
    ZQFunctionListBox *minpowerboard_box = new ZQFunctionListBox(tab, "液路板", 4);
    {
      /**
       * @brief 泵机控制接口
       */
      constructPumpControlUI(minpowerboard_box, kFixBoardId_LiquidCtrl);
    }
    {
      // 喷液MINI真空泵
      minpowerboard_box->newFunc("喷液MINI真空泵控制", {"onoff"}, [this](int argn, const char **args) {  //
        IflytopCanbusMaster::ins()->sl_mini_ac_ctrl(kFixBoardId_LiquidCtrl, atoi(args[0]));
      });
      // 气密性测试MINI真空泵
      minpowerboard_box->newFunc("气密性测试MINI真空泵", {"onoff"}, [this](int argn, const char **args) {  //
        IflytopCanbusMaster::ins()->atta_mini_air_compressor_ctrl(kFixBoardId_LiquidCtrl, atoi(args[0]));
      });
      // 压力传感器总线
      minpowerboard_box->newFunc("压力传感器总线-读数据", {"subid"}, [this](int argn, const char **args) {  //
        int32_t val = IflytopCanbusMaster::ins()->pressure_sensor_bus_read_data(                            //
            kFixBoardId_LiquidCtrl, atoi(args[0]));
        ZQUI::ins()->ishow("val:%d", val);
      });
      minpowerboard_box->newFunc("压力传感器总线-设置上报周期", {"periodms"}, [this](int argn, const char **args) {  //
        IflytopCanbusMaster::ins()->pressure_sensor_bus_set_report_period_ms(                                        //
            kFixBoardId_LiquidCtrl, atoi(args[0]));
      });
    }
  }
}

void MainWindow::construct_largeSpaceDisinfectionTab() {
  //

  int targetId = kFixBoardId_LiquidCtrl;

  ZQVTabPage *tab = new ZQVTabPage(ui->buttonTabWidget, "大空间消毒机");

  {
    ZQFunctionListBox *minpowerboard_box = new ZQFunctionListBox(tab, "液路板", 4);

    constructPumpControlUI(minpowerboard_box, targetId);            // 泵机控制接口
    minpowerboard_box->newFunc("压力传感器总线-读数据", {"subid"},  //
                               [this, targetId](int argn, const char **args) {
                                 int32_t val = IflytopCanbusMaster::ins()->pressure_sensor_bus_read_data(targetId, atoi(args[0]));
                                 ZQUI::ins()->ishow("val:%d", val);
                               });
    minpowerboard_box->newFunc("压力传感器总线-设置上报周期", {"periodms"},  //
                               [this, targetId](int argn, const char **args) { IflytopCanbusMaster::ins()->pressure_sensor_bus_set_report_period_ms(targetId, atoi(args[0])); });
    minpowerboard_box->newFunc("报警灯控制", {"r", "g", "b", "w"},  //
                               [this, targetId](int argn, const char **args) { IflytopCanbusMaster::ins()->triple_warning_light_ctl(targetId, atoi(args[0]), atoi(args[1]), atoi(args[2]), atoi(args[3])); });
    minpowerboard_box->newFunc("读取-蒸发桶水浸传感器-状态", {},  //
                               [this, targetId](int argn, const char **args) {
                                 int state = IflytopCanbusMaster::ins()->evaporation_bin_water_sensor_read_state(targetId);
                                 ZQUI::ins()->ishow("state:%d", state);
                               });
    minpowerboard_box->newFunc("读取-设备底部水浸传感器-状态", {},  //
                               [this, targetId](int argn, const char **args) {
                                 int state = IflytopCanbusMaster::ins()->device_bottom_water_sensor_read_state(targetId);
                                 ZQUI::ins()->ishow("state:%d", state);
                               });
  }
}

void MainWindow::constructAppUI() {
  //
  constructCommonOperationTab();
  constructDrawBarDisinfectionBoxTab();
  construct_largeSpaceDisinfectionTab();
}

void MainWindow::processReportPacket(packet_type_t type, uint8_t from, uint8_t to, uint8_t *hex, uint32_t hexlen) {
  if (type != kreport) {
    return;
  }
  zcanbus_packet_t *frame = (zcanbus_packet_t *)hex;

  if (frame->function_id == kreport_heatpacket_pong) {
    report_heatpacket_data_t *ack = (report_heatpacket_data_t *)frame->params;
    ZQUI::ins()->rshow("[Heat     ][FROM:%03d] HeatIndex:%x ToardType:%s flag:%x", from, ack->heartIndex, BoardTypeToString(ack->boardType), ack->flag);
  }
  //
  else if (frame->function_id == kreport_exception_error) {
    report_exeception_data_t *ack = (report_exeception_data_t *)frame->params;
    ZQUI::ins()->eshow("[Exception][FROM:%03d] subid:%x ecode:%s", from, ack->subid, ErrorCodeToString(ack->ecode));
  }
  //
  else if (frame->function_id == kreport_pressure_data) {
    report_pressure_data_t *ack = (report_pressure_data_t *)frame->params;
    QString                 info;
    info.append(fmt("[Pressure][FROM:%03d](%d)", from, ack->sensorDataNum));
    for (int i = 0; i < ack->sensorDataNum; i++) {
      info.append(fmt(" %d:%d,", ack->data[i].subid, ack->data[i].pressureVal));
    }
    ZQUI::ins()->rshow(info.toStdString().c_str());
  }
  //
  else if (frame->function_id == kreport_h2o2_sensor_data) {
    report_h2o2_data_t *ack = (report_h2o2_data_t *)frame->params;
    QString             info;
    info.append(fmt("[H2O2     ][FROM:%03d] suid:%d,err:%d h2o2:%d (x10ppm),humid:%d (x10),temp:%d (x10),saturation:%d (x10)",  //
                    from, ack->subid, ack->sensor_error, ack->h2o2, ack->humid, ack->temp, ack->saturation));
    ZQUI::ins()->rshow(info.toStdString().c_str());
  }
  //
  else if (frame->function_id == kreport_evaporation_bin_water_sensor) {
    report_water_sensor_state_t *ack = (report_water_sensor_state_t *)frame->params;
    ZQUI::ins()->rshow("[蒸发仓内水浸][FROM:%03d] (%d)", from, ack->state);
  }
  //
  else if (frame->function_id == kreport_device_bottom_water_sensor) {
    report_water_sensor_state_t *ack = (report_water_sensor_state_t *)frame->params;
    ZQUI::ins()->rshow("[设备底部水浸][FROM:%03d] (%d)", from, ack->state);
  }
}

void MainWindow::on_PublicState_ConfirmKey_clicked() { PublicState_DeviceIDVal = ui->PublicState_DeviceID->toPlainText().toInt(); }

void MainWindow::on_clearPreview_clicked() {
  // ZQUI()->
}