include MainWidget include ui_MainWidget MainWidget MainWidget QWidget

#include "MainWidget.h"
#include "ui_MainWidget.h"

MainWidget::MainWidget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::MainWidget)
{
    ui->setupUi(this);
    this->requestIndex = 0;
    this->titleForAddSnippet = "Создание сниппета";
    this->initUi();
    this->updateGroups();
}

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


void MainWidget::initUi() {
    this->ui->tableGroup->verticalHeader()->setVisible(false);
    this->ui->tableSnippet->verticalHeader()->setVisible(false);

    this->ui->tableGroup->setEditTriggers(QAbstractItemView::NoEditTriggers);
    this->ui->tableSnippet->setEditTriggers(QAbstractItemView::NoEditTriggers);

    QSettings *settings = assistant::getSettings();
    ui->pushGroupAdd->setIcon(assistant::getIcon("add"));
    ui->pushGroupAdd->setText("");

    ui->pushGroupEdit->setIcon(assistant::getIcon("edit"));
    ui->pushGroupEdit->setText("");

    ui->pushGroupDelete->setIcon(assistant::getIcon("delete"));
    ui->pushGroupDelete->setText("");

    ui->pushSnippetAdd->setIcon(assistant::getIcon("add"));
    ui->pushSnippetAdd->setText("");

    ui->pushSnippetEdit->setIcon(assistant::getIcon("edit"));
    ui->pushSnippetEdit->setText("");

    ui->pushSnippetDelete->setIcon(assistant::getIcon("delete"));
    ui->pushSnippetDelete->setText("");

    if(settings->getWindowWidth() > 0 && settings->getWindowHeight() > 0) {
        this->setGeometry(settings->getWindowX() , settings->getWindowY() , settings->getWindowWidth() , settings->getWindowHeight());
    }

    if(settings->getWidthGroup() > 0 && settings->getWidthSnippet() > 0) {
        QList<int> listSize;
        listSize.append(settings->getWidthGroup());
        listSize.append(settings->getWidthSnippet());
        listSize.append(settings->getWidthText());
        ui->splitter->setSizes(listSize);
    }

    connect(ui->splitter, &QSplitter::splitterMoved , this, &MainWidget::splitterMoved);

    QMenu *menu = new QMenu(this);
    menu->addAction("Авторизация");
    connect(menu->actions().last(), &QAction::triggered , this, &MainWidget::onAuthorization);

    ui->pushMenu->setMenu(menu);

    QList<QSnippetItem::QSnippetItemSyntax> listSyntax = assistant::getListSyntax();
    this->ui->comboSyntax->addItem("", 0);
    this->_mapIndexSyntax.clear();
    for(int i = 0 ; i < listSyntax.count(); i++) {
        QSnippetItem::QSnippetItemSyntax syntax = listSyntax.at(i);
        this->ui->comboSyntax->addItem(assistant::getSyntaxName(syntax), (int)syntax);
        this->_mapIndexSyntax[syntax] = i + 1;
    }
    this->ui->labelStatusBar->setText("");


    this->timerProgressBag = new QTimer(this);
    connect(this->timerProgressBag, &QTimer::timeout, this, &MainWidget::updateProgress);
    this->timerProgressBag->start(30);


    connect(this->ui->pushGroupAdd, &QPushButton::clicked , this, &MainWidget::onAddGroup);
    connect(this->ui->pushGroupEdit, &QPushButton::clicked , this, &MainWidget::onEditGroup);
    connect(this->ui->pushGroupDelete, &QPushButton::clicked , this, &MainWidget::onDeleteGroup);

    connect(this->ui->pushSnippetAdd, &QPushButton::clicked , this, &MainWidget::onAddSnippet);
    connect(this->ui->pushSnippetEdit, &QPushButton::clicked , this, &MainWidget::onEditSnippet);
    connect(this->ui->pushSnippetDelete, &QPushButton::clicked , this, &MainWidget::onDeleteSnippet);

    QAction *actionEdit = new QAction(this);
    actionEdit->setShortcut(QKeySequence("F2"));
    connect(actionEdit, &QAction::triggered , this, &MainWidget::onTriggeredEdit);


    this->addAction(actionEdit);
}

/** Заблокировать окно */
void MainWidget::setRequest(bool isRequest) {
    this->requestIndex += (isRequest ? 1 : -1);
    if(this->requestIndex > 0) {
        this->ui->splitter->setDisabled(true);
    } else {
        this->ui->splitter->setDisabled(false);
    }
    if(this->requestIndex < 0) {
        this->requestIndex = 0;
    }
}

/** Вызывается при необходимости авторизоваться */
void MainWidget::onAuthorization() {
    FormAuthorization *form = new FormAuthorization();
    form->show();
}

void MainWidget::splitterMoved(int pos, int index) {
    QList<int> listSize = ui->splitter->sizes();
    if(listSize.count() != 3) {
        return;
    }
    QSettings *settings = assistant::getSettings();
    settings->setWidthGroup(listSize.at(0));
    settings->setWidthSnippet(listSize.at(1));
    settings->setWidthText(listSize.at(2));
    assistant::savetSettings(settings);
}

/** Вызывается при изменении размера окна */
void MainWidget::resizeEvent(QResizeEvent *event) {
    if(event->oldSize().isEmpty()) {
        return;
    }

    QSettings *settings = assistant::getSettings();
    settings->setWindowWidth(event->size().width());
    settings->setWindowHeight(event->size().height());
    assistant::savetSettings(settings);
}

/** Вызывается при изменении позиции окна */
void MainWidget::moveEvent ( QMoveEvent * event ) {
    if(event->oldPos().isNull()) {
        return;
    }

    QSettings *settings = assistant::getSettings();
    settings->setWindowX(event->pos().x());
    settings->setWindowY(event->pos().y());
    assistant::savetSettings(settings);
}

/** Отображение прогресса выполнения запроса */
void MainWidget::updateProgress() {
    int value = this->ui->progressBar->value();
    int valueNext = value + 3;
    if(this->requestIndex > 0) {
        this->ui->progressBar->setValue(valueNext);
        if(valueNext >= this->ui->progressBar->maximum()) {
            this->ui->progressBar->reset();
        }
    } else {
        if(value > 0) {
            this->ui->progressBar->reset();
        }
    }

}

/** Добавить список групп в таблице */
void MainWidget::addGroups(QList<QSnippetResponseResourceItem*> listGroup) {
    QStandardItemModel *model = static_cast<QStandardItemModel *>(this->ui->tableGroup->model());
    if(!model) {
        model = new QStandardItemModel(0, 1);
        this->ui->tableGroup->setModel(model);

        QItemSelectionModel *selectionModel = this->ui->tableGroup->selectionModel();
        connect(selectionModel, &QItemSelectionModel::selectionChanged, this, &MainWidget::onChangeSelectedGroup);
        model->setHorizontalHeaderLabels(QStringList() << "Группы");
    }
    QList<QString> listGroupId;
    for(int r = 0 ; r < model->rowCount() ; r ++) {
        QStandardItem *item = model->item(r);
        if(item) {
            listGroupId.append(item->data(Qt::UserRole).toString());
        }
    }

    for( int i = 0 ; i < listGroup.count() ; i++) {
        QSnippetResponseResourceItem *item = listGroup.at(i);
        if(!(item->getIsDir()))
            continue;
        if(listGroupId.contains(item->resource_id))
            continue;

        QStandardItem *groupItem = new QStandardItem();
        groupItem->setData(item->name, Qt::DisplayRole);
        groupItem->setData(item->resource_id, Qt::UserRole);
        model->appendRow(QList<QStandardItem*>() << groupItem);
    }
}

/** Добавить список сниппетов в таблице */
void MainWidget::addSnippets(QList<QSnippetResponseResourceItem*> listSnippet) {
    QStandardItemModel *model = static_cast<QStandardItemModel *>(this->ui->tableSnippet->model());
    if(!model) {
        model = new QStandardItemModel(0, 1);
        this->ui->tableSnippet->setModel(model);

        QItemSelectionModel *selectionModel = this->ui->tableSnippet->selectionModel();
        connect(selectionModel, &QItemSelectionModel::selectionChanged, this, &MainWidget::onChangeSelectedSnippet);
        model->setHorizontalHeaderLabels(QStringList() << "Сниппеты");
    }

    for(int i = 0; i < listSnippet.count(); i ++) {
        QSnippetResponseResourceItem *item = listSnippet.at(i);
        QStandardItem *snippetItem = new QStandardItem();
        snippetItem->setData(item->getFileName(), Qt::DisplayRole);
        snippetItem->setData(item->resource_id, Qt::UserRole);
        model->appendRow(QList<QStandardItem*>() << snippetItem);
    }
}

/** Отобразить список групп в таблице */
void MainWidget::updateGroups() {
    this->addGroups(QList<QSnippetResponseResourceItem*>());
    QStandardItemModel *model = static_cast<QStandardItemModel *>(this->ui->tableGroup->model());
    model->clear();
    model->setHorizontalHeaderLabels(QStringList() << "Группы");
    this->setRequest(true);

    QSettings *settings = assistant::getSettings();
    assistant::createTask()
            ->resource()
            ->setPath(settings->getPath())
            ->setResponse([=](QSnippetResponseResource *resource){
                if(resource->resource) {
                    assistant::saveGroupCache(resource->resource->_embedded->items);
                    this->addGroups(resource->resource->_embedded->items);
                    this->setRequest(false);
                }
            })
            ->run();
}

/** Вызывается при изменении выбранной группы */
void MainWidget::onChangeSelectedGroup(const QItemSelection &selected, const QItemSelection &deselected) {
    QModelIndexList listIndexGroup = selected.indexes();
    QString resource_id = listIndexGroup.isEmpty() ? "" :listIndexGroup.first().data(Qt::UserRole).toString();
    this->showSnippetsGroup(resource_id);
}

/** Отобразить сниппеты из группы */
void MainWidget::showSnippetsGroup(QString resource_id) {
    this->ui->textSnippet->setText("");
    this->ui->textSnippet->document()
    this->ui->comboSyntax->setCurrentIndex(0);
    QList<QSnippetResponseResourceItem*> listSnippet;
    if(assistant::existsSnippetsInGroup(resource_id)) {
        listSnippet = assistant::getSnippetsInGroup(resource_id);
        this->showSnippetsGroup(listSnippet);
        return;
    }

    QSnippetResponseResourceItem *group = assistant::getGroup(resource_id);
    if(!group) {
        this->showSnippetsGroup(listSnippet);
        return;
    }

    this->group_resource_id = resource_id;

    this->setRequest(true);
    assistant::createTask()
            ->resource()
            ->setPath(group->path)
            ->setResponse([=](QSnippetResponseResource *resource){
                if(resource->resource) {
                    assistant::saveSnippetsInGroup(this->group_resource_id, resource->resource->_embedded->items);
                    QList<QSnippetResponseResourceItem*> listSnippet = assistant::getSnippetsInGroup(this->group_resource_id);
                    this->showSnippetsGroup(listSnippet);
                    this->setRequest(false);
                    this->ui->tableGroup->setFocus();
                }
            })
            ->run();
}

/** Отобразить сниппеты из группы */
void MainWidget::showSnippetsGroup(QList<QSnippetResponseResourceItem*> listSnippet) {
    QStandardItemModel *model = static_cast<QStandardItemModel *>(this->ui->tableSnippet->model());
    if(!model) {
        model = new QStandardItemModel(0, 1);
        this->ui->tableSnippet->setModel(model);

        QItemSelectionModel *selectionModel = this->ui->tableSnippet->selectionModel();
        connect(selectionModel, &QItemSelectionModel::selectionChanged, this, &MainWidget::onChangeSelectedSnippet);
    }

    model->clear();

    for(int i = 0; i < listSnippet.count(); i ++) {
        QSnippetResponseResourceItem *item = listSnippet.at(i);
        QStandardItem *snippetItem = new QStandardItem();
        snippetItem->setData(item->getFileName(), Qt::DisplayRole);
        snippetItem->setData(item->resource_id, Qt::UserRole);
        model->appendRow(QList<QStandardItem*>() << snippetItem);
    }

    model->setHorizontalHeaderLabels(QStringList() << "Сниппеты");
}

/** Вызывается при изменении выбранной сниппета */
void MainWidget::onChangeSelectedSnippet(const QItemSelection &selected, const QItemSelection &deselected) {
    QModelIndexList listIndexSnippet = selected.indexes();
    if(listIndexSnippet.isEmpty()) {
        this->ui->textSnippet->setText("");
        return;
    }
    QString resource_id = listIndexSnippet.first().data(Qt::UserRole).toString();
    QSnippetResponseResourceItem *snippet = assistant::getSnippet(resource_id);
    if(!snippet) {
        this->ui->textSnippet->setText("");
        return;
    }

    QString expansion = snippet->getExpansion();
    QSnippetItem::QSnippetItemSyntax syntax = assistant::getSyntaxExpansion(expansion);
    this->ui->comboSyntax->setCurrentIndex(this->_mapIndexSyntax[syntax]);

    if(snippet->getIsSetContent()){
        this->ui->textSnippet->setText(snippet->getContent());
        return;
    }

    this->snippet_resource_id = snippet->resource_id;
    this->setRequest(true);
    assistant::createTask()
            ->download()
            ->setPath(snippet->path)
            ->setResponse([=](QSnippetResponseDownload *resource){
                if(resource->error) {
                   qDebug() << resource->error->error_description ;
                }
                if(!(resource->error)) {
                    QSnippetResponseResourceItem *snippet = assistant::getSnippet(resource_id);
                    if(snippet) {
                        snippet->setContent(resource->resource->buffer);
                    }
                    this->ui->textSnippet->setText(snippet->getContent());
                    this->setRequest(false);
                    this->ui->tableSnippet->setFocus();
                }
            })
            ->run();

}

/** Вернуть выбранную группу */
QSnippetResponseResourceItem *MainWidget::getSelectedGroup() {
    QStandardItem *item = MainWidget::getSelectedItemGroup() ;
    if(!item)
        return nullptr;

    QString resource_id = item->data(Qt::UserRole).toString();
    return assistant::getGroup(resource_id);
}

/** Вернуть выбранную группу */
QStandardItem *MainWidget::getSelectedItemGroup() {
    QItemSelectionModel *selectionModel = this->ui->tableGroup->selectionModel();
    QStandardItemModel *model = static_cast<QStandardItemModel *>(this->ui->tableGroup->model());
    if(!selectionModel || !selectionModel)
        return nullptr;

    QModelIndexList listIndex = selectionModel->selectedIndexes();
    if(listIndex.empty())
        return nullptr;

    QModelIndex index = listIndex.first();
    return model->item(index.row(), index.column());
}

/** Вернуть выбраый сниппет */
QStandardItem *MainWidget::getSelectedItemSnippet() {
    QItemSelectionModel *selectionModel = this->ui->tableSnippet->selectionModel();
    QStandardItemModel *model = static_cast<QStandardItemModel *>(this->ui->tableSnippet->model());
    if(!selectionModel || !selectionModel)
        return nullptr;

    QModelIndexList listIndex = selectionModel->selectedIndexes();
    if(listIndex.empty())
        return nullptr;

    QModelIndex index = listIndex.first();
    return model->item(index.row(), index.column());
}

/** Вернуть элемент сниппета по идентификтаору ресурса */
QStandardItem *MainWidget::getItemSnippet(QString resource_id) {
    QStandardItemModel *model = static_cast<QStandardItemModel *>(this->ui->tableSnippet->model());
    if(!model) {
        return nullptr;
    }
    for(int i = 0 ; i < model->rowCount(); i++){
        QStandardItem *item = model->item(i);
        if(item) {
            if(item->data(Qt::UserRole).toString() == resource_id)
                return item;
        }

    }

    return nullptr;
}

/** Вернуть элемент группы по идентификтаору ресурса */
QStandardItem *MainWidget::getItemGroup(QString resource_id) {
    QStandardItemModel *model = static_cast<QStandardItemModel *>(this->ui->tableGroup->model());
    if(!model) {
        return nullptr;
    }
    for(int i = 0 ; i < model->rowCount(); i++){
        QStandardItem *item = model->item(i);
        if(item) {
            if(item->data(Qt::UserRole).toString() == resource_id)
                return item;
        }
    }

    return nullptr;
}

/** Вернуть выбранный сниппет */
QSnippetResponseResourceItem *MainWidget::getSelectedSnippet() {
    QItemSelectionModel *model = this->ui->tableSnippet->selectionModel();
    if(!model)
        return nullptr;

    QModelIndexList listIndex = model->selectedIndexes();
    if(listIndex.empty())
        return nullptr;

    QString resource_id = listIndex.first().data(Qt::UserRole).toString();
    return assistant::getSnippet(resource_id);
}

/** Установить выбранную группу */
void MainWidget::setSelectedItemGroup(QString resource_id) {
    QStandardItem *item = this->getItemGroup(resource_id);
    if(item) {
        this->ui->tableGroup->selectRow(item->row());
    }
}

/** Вызывается при необходимости добавить группу */
void MainWidget::onAddGroup() {
    QString title = "Создание группы";
    QSettings *settings = assistant::getSettings();
    bool ok;
    QString name = QInputDialog::getText(this, title, "Имя группы", QLineEdit::Normal, "", &ok);
    if(!ok)
        return;

    name = name.trimmed();
    if(name.isEmpty()) {
        QMessageBox::information(this, title , "Пустое имя группы");
        this->onAddGroup();
        return;
    }
    this->newGroupName = name;

    QString path = QDir(settings->getPath()).filePath(name);
    this->setRequest(true);
    assistant::createTask()
            ->createDirectory()
            ->setPath(path)
            ->setResponse([=](QSnippetResponseCreateDirectory *responce){
        if(responce->resource) {
            QSettings *settings = assistant::getSettings();
            assistant::createTask()
                    ->resource()
                    ->setPath(settings->getPath())
                    ->setResponse([=](QSnippetResponseResource *responce){
                if(responce->resource) {
                    this->setRequest(false);
                    QList<QString> listGroupId = assistant::getListGroupId();
                    QList<QSnippetResponseResourceItem *> listGroup = assistant::addGroupCache(responce->resource->_embedded->items);
                    this->addGroups(listGroup);
                    for(int i = 0; i < listGroup.count(); i++) {
                        QSnippetResponseResourceItem *group = listGroup.at(i);
                        if(group->name == this->newGroupName) {
                            this->setSelectedItemGroup(group->resource_id);
                            break;
                        }
                    }
                } else if(responce->error) {
                    this->setRequest(false);
                    QMessageBox::critical(this , title , responce->error->error_description);
                }
            })->run();
        } else if(responce->error) {
            this->setRequest(false);
            QMessageBox::critical(this , title , responce->error->error_description);
        }
    })->run();
}

/** Вызывается при необходимости редактироватьь группу */
void MainWidget::onEditGroup() {
    QSnippetResponseResourceItem *group = getSelectedGroup();
    QString title = "Редактирование группы";
    if(!group) {
        QMessageBox::information(this, title , "Выберите группу");
        return;
    }
    this->group_resource_id = group->resource_id;

    bool ok;
    QString name = QInputDialog::getText(this, title, "Имя группы", QLineEdit::Normal, group->name, &ok);
    if(!ok)
        return;

    name = name.trimmed();
    if(name.isEmpty()) {
        QMessageBox::information(this, title , "Пустое имя группы");
        this->onEditGroup();
        return;
    }
    if(name == group->name.trimmed()) {
        return;
    }
    this->newGroupName = name;

    this->setRequest(true);
    assistant::createTask()
            ->move()
            ->setFrom(group->path)
            ->setPath(group->getNewPath(name))
            ->setResponse([=](QSnippetResponseMove *responce) {
        this->setRequest(false);
        if(responce->resource) {
            QSnippetResponseResourceItem *group = getSelectedGroup();
            QStandardItem *item = this->getSelectedItemGroup();

            group->name = this->newGroupName;
            group->path = group->getNewPath(this->newGroupName);
            item->setData(group->name , Qt::DisplayRole);
        } else if(responce->error) {
            QMessageBox::critical(this , title , responce->error->error_description);
        }
    })->run();

}

/** Вызывается при необходимости удалить группу */
void MainWidget::onDeleteGroup() {
    QSnippetResponseResourceItem *group = getSelectedGroup();
    QString title = "Удаление группы";
    if(!group) {
        QMessageBox::information(this, title , "Выберите группу");
        return;
    }

    QMessageBox::StandardButton reply;
    reply = QMessageBox::question(this, title, QString("Вы уверены в удалении группы \"%1\"").arg(group->name), QMessageBox::Yes|QMessageBox::No);
    if(reply != QMessageBox::StandardButton::Yes) {
        return;
    }

    this->group_resource_id = group->resource_id;
    this->setRequest(true);
    assistant::createTask()
            ->deleteDirectoryOrFile()
            ->setPath(group->path)
            ->setResponse([=](QSnippetResponseDeleteDirectoryOrFile *responce){
        if(responce->resource) {
            this->setRequest(false);
            assistant::deleteResource(this->group_resource_id);
            QStandardItem *item = this->getItemGroup(this->group_resource_id);
            if(item) {
                this->ui->tableGroup->model()->removeRows(item->row() , 1);
            }
        } else if(responce->error) {
            this->setRequest(false);
            QMessageBox::critical(this , title , responce->error->error_description);
        }
    })->run();
}

/** Вызывается при необходимости добавить сниппет */
void MainWidget::onAddSnippet() {
    QSnippetResponseResourceItem *group = this->getSelectedGroup();
    if(!group) {
        QMessageBox::critical(this , this->titleForAddSnippet , "Выберите группу");
        return;
    }
    bool ok;
    QString name = QInputDialog::getText(this, this->titleForAddSnippet, "Имя сниппета", QLineEdit::Normal, "", &ok);
    if(!ok)
        return;

    name = name.trimmed();
    if(name.isEmpty()) {
        QMessageBox::information(this, this->titleForAddSnippet , "Пустое имя сниппета");
        this->onAddSnippet();
        return;
    }
    this->newSnippetName = name;

    QString path = QDir(group->path).filePath(QString("%1.%2").arg(name).arg("txt"));
    this->setRequest(true);
    assistant::createTask()
            ->saveContent()
            ->setPath(path)
            ->setContent("")
            ->setResponse([=](QSnippetResponseSaveContent *responce){
        if(responce->resource) {
            QSnippetResponseResourceItem *group = this->getSelectedGroup();
            if(!group) {
                QMessageBox::critical(this , this->titleForAddSnippet , "Выберите группу");
                return;
            }

            assistant::createTask()
                    ->resource()
                    ->setPath(group->path)
                    ->setResponse([=](QSnippetResponseResource *responce){
                if(responce->resource) {
                    this->setRequest(false);
                    QSnippetResponseResourceItem *group = this->getSelectedGroup();
                    if(!group) {
                        QMessageBox::critical(this , this->titleForAddSnippet , "Выберите группу");
                        return;
                    }

                    QList<QString> listSnippetId = assistant::getListSnippetsInGroupId(group->resource_id);
                    QList<QSnippetResponseResourceItem *> listSnippet = assistant::addSnippetsCache(responce->resource->_embedded->items, group->resource_id);
                    this->addSnippets(listSnippet);
                    for(int i = 0; i < listSnippet.count(); i++) {
                        QSnippetResponseResourceItem *snippet = listSnippet.at(i);
                        if(snippet->getFileName() == this->newSnippetName) {
                            QStandardItem *item = this->getItemSnippet(snippet->resource_id);
                            if(item)
                                this->ui->tableSnippet->selectRow(item->row());
                            break;
                        }
                    }
                } else if(responce->error) {
                    this->setRequest(false);
                    QMessageBox::critical(this , this->titleForAddSnippet  , responce->error->error_description);
                }
            })->run();
        } else if(responce->error) {
            this->setRequest(false);
            QMessageBox::critical(this , this->titleForAddSnippet  , responce->error->error_description);
        }
    })->run();
}

/** Вызывается при необходимости редактироватьь сниппет */
void MainWidget::onEditSnippet() {
    QSnippetResponseResourceItem *snippet = this->getSelectedSnippet();
    QString title = "Редактирование сниппета";
    if(!snippet) {
        QMessageBox::information(this, title , "Выберите сниппет");
        return;
    }

    bool ok;
    QString name = QInputDialog::getText(this, title, "Имя сниппета", QLineEdit::Normal, snippet->getFileName(), &ok);
    if(!ok)
        return;

    name = name.trimmed();
    if(name.isEmpty()) {
        QMessageBox::information(this, title , "Пустое имя сниппета");
        this->onEditSnippet();
        return;
    }
    if(name == snippet->getFileName()) {
        return;
    }

    this->snippet_resource_id = snippet->resource_id;
    this->newSnippetName = name;
    QString newPathForFile = snippet->getNewPathForFile(name);

    this->setRequest(true);
    assistant::createTask()
            ->move()
            ->setFrom(snippet->path)
            ->setPath(newPathForFile)
            ->setResponse([=](QSnippetResponseMove *responce) {
        this->setRequest(false);
        if(responce->resource) {
            QSnippetResponseResourceItem *snippet = assistant::getSnippet(this->snippet_resource_id);
            QStandardItem *item = this->getItemSnippet(this->snippet_resource_id);
            snippet->setFileName(this->newSnippetName);
            snippet->path = snippet->getNewPathForFile(this->newGroupName);
            item->setData(snippet->getFileName() , Qt::DisplayRole);
        } else if(responce->error) {
            QMessageBox::critical(this , title , responce->error->error_description);
        }
    })->run();
}

/** Вызывается при необходимости удалить сниппет */
void MainWidget::onDeleteSnippet() {
    QSnippetResponseResourceItem *snippet = this->getSelectedSnippet();
    QString title = "Удаление сниппета";
    if(!snippet) {
        QMessageBox::information(this, title , "Выберите сниппет");
        return;
    }

    QMessageBox::StandardButton reply;
    reply = QMessageBox::question(this, title, QString("Вы уверены в удалении сниппета \"%1\"").arg(snippet->name), QMessageBox::Yes|QMessageBox::No);
    if(reply != QMessageBox::StandardButton::Yes) {
        return;
    }

    this->setRequest(true);
    this->snippet_resource_id = snippet->resource_id;
    assistant::createTask()
            ->deleteDirectoryOrFile()
            ->setPath(snippet->path)
            ->setResponse([=](QSnippetResponseDeleteDirectoryOrFile *responce){
        if(responce->resource) {
            this->setRequest(false);
            assistant::deleteResource(this->snippet_resource_id);
            QStandardItem *item = this->getItemSnippet(this->snippet_resource_id);
            if(item) {
                this->ui->tableSnippet->model()->removeRows(item->row() , 1);
            }
        } else if(responce->error) {
            this->setRequest(false);
            QMessageBox::critical(this , title , responce->error->error_description);
        }
    })->run();
}

/** Вызывается при необходимости редактировать сниппет или группу с горячей клавиши */
void MainWidget::onTriggeredEdit() {
    QWidget *widget = this->focusWidget();
    if(this->ui->tableGroup == widget) {
        this->onEditGroup();
        return;
    }
    if(this->ui->tableSnippet == widget) {
        this->onEditSnippet();
        return;
    }
}