/* Copyright(c)--Navinfo--Author:fangzurui--date:2023-05-27 */

#include <QtDebug>
#include "mainwindow.h"

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
    , _pTimer(new QTimer()) {

    // 引用翻译文件
    auto trans = new QTranslator(qApp);
    trans->load(":/test_zh_CN.qm");
    qApp->installTranslator(trans);

    this->setWindowIcon(QIcon(QCoreApplication::applicationDirPath() + "\\Resource\\dmatch.ico"));
    ui->setupUi(this);
}

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

void MainWindow::initMainWindow() {
    // 初始化任务栏
    initTaskBar();

    // 初始化侧边栏
    initImageSideBar();
    initMarkPointSideBar();

    // 初始化渲染窗口
    initOsgRender();

    // 初始化底部栏
    initButtomBar();

    // 初始化数据库
    initDatabase();

    QMessageBox* welcomeMessage = new QMessageBox(QMessageBox::Information,
                                                  QObject::tr("Welcome"),
                                                  QObject::tr("Everything is Ready"),
                                                  QMessageBox::Button::NoButton, this);
    // 定时关闭窗口
    QTimer::singleShot(500, welcomeMessage, SLOT(accept()));
    welcomeMessage->exec();

    // 自动关闭欢迎窗口时触发事件
    if(welcomeMessage->close() == true) {
        // 根据时间刷新一次图像管理表格
        emit ui->SearchButton->clicked();
        // 根据数据库记录点跳转位置
        if(_lastMapPoint._dLon != 0.0) {
            OSGRender::getInstance()->setViewPoint("cache", _lastMapPoint, 0, -90.0, 500);
            // 根据ImageLayer中最后一个图像的信息，设置当前图像记录
            if(RenderNode::getInstance()->_pImageLayer->getImageVec().size() == 0) {
                return;
            } else {
                _pCurrentImage = RenderNode::getInstance()->_pImageLayer->getImageVec().back();
            }
        } else {
            return;
        }
        delete welcomeMessage;
        welcomeMessage = nullptr;
    }
}

/*  -------------------------------------- 任务栏初始化 --------------------------------------   */
/**
 * @brief MainWindow::initTaskBar
 * 初始化任务栏
 */
void MainWindow::initTaskBar() {
    // 初始化ui界面
    ui->ImportImage->setText(QObject::tr("Import Image"));
    ui->SaveImage->setText(QObject::tr("Save Image"));
    ui->ExportMarkPoint->setText(QObject::tr("Export Task"));
    ui->ImportMarkPoint->setText(QObject::tr("Import Task"));
    ui->CoordLocate->setText(QObject::tr("Map Locate"));

    connect(ui->ImportImage, SIGNAL(clicked(bool)), this, SLOT(importImage()));
    connect(ui->SaveImage, SIGNAL(clicked(bool)), this, SLOT(saveImage()));
    connect(ui->ExportMarkPoint, SIGNAL(clicked(bool)), this, SLOT(exportMarkPoint()));
    connect(ui->ImportMarkPoint, SIGNAL(clicked(bool)), this, SLOT(importMarkPoint()));
    connect(ui->CoordLocate, SIGNAL(clicked(bool)), this, SLOT(coordLocate()));
    connect(OSGRender::getInstance(), SIGNAL(updateImage(Image*)), this, SLOT(updateImage(Image*)));
}

void MainWindow::loadDefaultImage() {
    // 获取默认高程数据存放的文件路径
    QDir defaultDEMDir(QCoreApplication::applicationDirPath() + "\\defaultDEM");

    QStringList fileType;
    fileType << "*.tif";        // 读取所有tif文件的文件名

    QStringList demFileNameList = defaultDEMDir.entryList(fileType, QDir::Files | QDir::Readable, QDir::Name);
    // 加载数据
    for(int i = 0; i < demFileNameList.size(); i++) {
        osg::ref_ptr<TifDemLayer> demLayer = RenderNode::getInstance()->getOrCreateTifDemData(defaultDEMDir.path().toStdString() + "\\" + demFileNameList.at(i).toStdString(), "defaultDEM");
    }

//    // 获取默认影像数据存放的文件路径
//    QDir defaultImageDir(QCoreApplication::applicationDirPath() + "\\defaultImage");
//    QStringList ImageFileNameList = defaultImageDir.entryList(fileType, QDir::Files | QDir::Readable, QDir::Name);
//    for(int i = 0; i < ImageFileNameList.size(); i++) {
//        osg::ref_ptr<TifImageLayer> imageLayer = RenderNode::getInstance()->getOrCreateTifImageData(defaultImageDir.path().toStdString() + "\\" + ImageFileNameList.at(i).toStdString(), "defaultImage");
//    }
}

/**
 * @brief MainWindow::readTifManageFile
 * 读取TifManageFile文件
 */
void MainWindow::readImageManageFile() {
    // 创建tif图层
    RenderNode::getInstance()->createImageLayer(new ImageLayer());

    // 读取数据库
    ImageInfoDb* imageInfoDb = new ImageInfoDb();
    if(imageInfoDb->open(QCoreApplication::applicationDirPath() + "\\dmatch.db") == true) {
        // 获取刚刚创建的图层
        ImageLayer* imageLayer = RenderNode::getInstance()->getImageLayer();

        // 从数据库中读取图像信息
        std::vector<Image*> vecImage = imageInfoDb->getAllImage();
        for(int i = 0; i < vecImage.size(); i++) {
            // 将读取的图像信息放到内存中
            Image* image = imageLayer->createImage(vecImage.at(i)->getImageName(),
                                                   vecImage.at(i)->getImageDate(),
                                                   vecImage.at(i)->getImageType(),
                                                   vecImage.at(i)->getImageCenterCoord());

            // 加载数据
            osg::ref_ptr<TifImageLayer> pImage = RenderNode::getInstance()->getOrCreateTifImageData(
                QCoreApplication::applicationDirPath().toStdString() + "\\tifMaxRect\\" + vecImage.at(i)->getImageName() + ".tif",
                "SavedImage");
            image->setImagePtr(pImage);
            imageLayer->addImage(image);
            updateImageFileTable();
        }
    } else {
        QMessageBox::warning(this,
                             QObject::tr("Waring"),
                             QObject::tr("Cannot Connect Database"),
                             QMessageBox::Ok, QMessageBox::Ok);
        return;
    }
    delete imageInfoDb;
    imageInfoDb = nullptr;
}

void MainWindow::readMarkPoint() {
    // 读取数据库
    MarkPointDb* markPointDb = new  MarkPointDb();

    // 数据库如果不为空，则置空数据库
    if(markPointDb->getAllMarkPoint().size() != 0) {
        markPointDb->clearMarkPoint();
    }

    delete markPointDb;
    markPointDb = nullptr;
}

void MainWindow::readCache() {
    // 读取数据库
    PositionDb* positionDb = new PositionDb();
    if(positionDb->open(QCoreApplication::applicationDirPath() + "\\dmatch.db") == true) {
        // 从数据库中读取坐标点信息
        _lastMapPoint = positionDb->getPosition();
    } else {
        QMessageBox::warning(this,
                             QObject::tr("Waring"),
                             QObject::tr("Cannot Connect Database"),
                             QMessageBox::Ok, QMessageBox::Ok);
        return;
    }
    delete positionDb;
    positionDb = nullptr;
}

/**
 * @brief MainWindow::switchToTask
 * 切换到标记模式
 */
void MainWindow::setMarkPoint() {
    int state = OSGRender::getDrawState();
    if(state != 3) {
        ui->SetMarkPointButton->setDown(true);
        OSGRender::getInstance()->setDrawState(3);
    } else {
        ui->SetMarkPointButton->setDown(false);
        OSGRender::getInstance()->setDrawState(0);
    }
}

/**
 * @brief MainWindow::importImage
 * 导入图像
 */
void MainWindow::importImage() {
    // 创建数据库对象
    ImageInfoDb* imageInfoDb = new ImageInfoDb();
    std::vector<Image*> vecImage = imageInfoDb->getAllImage();

    // 检查是否已经存入数组
    if(_pCurrentImage == nullptr) {
        // next
    } else if(vecImage.size() == 0 && _pCurrentImage != nullptr) {
        int result = QMessageBox::warning(this,
                                          QObject::tr("Waring"),
                                          QObject::tr("Import New Image, This Image Will Delete"),
                                          QMessageBox::Ok | QMessageBox::Cancel,
                                          QMessageBox::Cancel);
        if(result == QMessageBox::Cancel) {
            return;
        }
    } else {
        if(imageInfoDb->isExists(_pCurrentImage) == false) {
            int result = QMessageBox::warning(this,
                                              QObject::tr("Waring"),
                                              QObject::tr("Import New Image, This Image Will Delete"),
                                              QMessageBox::Ok | QMessageBox::Cancel,
                                              QMessageBox::Cancel);
            if(result == QMessageBox::Cancel) {
                return;
            }
        }
    }

    // 创建基本参数窗口
    if(_widgetImportImageFile == nullptr) {
        _widgetImportImageFile = new ImageFileImport(this);
    }
//    _widgetImportImageFile->exec();
    _widgetImportImageFile->show();
}

/**
 * @brief MainWindow::saveImage
 * 记录tif文件名称到list中
 */
 void MainWindow::saveImage() {
    // 获取tif图层
    ImageLayer* imageLayer = RenderNode::getInstance()->getImageLayer();
    if(_pCurrentImage == nullptr) {
        QMessageBox::warning(this,
                             QObject::tr("Warning"),
                             QObject::tr("No Image Need To Save"),
                             QMessageBox::Ok, QMessageBox::Ok);
        return;
    } else {
        // 读取数据库
        ImageInfoDb* imageInfoDb = new ImageInfoDb();
        if(imageInfoDb->open(QCoreApplication::applicationDirPath() + "\\dmatch.db") == false) {
            QMessageBox::warning(this,
                                 QObject::tr("Warning"),
                                 QObject::tr("Cannot Open Database"),
                                 QMessageBox::Ok,
                                 QMessageBox::Ok);
            return;
        }

        // 判断是否已经保存
        if(imageInfoDb->isExists(_pCurrentImage) == true) {
            QMessageBox::warning(this,
                                 QObject::tr("Warning"),
                                 QObject::tr("This Image Is Already Saved"),
                                 QMessageBox::Ok, QMessageBox::Ok);
            return;
        } else {
            // 确认是否保存
            int result = QMessageBox::information(this,
                                              QObject::tr("Warning"),
                                              QObject::tr("This Image Will Be Saved"),
                                              QMessageBox::Ok | QMessageBox::Cancel,
                                              QMessageBox::Cancel);
            if(result == QMessageBox::Cancel) {
                return;
            } else {
                // 写入到数据库中
                imageInfoDb->saveImage(_pCurrentImage);
                imageLayer->addImage(_pCurrentImage);
                QMessageBox::information(this,
                                         QObject::tr("Finished"),
                                         QObject::tr("Save Image Finished"),
                                         QMessageBox::Ok, QMessageBox::Ok);
                updateImageFileTable();
            }
        }
        // 释放
        delete imageInfoDb;
        imageInfoDb = nullptr;
    }
}

/**
 * @brief MainWindow::exportTask
 * 标注导出
 */
void MainWindow::exportMarkPoint() {
    if(_widgetExportMarkPointFile == nullptr) {
        _widgetExportMarkPointFile = new MarkPointFileExport();
    }

    MarkPointLayer* layer = RenderNode::getInstance()->getMarkPointLayer();
    // 如果数组为空
    if(layer->getMarkPointVec().empty() == true) {
        QMessageBox::warning(this,
                             QObject::tr("Waring"),
                             QObject::tr("No Mark Point Need To Export"),
                             QMessageBox::Ok, QMessageBox::Ok);
        return;
    } else {
        _widgetExportMarkPointFile->exec();
    }
}

/**
 * @brief MainWindow::importTask
 * 标注导入
 */
void MainWindow::importMarkPoint() {
    if(_widgetImportMarkPointFile == nullptr) {
        _widgetImportMarkPointFile = new MarkPointFileImport(this);
    }
    _widgetImportMarkPointFile->exec();
//    _widgetImportMarkPointFile->show();
    updateMarkPointTable();
}

/**
 * @brief MainWindow::coordLocate
 * 地图定位
 */
void MainWindow::coordLocate() {
    if(_widgetCoordLocate == nullptr) {
        _widgetCoordLocate = new CoordLocate(this);
    }
//    _widgetCoordLocate->exec();
    _widgetCoordLocate->show();
}

void MainWindow::updateImage(Image* image) {
    // 移除掉之前的影像
    if(_pCurrentImage != nullptr) {
        RenderNode::getInstance()->deleteTifImageData(_pCurrentImage->getImagePtr());
    }

    if(image != nullptr) {
        // 将新创建的Image设为当前Image
        _pCurrentImage = image;
        osg::ref_ptr<TifImageLayer> imageLayer =
            RenderNode::getInstance()->getOrCreateTifImageData(
                QCoreApplication::applicationDirPath().toStdString() + "\\tifMaxRect\\" +
                    _pCurrentImage->getImageName() + ".tif", "Image");
        _pCurrentImage->setImagePtr(imageLayer);

        // 将新创建的Image的中心点设为当前中心点
        _lastMapPoint = _pCurrentImage->getImageCenterCoord();
    }
}

/*  -------------------------------------- 影像层侧边栏 --------------------------------------   */
/**
 * @brief MainWindow::initImageSideBar
 * 初始化影像层侧边栏
 */
void MainWindow::initImageSideBar() {
    // Image侧边栏
    ui->SideTabBar->setTabText(0, QObject::tr("History Image"));

    // 更新影像文件表格
    ui->ImageFileTable->setColumnCount(6);        // 序号 名称
    ui->ImageFileTable->horizontalHeader()->setStretchLastSection(true);
    ui->ImageFileTable->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);

    // 设置影像表单组件
    QTableWidgetItem* selectAll = new QTableWidgetItem();
    QTableWidgetItem* name = new QTableWidgetItem();
    QTableWidgetItem* createDate = new QTableWidgetItem();
    QTableWidgetItem* imgType = new QTableWidgetItem();
    QTableWidgetItem* centerLon = new QTableWidgetItem();
    QTableWidgetItem* centerLat = new QTableWidgetItem();
    selectAll->setCheckState(Qt::Unchecked);
    name->setText(QObject::tr("Name"));
    createDate->setText(QObject::tr("Date"));
    imgType->setText(QObject::tr("Type"));
    centerLon->setText(QObject::tr("Longitude"));
    centerLat->setText(QObject::tr("Latitude"));
    ui->ImageFileTable->setHorizontalHeaderItem(0, selectAll);
    ui->ImageFileTable->setHorizontalHeaderItem(1, name);
    ui->ImageFileTable->setHorizontalHeaderItem(2, createDate);
    ui->ImageFileTable->setHorizontalHeaderItem(3, imgType);
    ui->ImageFileTable->setHorizontalHeaderItem(4, centerLon);
    ui->ImageFileTable->setHorizontalHeaderItem(5, centerLat);

    // 设置搜索组件
    ui->StartDate->setMaximumDate(QDate::currentDate().addMonths(1));
    ui->EndDate->setMaximumDate(QDate::currentDate().addMonths(1));
    ui->StartDate->setDate(QDate::currentDate().addMonths(-1));
    ui->EndDate->setDate(QDate::currentDate());
    ui->SearchTypeBox->addItem(QObject::tr("All"));
    ui->SearchTypeBox->addItem(QObject::tr("Infrared Image"));
    ui->SearchTypeBox->addItem(QObject::tr("Visible Image"));
    ui->SearchButton->setText(QObject::tr("Search"));
    ui->SearchReset->setText(QObject::tr("Reset"));
    // 设置图像表单组件
    ui->ImageFileTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
    ui->ImageSelectAll->setText(QObject::tr("Select All"));
    ui->ImageFileDelete->setText(QObject::tr("Delete"));

    // 双击加载选择的tif到地球
    connect(ui->ImageFileTable, SIGNAL(cellDoubleClicked(int,int)), this, SLOT(loadGenerateTif(int,int)));
    // 点击全选
    connect(ui->ImageSelectAll, SIGNAL(clicked(bool)), this, SLOT(selectAllImage()));
    // 点击复选框选中影像
    connect(ui->ImageFileTable, SIGNAL(itemClicked(QTableWidgetItem*)), this, SLOT(selectImage(QTableWidgetItem*)));
    // 点击删除按钮删除指定序号的tif文件
    connect(ui->ImageFileDelete, SIGNAL(clicked(bool)), this, SLOT(deleteImageFile()));
    // 点击搜索按钮进行搜索
    connect(ui->SearchButton, SIGNAL(clicked(bool)), this, SLOT(searchImage()));
    // 点击重置按钮进行搜索
    connect(ui->SearchReset, SIGNAL(clicked(bool)), this, SLOT(resetSearch()));
}

void MainWindow::searchImage() {
    // 创建影像数据库对象
    ImageInfoDb* imageInfoDb = new ImageInfoDb();
    std::vector<Image*> vecSearchResult;
    if(ui->StartDate->date() < ui->EndDate->date()) {
        vecSearchResult = imageInfoDb->searchImage(ui->StartDate->date(),
                                                   ui->EndDate->date().addDays(1),
                                                   ui->SearchTypeBox->currentText().toStdString());
    } else {
        vecSearchResult = imageInfoDb->searchImage(ui->EndDate->date(),
                                                   ui->StartDate->date().addDays(1),
                                                   ui->SearchTypeBox->currentText().toStdString());
    }

    // 先清空表格原始的内容
    ui->ImageFileTable->clearContents();

    // 按照长度更新表格
    ui->ImageFileTable->setRowCount(vecSearchResult.size());
    if(vecSearchResult.size() == 0) {
        return;
    }
    for(int i = 0; i < vecSearchResult.size(); i++) {
        QTableWidgetItem* checkbox = new QTableWidgetItem();
        checkbox->setCheckState(Qt::Unchecked);

        QTableWidgetItem* name = new QTableWidgetItem(vecSearchResult.at(i)->getImageName().c_str());
        QTableWidgetItem* createDate = new QTableWidgetItem(vecSearchResult.at(i)->getImageDate().c_str());
        QTableWidgetItem* imgType = new QTableWidgetItem(vecSearchResult.at(i)->getImageType().c_str());
        QTableWidgetItem* lon = new QTableWidgetItem(QString::number(vecSearchResult.at(i)->getImageCenterCoord()._dLon, 'f', 7));
        QTableWidgetItem* lat = new QTableWidgetItem(QString::number(vecSearchResult.at(i)->getImageCenterCoord()._dLat, 'f', 7));

        ui->ImageFileTable->setItem(vecSearchResult.size() - 1 - i, 0, checkbox);
        ui->ImageFileTable->setItem(vecSearchResult.size() - 1 - i, 1, name);
        ui->ImageFileTable->setItem(vecSearchResult.size() - 1 - i, 2, createDate);
        ui->ImageFileTable->setItem(vecSearchResult.size() - 1 - i, 3, imgType);
        ui->ImageFileTable->setItem(vecSearchResult.size() - 1 - i, 4, lon);
        ui->ImageFileTable->setItem(vecSearchResult.size() - 1 - i, 5, lat);
    }
    _vecSelectImage.clear();

    delete imageInfoDb;
    imageInfoDb = nullptr;
}

void MainWindow::resetSearch() {
    // 重置输入参数
    ui->StartDate->setDate(QDate::currentDate());
    ui->EndDate->setDate(QDate::currentDate().addMonths(1));
    ui->SearchTypeBox->setCurrentIndex(0);

    searchImage();
}

/**
 * @brief MainWindow::updateTifFileTable
 * 更新侧边栏Tif文件表格的内容
 */
void MainWindow::updateImageFileTable() {
    // 创建影像数据库对象
    ImageInfoDb* imageInfoDb = new ImageInfoDb();
    std::vector<Image*> vecImage = imageInfoDb->getAllImage();

    // 先清空表格原始的内容
    ui->ImageFileTable->clearContents();

    // 按照长度更新表格
    ui->ImageFileTable->setRowCount(vecImage.size());
    if(vecImage.size() == 0) {
        return;
    }
    for(int i = 0; i < vecImage.size(); i++) {
        QTableWidgetItem* checkbox = new QTableWidgetItem();
        checkbox->setCheckState(Qt::Unchecked);

        QTableWidgetItem* name = new QTableWidgetItem(vecImage.at(i)->getImageName().c_str());
        QTableWidgetItem* createDate = new QTableWidgetItem(vecImage.at(i)->getImageDate().c_str());
        QTableWidgetItem* imgType = new QTableWidgetItem(vecImage.at(i)->getImageType().c_str());
        QTableWidgetItem* lon = new QTableWidgetItem(QString::number(vecImage.at(i)->getImageCenterCoord()._dLon, 'f', 7));
        QTableWidgetItem* lat = new QTableWidgetItem(QString::number(vecImage.at(i)->getImageCenterCoord()._dLat, 'f', 7));

        ui->ImageFileTable->setItem(vecImage.size() - 1 - i, 0, checkbox);
        ui->ImageFileTable->setItem(vecImage.size() - 1 - i, 1, name);
        ui->ImageFileTable->setItem(vecImage.size() - 1 - i, 2, createDate);
        ui->ImageFileTable->setItem(vecImage.size() - 1 - i, 3, imgType);
        ui->ImageFileTable->setItem(vecImage.size() - 1 - i, 4, lon);
        ui->ImageFileTable->setItem(vecImage.size() - 1 - i, 5, lat);
    }
    _vecSelectImage.clear();

    delete imageInfoDb;
    imageInfoDb = nullptr;
}

/**
 * @brief MainWindow::loadGenerateTif
 * 在地球上展示选中的tif
 */
void MainWindow::loadGenerateTif(int i, int j) {
    // 获取需要加载的文件名称
    if(ui->ImageFileTable->item(i, 1) == nullptr) {
        return;
    }

    // 与数据库建立链接
    ImageInfoDb* imageInfoDb = new ImageInfoDb();

    // 获取影像图层
    ImageLayer* imageLayer = new ImageLayer();

    // 找到目标路径
    QString tifFilePath = QCoreApplication::applicationDirPath() + "\\tifMaxRect\\" + ui->ImageFileTable->item(i, 1)->text() + ".tif";

    // 获取创建时间
    QString strDate = ui->ImageFileTable->item(i, 2)->text();

    // 判断是否已经加载
    for(int i = 0; i < imageLayer->getImageVec().size(); i++) {
        if(strDate == imageLayer->getImageDate(i).c_str()) {
            // 先移除影像
            RenderNode::getInstance()->deleteTifImageData(imageLayer->getImage(i)->getImagePtr());
            // 重新获取该对象
            osg::ref_ptr<TifImageLayer> pImage = RenderNode::getInstance()->getOrCreateTifImageData(tifFilePath.toStdString(), "CurrentImage");
            // 重新设置
            imageLayer->getImage(i)->setImagePtr(pImage);
            // 设置视点
            OSGRender::getInstance()->setViewPoint("ImageView", imageLayer->getImageCenterCoord(i), 0, -90.0, imageLayer->getImageCenterCoord(i)._dAlt + 500);

            delete imageInfoDb;
            imageInfoDb = nullptr;
            return;
        }
    }
    // 如果未加载
    Image* image = imageInfoDb->getImageByDate(strDate);
    if(image == nullptr) {
        QMessageBox::warning(this,
                             QObject::tr("Warning"),
                             QObject::tr("Cannot Get Image From Database"),
                             QMessageBox::Ok,
                             QMessageBox::Ok);
        delete imageInfoDb;
        imageInfoDb = nullptr;
        return;
    }

    MapPoint tifCenterCoord = image->getImageCenterCoord();
    if(tifCenterCoord._dLon != 0.0) {
        // 加载到三维地球中
        osg::ref_ptr<TifImageLayer> tifImageLayer = RenderNode::getInstance()->getOrCreateTifImageData(tifFilePath.toStdString(), "calibratedImage");

        // 设为当前图层
        if(_pCurrentImage == nullptr) {
            _pCurrentImage = new Image();
        }
        _pCurrentImage->setImageName(image->getImageName());
        _pCurrentImage->setImageDate(image->getImageDate());
        _pCurrentImage->setImageType(image->getImageType());
        _pCurrentImage->setImageCenterCoord(image->getImageCenterCoord());
        _pCurrentImage->setImagePtr(tifImageLayer);
        OSGRender::getInstance()->setViewPoint("ImageView", tifCenterCoord, 0, -90.0, tifCenterCoord._dAlt + 500);

        // 添加到图层
        imageLayer->addImage(_pCurrentImage);
    }
    delete imageInfoDb;
    imageInfoDb = nullptr;
}

void MainWindow::selectAllImage() {
    // 判断是否已经选择
    if(_vecSelectImage.size() == ui->ImageFileTable->rowCount()) {
        for(int i = 0; i < ui->ImageFileTable->rowCount(); i++) {
            ui->ImageFileTable->item(i, 0)->setCheckState(Qt::Unchecked);
        }
        _vecSelectImage.clear();
    } else {
        for(int i = 0; i < ui->ImageFileTable->rowCount(); i++) {
            if(ui->ImageFileTable->item(i, 0)->checkState() == Qt::Checked) {
                continue;
            } else {
                ui->ImageFileTable->item(i, 0)->setCheckState(Qt::Checked);
                _vecSelectImage.push_back(ui->ImageFileTable->item(i, 2)->text().toStdString());
            }
        }
    }
}

void MainWindow::selectImage(QTableWidgetItem* checkbox) {
    // 获取表格中的创建时间字段
    if(checkbox->checkState() == Qt::Checked) {
        _vecSelectImage.push_back(ui->ImageFileTable->item(checkbox->row(), 2)->text().toStdString());
    }
    if(checkbox->checkState() == Qt::Unchecked) {
        // 已选择则取消选择并从选择数组中移除
        for(int num = 0; num < _vecSelectImage.size(); num++) {
            if(ui->ImageFileTable->item(checkbox->row(), 2)->text().toStdString() == _vecSelectImage.at(num)) {
                _vecSelectImage.erase(_vecSelectImage.begin() + num);
                break;
            }
        }
    }
}

void MainWindow::deleteImageFile() {
    // 判断是否有选点
    if(_vecSelectImage.size() == 0) {
        QMessageBox::warning(this,
                             QObject::tr("Waring"),
                             QObject::tr("No Image Selected"),
                             QMessageBox::Ok, QMessageBox::Ok);
        return;
    } else {
        for(int i = 0; i < _vecSelectImage.size(); i++) {
            deleteImageFile(_vecSelectImage.at(i));
        }
        _vecSelectImage.clear();
    }
    // 更新影像表格
    updateImageFileTable();
}

/**
 * @brief MainWindow::deleteTifFile
 * 删除tif文件
 */
void MainWindow::deleteImageFile(std::string imageDate) {
    // 从数据库中移除
    ImageInfoDb* imageInfoDb = new ImageInfoDb();
    // 获取tif图层
    ImageLayer* imageLayer = RenderNode::getInstance()->getImageLayer();

    if(imageLayer->isExists(imageDate) == false) {
        QMessageBox::warning(this,
                             QObject::tr("Waring"),
                             QObject::tr("Cannot Get Choose Item"),
                             QMessageBox::Ok, QMessageBox::Ok);
    } else {
        // 从三维地球上移除
        osg::ref_ptr<TifImageLayer> tif = imageLayer->getTifImage(imageDate);
        if(tif != nullptr) {
            RenderNode::getInstance()->deleteTifImageData(imageLayer->getTifImage(imageDate));
            imageInfoDb->removeImage(imageDate);
            imageLayer->deleteImage(imageDate);
            _pCurrentImage = nullptr;
        }
    }
    delete imageInfoDb;
    imageInfoDb = nullptr;
}

/*  -------------------------------------- 标记点侧边栏 -------------------------------------   */
/**
 * @brief MainWindow::initSideBar
 * 初始化标记点侧边栏
 */
void MainWindow::initMarkPointSideBar() {
    // MarkPoint侧边栏
    ui->SideTabBar->setTabText(1, QObject::tr("Task Infomation"));

    // 更新任务点表格
    ui->SetMarkPointButton->setText(QObject::tr("Set Mark"));
    ui->MarkPointTable->setColumnCount(5);      // 序号 经度 纬度 高程
    ui->MarkPointTable->horizontalHeader()->setStretchLastSection(true);
    ui->MarkPointTable->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);

//    ui->MarkPointTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Interactive);
//    ui->MarkPointTable->horizontalHeader()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
//    ui->MarkPointTable->horizontalHeader()->setSectionResizeMode(1, QHeaderView::ResizeToContents);
//    ui->MarkPointTable->horizontalHeader()->setSectionResizeMode(2, QHeaderView::ResizeToContents);
//    ui->MarkPointTable->horizontalHeader()->setSectionResizeMode(3, QHeaderView::ResizeToContents);
//    ui->MarkPointTable->horizontalHeader()->setSectionResizeMode(4, QHeaderView::ResizeToContents);

    // 设置任务点表单组件
    QTableWidgetItem* selectAll = new QTableWidgetItem();
    QTableWidgetItem* coordId = new QTableWidgetItem();
    QTableWidgetItem* coordLon = new QTableWidgetItem();
    QTableWidgetItem* coordLat = new QTableWidgetItem();
    QTableWidgetItem* coordAlt = new QTableWidgetItem();
    selectAll->setCheckState(Qt::Unchecked);
    coordId->setText(QObject::tr("Name"));
    coordLon->setText(QObject::tr("Longitude"));
    coordLat->setText(QObject::tr("Latitude"));
    coordAlt->setText(QObject::tr("Altitude"));
    ui->MarkPointTable->setHorizontalHeaderItem(0, selectAll);
    ui->MarkPointTable->setHorizontalHeaderItem(1, coordId);
    ui->MarkPointTable->setHorizontalHeaderItem(2, coordLon);
    ui->MarkPointTable->setHorizontalHeaderItem(3, coordLat);
    ui->MarkPointTable->setHorizontalHeaderItem(4, coordAlt);

    ui->MarkPointTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
    ui->MarkPointSelectAll->setText(QObject::tr("Select All"));
    ui->MarkPointDelete->setText(QObject::tr("Delete"));
    ui->MarkPointClear->setText(QObject::tr("Clear"));

    // 点击放置任务点
    connect(ui->SetMarkPointButton,SIGNAL(clicked(bool)), this, SLOT(setMarkPoint()));
    // 双击跳转到选择的任务点坐标位置
    connect(ui->MarkPointTable, SIGNAL(cellDoubleClicked(int,int)), this, SLOT(jumpCoordPos(int,int)));
    // 点击全选
    connect(ui->MarkPointSelectAll, SIGNAL(clicked(bool)), this, SLOT(selectAllMarkPoint()));
    // 点击复选框选中任务点
    connect(ui->MarkPointTable, SIGNAL(itemClicked(QTableWidgetItem*)), this, SLOT(selectMarkPoint(QTableWidgetItem*)));
    // 点击删除按钮删除勾线的任务点
    connect(ui->MarkPointDelete, SIGNAL(clicked(bool)), this, SLOT(deleteMarkPoint()));
    // 点击删除按钮删除指定序号的任务点
    connect(ui->MarkPointClear, SIGNAL(clicked(bool)), this, SLOT(clearMarkPoint()));
    // 任务点侧边栏更新事件
    connect(OSGRender::getInstance(), SIGNAL(updateMarkPointTable()), this, SLOT(updateMarkPointTable()));
    // 删除指定任务点
    connect(OSGRender::getInstance(), SIGNAL(deleteMarkPoint(int)), this, SLOT(deleteMarkPoint(int)));
}

/**
 * @brief MainWindow::updateMarkPointTable
 * 更新侧边栏任务点表格的内容
 */
void MainWindow::updateMarkPointTable() {
    // 获取数据库对象
    MarkPointDb* markPointDb = new MarkPointDb();
    std::vector<MarkPoint*> vecMarkPoint = markPointDb->getAllMarkPoint();

    // 先清空表格原始的内容
    ui->MarkPointTable->clearContents();

    // 根据数据库信息设置表格内容
    ui->MarkPointTable->setRowCount(vecMarkPoint.size());
    if(vecMarkPoint.size() == 0) {
        return;
    }
    for(int i = 0; i < vecMarkPoint.size(); i++) {
        QTableWidgetItem* checkbox = new QTableWidgetItem();
        checkbox->setCheckState(Qt::Unchecked);

        QTableWidgetItem* id = new QTableWidgetItem(QString(vecMarkPoint.at(i)->getId().c_str()));
        QTableWidgetItem* lon = new QTableWidgetItem(QString::number(vecMarkPoint.at(i)->getMapPoint()._dLon, 'f', 7));
        QTableWidgetItem* lat = new QTableWidgetItem(QString::number(vecMarkPoint.at(i)->getMapPoint()._dLat, 'f', 7));
        QTableWidgetItem* alt = new QTableWidgetItem(QString::number(vecMarkPoint.at(i)->getMapPoint()._dAlt, 'f', 2));

        ui->MarkPointTable->setItem(i, 0, checkbox);
        ui->MarkPointTable->setItem(i, 1, id);
        ui->MarkPointTable->setItem(i, 2, lon);
        ui->MarkPointTable->setItem(i, 3, lat);
        ui->MarkPointTable->setItem(i, 4, alt);
    }
    ui->SetMarkPointButton->setDown(false);
    _vecSelectMarkPoint.clear();

    delete markPointDb;
    markPointDb = nullptr;
}

void MainWindow::selectAllMarkPoint() {
    // 判断是否已经选择
    if(_vecSelectMarkPoint.size() == ui->MarkPointTable->rowCount()) {
        // 全选则全部取消
        for(int i = 0; i < ui->MarkPointTable->rowCount(); i++) {
            ui->MarkPointTable->item(i, 0)->setCheckState(Qt::Unchecked);
        }
        _vecSelectMarkPoint.clear();
    } else {
        for(int i = 0; i < ui->MarkPointTable->rowCount(); i++) {
            if(ui->MarkPointTable->item(i, 0)->checkState() == Qt::Checked) {
                continue;
            } else {
                ui->MarkPointTable->item(i, 0)->setCheckState(Qt::Checked);
                _vecSelectMarkPoint.push_back(ui->MarkPointTable->item(i, 1)->text().toStdString());
            }
        }
    }
}

void MainWindow::selectMarkPoint(QTableWidgetItem* checkbox) {
    // 如果状态未选
    if(checkbox->checkState() == Qt::Checked) {
        _vecSelectMarkPoint.push_back(ui->MarkPointTable->item(checkbox->row(), 1)->text().toStdString());
    }
    if(checkbox->checkState() == Qt::Unchecked) {
        // 已选择则取消选择并从选择数组中移除
        for(int num = 0; num < _vecSelectMarkPoint.size(); num++) {
            if(ui->MarkPointTable->item(checkbox->row(), 1)->text().toStdString() == _vecSelectMarkPoint.at(num)) {
                _vecSelectMarkPoint.erase(_vecSelectMarkPoint.begin() + num);
                break;
            }
        }
    }
}

/**
 * @brief MainWindow::deleteTaskPoint
 * 删除侧边任务栏表格中对应任务点
 */
void MainWindow::deleteMarkPoint() {
    // 判断是否有选点
    if(_vecSelectMarkPoint.size() == 0) {
        QMessageBox::warning(this,
                             QObject::tr("Waring"),
                             QObject::tr("No Mark Point Selected"),
                             QMessageBox::Ok, QMessageBox::Ok);
        return;
    } else {
        for(int i = 0; i < _vecSelectMarkPoint.size(); i++) {
            deleteMarkPoint(_vecSelectMarkPoint.at(i));
        }
        _vecSelectMarkPoint.clear();
    }
    updateMarkPointTable();
}

void MainWindow::deleteMarkPoint(int num) {
    // 记录到数据库
    MarkPointDb* markPointDb = new MarkPointDb();
    // 获取任务点图层对象
    MarkPointLayer* markPointLayer = RenderNode::getInstance()->getMarkPointLayer();
    if(markPointLayer->isExists(num) == false) {
        QMessageBox::warning(this,
                             QObject::tr("Waring"),
                             QObject::tr("Enter Number Out of Arrage"),
                             QMessageBox::Ok, QMessageBox::Ok);
    } else {
        // 先从图层上移除mark
        osg::ref_ptr<Mark> mark = markPointLayer->getMarkPtr(num);
        if(mark != nullptr) {
            RenderNode::getInstance()->deleteMark(mark);
            markPointDb->deleteMarkPoint(markPointLayer->getId(num));
            markPointLayer->deleteMarkPoint(num);
        }
        updateMarkPointTable();
    }
    delete markPointDb;
    markPointDb = nullptr;
}

void MainWindow::deleteMarkPoint(std::string strId) {
    // 记录到数据库
    MarkPointDb* markPointDb = new MarkPointDb();
    // 获取任务点图层对象
    MarkPointLayer* markPointLayer = RenderNode::getInstance()->getMarkPointLayer();
    if(markPointLayer->isExists(strId) == false) {
        QMessageBox::warning(this,
                             QObject::tr("Waring"),
                             QObject::tr("Enter Number Out of Arrage"),
                             QMessageBox::Ok, QMessageBox::Ok);
    } else {
        for(int num = 0; num < markPointLayer->getMarkPointVec().size(); num++) {
            if(markPointLayer->getId(num) == strId) {
                // 先从图层上移除pText
                osg::ref_ptr<Mark> mark = markPointLayer->getMarkPtr(num);
                if(mark != nullptr) {
                    RenderNode::getInstance()->deleteMark(mark);
                    markPointDb->deleteMarkPoint(markPointLayer->getId(num));
                    markPointLayer->deleteMarkPoint(num);
                }
                break;
            }
        }
    }
    delete markPointDb;
    markPointDb = nullptr;
}

void MainWindow::clearMarkPoint() {
    // 确认是否清空
    int result = QMessageBox::warning(this,
                                      QObject::tr("Warning"),
                                      QObject::tr("It Will Clean All Mark Point"),
                                      QMessageBox::Ok | QMessageBox::Cancel,
                                      QMessageBox::Cancel);
    if(result == QMessageBox::Cancel) {
        return;
    }

    // 获取任务点图层对象
    MarkPointLayer* markPointLayer = RenderNode::getInstance()->getMarkPointLayer();
    if(markPointLayer->getMarkPointVec().size() == 0) {
        return;
    } else {
        // 记录到数据库
        MarkPointDb* markPointDb = new MarkPointDb();

        // 先从图层上移除pText
        int max = markPointLayer->getMarkPointVec().size();
        for(int i = 0; i < max; i++) {
            osg::ref_ptr<Mark> text = markPointLayer->getMarkPtr(i);
            if(text != nullptr) {
                RenderNode::getInstance()->deleteMark(text);
            }
        }
        // 清空图层
        markPointLayer->clearMarkPoint();
        markPointLayer->resetMarkPointCount();
        // 清空数据库
        markPointDb->clearMarkPoint();

        updateMarkPointTable();

        delete markPointDb;
        markPointDb = nullptr;
    }
}

/**
 * @brief MainWindow::jumpCoordPos
 * 双击跳转到选中任务点所在位置
 */
void MainWindow::jumpCoordPos(int i, int j) {
    // 获取markPoint图层
    MarkPointLayer* markPointLayer = RenderNode::getInstance()->getMarkPointLayer();

    OSGRender::getInstance()->setViewPoint("taskPoint",
                                           MapPoint(markPointLayer->getMarkPoint(i)->getMapPoint()._dLon,
                                                    markPointLayer->getMarkPoint(i)->getMapPoint()._dLat,
                                                    markPointLayer->getMarkPoint(i)->getMapPoint()._dAlt),
                                           0, -90.0, markPointLayer->getMarkPoint(i)->getMapPoint()._dAlt + 200);
}

/*  ------------------------------------ OSG渲染窗口初始化 ------------------------------------   */
/**
 * @brief MainWindow::initOsgRender
 * 初始化渲染窗口
 */
void MainWindow::initOsgRender() {
    // 创建渲染窗口
    OSGRender::getInstance()->initOSGRender();
    _osgRender = OSGRender::getInstance()->getQWidget();
    ui->RenderLayout->addWidget(_osgRender);
    qDebug() << "*** tiles files path: " << QCoreApplication::applicationDirPath().append("/tiles/{z}/{x}/{y}.jpg");
    // 加载瓦片数据
//    _pGlobalLayer = RenderNode::getInstance()->getOrCreateXYZServerData("E:/Data/tdt2/{z}/{x}/{y}.jpg");
    _pGlobalLayer = RenderNode::getInstance()->getOrCreateXYZServerData(QCoreApplication::applicationDirPath().toStdString() + "/tiles/{z}/{x}/{y}.jpg");
//    _pXYZLayer = RenderNode::getInstance()->getOrCreateXYZServerData("http://172.19.50.236:8086/{z}/{x}/{y}.jpg");
    OSGRender::getInstance()->setDrawState(0);
}

/*  -------------------------------------- 底部栏初始化 --------------------------------------   */
/**
 * @brief MainWindow::initButtomBar
 * 初始化底部栏
 */
void MainWindow::initButtomBar() {
    ui->CoordinateLine->setText(QObject::tr("Longitude:0.0 Latitude:0.0 Altitude:0.0"));
    connect(OSGRender::getInstance(), SIGNAL(updatePickMapPoint()), this, SLOT(updatePickCoord()));
    connect(OSGRender::getInstance(), SIGNAL(updatePickMapPoint(double, double, double)), this, SLOT(updatePickCoord(double, double, double)));
}

/**
 * @brief MainWindow::updatePickCoord
 * 更新底部坐标框信息
 */
void MainWindow::updatePickCoord() {
    osg::Vec3d vecCoord = RenderNode::getInstance()->getCoord();
    std::stringstream streamX, streamY, streamZ;
    streamX << std::fixed << std::setprecision(7) << vecCoord.x();
    streamY << std::fixed << std::setprecision(7) << vecCoord.y();
    streamZ << std::fixed << std::setprecision(2) << vecCoord.z();

    std::string stdCoord = (QObject::tr("Longitude:").toStdString() + streamX.str() + " " +
                            QObject::tr("Latitude:").toStdString() + streamY.str() + " " +
                            QObject::tr("Altitude:").toStdString() + streamZ.str());
    ui->CoordinateLine->setText(QObject::tr(stdCoord.c_str()));
}
void MainWindow::updatePickCoord(double lon, double lat, double alt) {
    std::stringstream streamX, streamY, streamZ;
    streamX << std::fixed << std::setprecision(7) << lon;
    streamY << std::fixed << std::setprecision(7) << lat;
    streamZ << std::fixed << std::setprecision(2) << alt;

    std::string stdCoord = (QObject::tr("Longitude:").toStdString() + streamX.str() + " " +
                            QObject::tr("Latitude:").toStdString() + streamY.str() + " " +
                            QObject::tr("Altitude:").toStdString() + streamZ.str());
    ui->CoordinateLine->setText(QObject::tr(stdCoord.c_str()));
}

/*  -------------------------------------- 数据库初始化 --------------------------------------   */
void MainWindow::initDatabase() {
    // 判断数据库是否存在
    DbManager* dbManager = new DbManager();
    if(dbManager->isDbExists(QCoreApplication::applicationDirPath() + "\\dmatch.db") == false) {
        // 创建数据库
        QSqlDatabase* database = dbManager->createDatabase(QCoreApplication::applicationDirPath() + "\\dmatch.db");
        database->open();

        // 在数据库中创建table
        if(dbManager->createTables(database) == false) {
            QMessageBox::warning(this,
                                 QObject::tr("Warning"),
                                 QObject::tr("Create Table Failed"),
                                 QMessageBox::Ok,
                                 QMessageBox::Ok);
        }
    }

    // 加载默认Tif数据
    loadDefaultImage();

    // 读取tifMangeFile
    readImageManageFile();

    // 读取任务点
    readMarkPoint();

    // 读取cache
    readCache();
}

/*  -------------------------------------- 窗口关闭事件 --------------------------------------   */
/**
 * @brief MainWindow::closeEvent
 * 初始化相关事件
 * @param QCloseEvent* event 关闭事件指针
 */
void MainWindow::closeEvent(QCloseEvent* event) {
    int result  = QMessageBox::warning(this,
                                       QObject::tr("Waring"),
                                       QObject::tr("Really Want To Exit?\nAnything not Saved Will be Cleaned."),
                                       QMessageBox::Ok | QMessageBox::Cancel,
                                      QMessageBox::Cancel);
    if(result == QMessageBox::Ok) {
        writeCache();
        cleanTemImage();
        cleanTemMarkPoint();
        event->accept();
    } else {
        event->ignore();
    }
}

/**
 * @brief MainWindow::cleanTemTif
 * 清理不需要保存的tif文件
 */
void MainWindow::cleanTemImage() {
    // 读取影像数据库
    ImageInfoDb* imageDb = new ImageInfoDb();

    // 获取该文件夹下的所有文件名称
    QDir dir(QCoreApplication::applicationDirPath() + "\\tifMaxRect");
    QStringList fileList;
    // 遍历目录中的所有文件
    foreach(QString fileName, dir.entryList(QDir::Files)) {
        // 获取文件的基本名称（不包含路径和扩展名）
        QString baseName = QFileInfo(dir.filePath(fileName)).baseName();
        fileList.append(baseName);
    }
    // 获取数据库保存的所有影像名称
    QStringList saveList;
    for(int i = 0; i < imageDb->getAllImage().size(); i++) {
        saveList.append(imageDb->getImageByIndex(i)->getImageName().c_str());
    }

    // 如果没有保存图片，直接清空文件夹
    if(saveList.empty() == true) {
        for(int i = 0; i < fileList.size(); i++) {
            QFile file(QCoreApplication::applicationDirPath() + "\\tifMaxRect\\" + fileList.at(i) + ".tif");
            file.remove();
        }
    } else {
        // 循环判断名称是否在保存影像的列表中
        for(int i = 0; i < fileList.size(); i++) {
            // 如果不存在则删除文件
            if(saveList.contains(fileList.at(i)) == false) {
                QFile file(QCoreApplication::applicationDirPath() + "\\tifMaxRect\\" + fileList.at(i) + ".tif");
                file.remove();
            }
        }
    }
}

void MainWindow::cleanTemMarkPoint() {
    // 获取任务点图层
    MarkPointLayer* markPointLayer = RenderNode::getInstance()->getMarkPointLayer();
    // 读取数据库
    MarkPointDb* markPointDb = new MarkPointDb();
    markPointLayer->clearMarkPoint();
    markPointDb->clearMarkPoint();
}

/**
 * @brief MainWindow::writeCache
 * 写入cache
 */
void MainWindow::writeCache() {
    // 读取数据库
    PositionDb* positionDb = new PositionDb();
    if(positionDb->open(QCoreApplication::applicationDirPath() + "\\dmatch.db") == true) {
        // 从数据库中写入坐标信息
        positionDb->clearPosition();
        positionDb->savePosition(_lastMapPoint);
    } else {
        QMessageBox::warning(this,
                             QObject::tr("Waring"),
                             QObject::tr("Cannot Connect Database"),
                             QMessageBox::Ok, QMessageBox::Ok);
        return;
    }
    delete positionDb;
    positionDb = nullptr;
}