mainwindow.cpp

#include "mainwindow.h"


#include "ui_mainwindow.h"

#include <QDebug>
#include <QScreen>
#include <QCloseEvent>
#include <QtConcurrent>
#include <QMessageBox>
#include <QPainter>

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


    CreateWindow = new Dialog;
    SettingWindow = new WindowSettings;

    //Заполянем дерево
    GetDiskInfo();
    populateTree();
    connect(ui->treeWidget, &QTreeWidget::itemChanged, this, &MainWindow::onItemChanged);

    connect(this,&MainWindow::signal_CreateWindowSettings,SettingWindow,&WindowSettings::slot_CreateWindowSettings);
    connect(SettingWindow,&WindowSettings::signal_EnableThread,this,&MainWindow::slot_EnableThread);
    connect(this,&MainWindow::signal_CreateWindowDialog,CreateWindow,&Dialog::slot_CreateWindow);
    connect(CreateWindow,&Dialog::signal_RUN_CREATE,this,&MainWindow::SLOT_RUN_CREATE);

     //tray();
}

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


//Заполняет QMap для класса MainWindow
void MainWindow::GetDiskInfo(){
    DiskInfo disks;
    int numOfPhysicalDisks = disks.GetNumOfPhysicalDisk();
    qDebug()<<"Ошибки: логический диск с индексом не найден это нормально их количесвто должно совпадать с количеством физ. дисков";

    for (int physicalDiskId = 0; physicalDiskId < numOfPhysicalDisks; ++physicalDiskId) {
        // Получаем информацию о диске
        QVector<DiskInfoStruct> list_disk;
        DiskInfoStruct diskStruct;  // Структура для хранения информации о диске

        if (disks.GetDiskInfo(physicalDiskId, 0, &diskStruct)) {
            list_disk.append(diskStruct);
            // Вставляем в QMap, где ключ - это имя диска (используем diskStruct.diskName)
            QString diskName = QString::fromStdWString(diskStruct.diskName);

            int logicalDiskId = 1;  // Индекс логического диска

            // Пока GetDiskInfo() возвращает true (пока есть логические диски или разделы)
            while (disks.GetDiskInfo(physicalDiskId, logicalDiskId, &diskStruct)) {
                list_disk.append(diskStruct);

                // Увеличиваем индекс логического диска для следующего
                ++logicalDiskId;
            } // Используем имя последнего диска
            conected_drivers.insert(diskName, list_disk);
        }
    }
}

//Функция для стилей чтобы не было громостко в конструкторе
void MainWindow::setStyleSheet_construct()
{
    //setWindowFlags(Qt::FramelessWindowHint);//убрал рамку

    ui->Progress->setVisible(false); //скрываем прогрессбар
    ui->tableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);//таблица атоматически растягивается
}

//Функция добовления в QTreeWidget Дисков и их разделов
void MainWindow::populateTree() {
    for (auto it = conected_drivers.begin(); it != conected_drivers.end(); ++it) {
        QString diskName = it.key();
        QVector<DiskInfoStruct> partitions = it.value();

        if (!partitions.isEmpty()) {
            DiskInfoStruct diskStruct = partitions[0]; // Физический диск
            QTreeWidgetItem* diskItem = new QTreeWidgetItem(ui->treeWidget);

            diskItem->setText(0, diskName);
            diskItem->setText(1, QString::number(diskStruct.totalSize));
            diskItem->setFlags(diskItem->flags() | Qt::ItemIsUserCheckable);
            diskItem->setCheckState(0, Qt::Unchecked);

            // Сохраняем данные физического диска в элемент
            diskItem->setData(0, Qt::UserRole, 0); // 0 — индекс физического диска

            bool first = true;
            bool first_Mount = false;
            for (int i = 0; i < partitions.size(); ++i) {
                const DiskInfoStruct& partition = partitions[i];
                if (first) {
                    first = false;
                    continue;
                }

                QTreeWidgetItem* partitionItem = new QTreeWidgetItem(diskItem);
                partitionItem->setText(0, QString::fromStdWString(partition.diskName));
                partitionItem->setText(1, QString::number(partition.totalSize));
                partitionItem->setIcon(2, QIcon(partition.isMount ? ":/rec/img/dikMount.png" : ":/rec/img/dikUnMount.png"));
                partitionItem->setFlags(partitionItem->flags() | Qt::ItemIsUserCheckable);
                partitionItem->setCheckState(0, Qt::Unchecked);

                if (partition.isMount) {
                    first_Mount = true;
                    for (int col = 0; col < partitionItem->columnCount(); ++col) {
                        partitionItem->setBackground(col, QBrush(QColor(186,219,173,30)));
                    }
                }

                // Сохраняем индекс раздела в Data
                partitionItem->setData(0, Qt::UserRole, i);
            }

            if (first_Mount) {
                diskItem->setIcon(2, QIcon(":/rec/img/dikMount.png"));
                for (int col = 0; col < diskItem->columnCount(); ++col) {
                    diskItem->setBackground(col, QBrush(QColor(186,219,173,30)));
                }
            } else {
                diskItem->setIcon(2, QIcon(":/rec/img/dikUnMount.png"));
            }
        }
    }
}



//Функция выбора диска
void MainWindow::onItemChanged(QTreeWidgetItem* item, int column) {
    static bool updating = false; // Защита от повторного вызова
    if (updating) {
        return;
    }
    updating = true; // Включаем блокировку

    if (column == 0) {
        if (item->checkState(0) == Qt::Checked) {
            qDebug() << "Item checked:" << item->text(0);

            // Если выбран новый элемент, сбрасываем чекбокс у старого
            if (selectedItem && selectedItem != item) {
                selectedItem->setCheckState(0, Qt::Unchecked);
            }

            // Сохраняем ссылку на текущий выбранный элемент
            selectedItem = item;

        } else if (item->checkState(0) == Qt::Unchecked) {
            qDebug() << "Item unchecked:" << item->text(0);
            // Если галочка снята и не выбран новый элемент, обнуляем ссылку
            if (selectedItem == item) {
                selectedItem = nullptr;
            }
        }
    }

    updating = false; // Снимаем блокировку
}


//Тригер для Update_disks - обновление о подключенных дисках
void MainWindow::on_Update_disks_triggered()
{
    ui->statusbar->showMessage("Обновление",300);

    targetDisk = nullptr;

    //Отчистка QTree
    ui->treeWidget->blockSignals(true);
    selectedItem = nullptr;
    ui->treeWidget->clear();

    //Отчистка QTable
    ui->tableWidget->clearContents();
    ui->tableWidget->setRowCount(0);

    // Очищаем старые данные
    conected_drivers.clear();
    GetDiskInfo();
    populateTree();

    ui->treeWidget->blockSignals(false);
}

//Функция если мы выбираем диск то инфа о нем появится в списке
void MainWindow::on_treeWidget_itemSelectionChanged() {
    // Получаем текущий выбранный элемент дерева
    QTreeWidgetItem* selectedItem = ui->treeWidget->currentItem();

    // Проверяем, если элемент выбран
    if (!selectedItem) return;

    // Получаем родительский элемент (если есть)
    QTreeWidgetItem* parentItem = selectedItem->parent();

    // Очистим таблицу перед выводом новых данных
    ui->tableWidget->clearContents();
    ui->tableWidget->setRowCount(0);  // Сбрасываем количество строк

    // Если родительский элемент есть, то это раздел, иначе это физический диск
    if (parentItem) {
        // Это элемент раздела, ищем родительский элемент (физический диск)
        QString diskName = parentItem->text(0);  // Имя физического диска
        if (conected_drivers.contains(diskName)) {
            QVector<DiskInfoStruct> partitions = conected_drivers[diskName];

            // Получаем информацию о выбранном разделе
            QString partitionName = selectedItem->text(0);  // Имя раздела

            for (const DiskInfoStruct& partition : partitions) {
                if (QString::fromStdWString(partition.diskName) == partitionName) {
                    // Выводим информацию о выбранном разделе
                    int row = 0;

                    // Добавляем свойства раздела в таблицу
                    ui->tableWidget->insertRow(row);
                    ui->tableWidget->setItem(row, 0, new QTableWidgetItem("Имя Раздела"));
                    ui->tableWidget->setItem(row, 1, new QTableWidgetItem(QString::fromStdWString(partition.diskName)));

                    row++;
                    ui->tableWidget->insertRow(row);
                    ui->tableWidget->setItem(row, 0, new QTableWidgetItem("Тип диска"));
                    ui->tableWidget->setItem(row, 1, new QTableWidgetItem(partition.type == DiskType::Physical ? "Физический" : "Логический"));

                    row++;
                    ui->tableWidget->insertRow(row);
                    ui->tableWidget->setItem(row, 0, new QTableWidgetItem("Серийный номер"));
                    ui->tableWidget->setItem(row, 1, new QTableWidgetItem(QString::fromStdWString(partition.serial_id)));

                    row++;
                    ui->tableWidget->insertRow(row);
                    ui->tableWidget->setItem(row, 0, new QTableWidgetItem("Файловая система"));
                    ui->tableWidget->setItem(row, 1, new QTableWidgetItem(QString::fromStdWString(partition.fileSystemType)));

                    row++;
                    ui->tableWidget->insertRow(row);
                    ui->tableWidget->setItem(row, 0, new QTableWidgetItem("Общий размер (ГБ)"));
                    ui->tableWidget->setItem(row, 1, new QTableWidgetItem(QString::number(partition.totalSize)));

                    row++;
                    ui->tableWidget->insertRow(row);
                    ui->tableWidget->setItem(row, 0, new QTableWidgetItem("Свободное место (ГБ)"));
                    ui->tableWidget->setItem(row, 1, new QTableWidgetItem(QString::number(partition.freeSpace)));

                    row++;
                    ui->tableWidget->insertRow(row);
                    ui->tableWidget->setItem(row, 0, new QTableWidgetItem("Количество секторов"));
                    ui->tableWidget->setItem(row, 1, new QTableWidgetItem(QString::number(partition.total_sectors)));

                    row++;
                    ui->tableWidget->insertRow(row);
                    ui->tableWidget->setItem(row, 0, new QTableWidgetItem("Количество байт"));
                    ui->tableWidget->setItem(row, 1, new QTableWidgetItem(QString::number(partition.total_bytes)));
                }
            }
        }
    } else {
        // Это физический диск, отображаем информацию о нем
        QString diskName = selectedItem->text(0);  // Имя физического диска
        if (conected_drivers.contains(diskName)) {
            QVector<DiskInfoStruct> partitions = conected_drivers[diskName];

            // Получаем информацию о физическом диске (первый элемент в списке)
            const DiskInfoStruct& physicalDisk = partitions[0];
            int row = 0;

            // Добавляем свойства физического диска в таблицу
            ui->tableWidget->insertRow(row);
            ui->tableWidget->setItem(row, 0, new QTableWidgetItem("Имя диска"));
            ui->tableWidget->setItem(row, 1, new QTableWidgetItem(QString::fromStdWString(physicalDisk.diskName)));

            row++;
            ui->tableWidget->insertRow(row);
            ui->tableWidget->setItem(row, 0, new QTableWidgetItem("Тип диска"));
            ui->tableWidget->setItem(row, 1, new QTableWidgetItem(physicalDisk.type == DiskType::Physical ? "Физический" : "Логический"));

            row++;
            ui->tableWidget->insertRow(row);
            ui->tableWidget->setItem(row, 0, new QTableWidgetItem("Серийный номер"));
            ui->tableWidget->setItem(row, 1, new QTableWidgetItem(QString::fromStdWString(physicalDisk.serial_id)));

            row++;
            ui->tableWidget->insertRow(row);
            ui->tableWidget->setItem(row, 0, new QTableWidgetItem("Общий размер (ГБ)"));
            ui->tableWidget->setItem(row, 1, new QTableWidgetItem(QString::number(physicalDisk.totalSize)));

            row++;
            ui->tableWidget->insertRow(row);
            ui->tableWidget->setItem(row, 0, new QTableWidgetItem("Свободное место (ГБ)"));
            ui->tableWidget->setItem(row, 1, new QTableWidgetItem(QString::number(physicalDisk.freeSpace)));

            row++;
            ui->tableWidget->insertRow(row);
            ui->tableWidget->setItem(row, 0, new QTableWidgetItem("Количество секторов"));
            ui->tableWidget->setItem(row, 1, new QTableWidgetItem(QString::number(physicalDisk.total_sectors)));

            row++;
            ui->tableWidget->insertRow(row);
            ui->tableWidget->setItem(row, 0, new QTableWidgetItem("Количество байт"));
            ui->tableWidget->setItem(row, 1, new QTableWidgetItem(QString::number(physicalDisk.total_bytes)));

        }
    }
}

//Нажатие кнопки создать образ
void MainWindow::on_CreateButton_clicked()
{
    if (selectedItem != nullptr && selectedItem->checkState(0) == Qt::Checked) {
        // Если элемент выбран и галочка установлена
        QVariant data = selectedItem->data(0, Qt::UserRole);
        if (data.isValid()) {
            int index = data.toInt();
            QString diskName = selectedItem->parent() ? selectedItem->parent()->text(0) : selectedItem->text(0);

            // Находим соответствующий диск в QMap
            auto it = conected_drivers.find(diskName);
            if (it != conected_drivers.end() && index >= 0 && index < it.value().size()) {
                targetDisk = &(it.value()[index]);
                qDebug() << "Target disk set to:" << QString::fromStdWString(targetDisk->diskName);

                // Открываем диалоговое окно
                CreateWindow->setModal(true);
                emit signal_CreateWindowDialog();
            }
        }
    } else {
        ui->statusbar->showMessage("Выберите диск!", 800); // Сообщение, если диск не выбран
    }
}

//пункт настройки
void MainWindow::on_Settings_triggered()
{
    SettingWindow->setModal(true);
    emit signal_CreateWindowSettings(enableThread);
}

//нажатие кнопки паузы/воозобновления
void MainWindow::on_PCButton_clicked()
{
    // ui->PCButton->setIconSize(QSize( 12,12));
    // ui->PCButton->setIcon(QIcon(":/rec/img/continue.png"));
}


//тригер на кнопку на кнопку создать образ в диалоговом окне
void MainWindow::SLOT_RUN_CREATE(const QString &typeImage, const QString &dir, const QString &nameF, const long bs)
{
    //нужна проверка на доступное место на диске

    qDebug()<<"Thread: "<<enableThread;
    ui->CreateButton->setVisible(false);
    ui->Progress->setVisible(true);
    ui->progressBar->setValue(0);

    // Сохраняем QFuture
    QFuture<void> future = QtConcurrent::run([this, typeImage, dir, nameF, bs]() {
        bool res = false;

        if (typeImage == "dd") {
            qDebug() << "Run copy/create dd";

            QRawCopy* RC = new QRawCopy ((targetDisk->diskName).data(),
                               (targetDisk->serial_id).data(),
#ifdef _WIN32
                               QString(dir + "\\" + nameF + ".dd").toStdWString(),
#elif defined(__linux__)
                               QString(dir + "/" + nameF + ".dd").toStdWString(),
#endif
                               bs,
                               targetDisk->total_sectors);

            RC->moveToThread(QThread::currentThread()); //возможно надо убрать
            connect(RC,&QRawCopy::SpeedProgressBar,this,&MainWindow::SpeedProgressBar,Qt::QueuedConnection);
            res = enableThread ? RC->CreateRawCopyThreads(0) : RC->CreateRawCopy(0);
            delete RC;

        } else if (typeImage == "sparce") {
            qDebug() << "Run copy/create sparse";

            QSparseVMDK* SV = new QSparseVMDK(dir.toStdWString(),
                                  nameF.toStdWString(),
                                  (targetDisk->diskName).data(),
                                  (targetDisk->serial_id).data(),
                                  65536,
                                  targetDisk->total_sectors);

            SV->moveToThread(QThread::currentThread());
            connect(SV,&QSparseVMDK::SpeedProgressBar,this,&MainWindow::SpeedProgressBar,Qt::QueuedConnection);
            res = enableThread ? SV->CreateSparseThread(): SV->CreateSparse();
            delete SV;

        } else if (typeImage == "flat") {
            qDebug() << "Run copy/create flat";

            QFlatVMDK* FV = new QFlatVMDK(dir.toStdWString(),
                                nameF.toStdWString(),
                                (targetDisk->diskName).data(),
                                (targetDisk->serial_id).data());

            FV->moveToThread(QThread::currentThread());
            connect(FV,&QFlatVMDK::SpeedProgressBar,this,&MainWindow::SpeedProgressBar,Qt::QueuedConnection);
            res = enableThread ?FV->CreateVMDKThread(bs, targetDisk->total_sectors) : FV->CreateVMDK(bs, targetDisk->total_sectors);
            delete FV;

        } else {
            qDebug() << "Error choose typeImage in SLOT_RUN_CREATE";
        }

        qDebug() << "Result of operation:" << res;

        //Это передача данных через invokeMethod лямда функцией в основной поток так как мы не можнм обновить интерфейс в фоновом потоке
        QMetaObject::invokeMethod(this, [this, typeImage, res]() {

            ui->progressBar->setValue(100);
            res ?
                QMessageBox::information(this,"Успех","Образ " +QString(typeImage) + " " + QString::fromStdWString(targetDisk->diskName) + " успешно создан"):
                QMessageBox::critical(this,"Ошибка","Образ " + QString(typeImage) + " " + QString::fromStdWString(targetDisk->diskName) + " небыл создан");

            ui->CreateButton->setVisible(true);
            ui->PCButton->setIcon(QIcon(":/rec/img/chek.png"));
            ui->DeleteButton->setVisible(false);
            on_Update_disks_triggered();
        });
    });

}

void MainWindow::SpeedProgressBar(int progress){
    ui->progressBar->setValue(progress);
    qDebug()<<progress;
}