#include <QDomDocument>
#include <QFile>
#include <QMessageBox>
#include <QTreeWidget>
#include <QThread>
#include <QResizeEvent>
#include "fimtaskswidget.h"
#include "ui_fimtaskswidget.h"
#include "tasksAmmFim.h"
#include "dialogchecktask.h"

FIMtasksWidget::FIMtasksWidget(ConnectorToServer* connectorToServer, TypeList type, QWidget *parent) :
    QWidget(parent),
    ui(new Ui::FIMtasksWidget),
    connectorToServer(connectorToServer),
    treeWidget(nullptr),
    type(type),    
    loginTraineeSelected(""),
    idTraineeSelected(0),
    threadPreparation(nullptr),
    taskTreePreparation(nullptr),
    waitAnimationWidget(nullptr),
    userName("")
{
    ui->setupUi(this);

    qDebug() << "FIMtasksWidget init thread ID " << QThread::currentThreadId();

    treeWidget = new QTreeWidget();
    ui->horizontalLayout_1->addWidget(treeWidget);

    connect(treeWidget, &QTreeWidget::currentItemChanged, this, &FIMtasksWidget::on_treeWidget_currentItemChanged);

    preparationTreeWidget();

    threadPreparation = new QThread();
    taskTreePreparation = new TaskTreePreparation();
    taskTreePreparation->moveToThread(threadPreparation);
    threadPreparation->start();
    threadPreparation->setPriority(QThread::HighestPriority);
    connect(this, &FIMtasksWidget::signal_prepareFIMListItems, taskTreePreparation, &TaskTreePreparation::slot_prepareFIMListItems);
    connect(this, &FIMtasksWidget::signal_prepareFIMListItemsForTrainee, taskTreePreparation, &TaskTreePreparation::slot_prepareFIMListItemsForTrainee);
    connect(taskTreePreparation, &TaskTreePreparation::signal_listFIMItemsReady, this, &FIMtasksWidget::slot_FIMlistItemsReady);

    waitAnimationWidget = new WaitAnimationWidget;
    QMovie *movie = new QMovie(":/resources/icons/762.gif");
    waitAnimationWidget->setParent(this);
    waitAnimationWidget->initialize(movie,this);

    ui->btnDelete->setObjectName("btnDelete");
    ui->btnDelete->setEnabled(false);
    ui->btnCheck->setObjectName("btnCheck");
    ui->btnCheck->setEnabled(false);
    ui->btnAssignTask->setObjectName("btnAssignTask");
    ui->btnAssignTask->setEnabled(false);

    if(type == TypeList::listCommon)
    {
        ui->horizontalLayout_3->addWidget(ui->btnAssignTask);
        ui->horizontalLayout_3->addWidget(ui->btnCheck);
        ui->horizontalLayout_3->addWidget(ui->btnDelete);
        ui->horizontalLayout_3->setAlignment(Qt::AlignmentFlag::AlignLeft);

        ui->btnDelete->setVisible(false);
        ui->btnCheck->setVisible(false);
    }
    else if(type == TypeList::listOneTask)
    {
        ui->btnDelete->setVisible(false);
        ui->btnCheck->setVisible(false);
        ui->btnAssignTask->setVisible(false);
        this->treeWidget->headerItem()->setHidden(true);
        this->treeWidget->setSelectionMode(QAbstractItemView::SelectionMode::NoSelection);        
    }
    else
    {
        ui->btnAssignTask->setVisible(false);

        ui->verticalLayout->setAlignment(Qt::AlignmentFlag::AlignBottom);
    }
}

FIMtasksWidget::~FIMtasksWidget()
{
    //deleteAllTaskAmmFim(); //TODO

    waitAnimationWidget->hideWithStop();
    taskTreePreparation->stopParser();

    threadPreparation->quit();
    threadPreparation->wait();

    delete threadPreparation;

    delete  taskTreePreparation;
    delete waitAnimationWidget;
    delete  treeWidget;

    delete ui;
}

void FIMtasksWidget::deactivate()
{
    ui->btnAssignTask->setEnabled(false);
    treeWidget->clear();
    loginTraineeSelected = "";
    idTraineeSelected = 0;
}

void FIMtasksWidget::setOneTaskFim(TaskAmmFim* task)
{
    listTaskAmmFim.append(task);
    //fillTree();
    //TODO
}

void FIMtasksWidget::resizeEvent(QResizeEvent *event)
{
    QSize size = event->size();
    waitAnimationWidget->resize(size);

    int width = treeWidget->width();

    treeWidget->setColumnWidth(ColumnsTreeFIM::clmnFIM_ID, 50);
    treeWidget->setColumnWidth(ColumnsTreeFIM::clmnFIM_status, 110);

    int widthTitle;
    if(type == TypeList::listCommon)
        widthTitle = width - (0 + 10);
    else
        widthTitle = width - (160 + 10);

    treeWidget->setColumnWidth(ColumnsTreeFIM::clmnFIM_Title, widthTitle);
}

void FIMtasksWidget::changeEvent(QEvent *event)
{
    // В случае получения события изменения языка приложения
    if (event->type() == QEvent::LanguageChange)
    {// переведём окно заново
        ui->retranslateUi(this);

        reSetHeadTreeWidget();

        if(type == TypeList::listCommon)
        {
            //slot_NeedUpdateUI();
        }
        else if(type == TypeList::listForTrainee)
            if(idTraineeSelected)
                slot_UpdateTasksFIMforTrainee(idTraineeSelected);
                //fillTree();
    }
}

void FIMtasksWidget::on_treeWidget_currentItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous)
{
    if(current == nullptr)
    {
        ui->btnDelete->setEnabled(false);
        ui->btnCheck->setEnabled(false);
        return;
    }

    QString code = "";

    QTreeWidgetItem *treeItemParent = current->parent();
    if(treeItemParent == nullptr)
    {//Выбрана задача
        int id = current->text(ColumnsTreeFIM::clmnFIM_ID).toInt();

        TaskAmmFim* task = getTaskByID(id);

        code = task->title;

        ui->btnAssignTask->setEnabled(true);

        ui->btnDelete->setEnabled(true);

        if(task->status != "new")
            ui->btnCheck->setEnabled(true);
        else
            ui->btnCheck->setEnabled(false);
    }
    else
    {
        ui->btnAssignTask->setEnabled(false);

        ui->btnDelete->setEnabled(false);
        ui->btnCheck->setEnabled(false);
    }
}

#ifdef OLD_FILL
void FIMtasksWidget::fillTree()
{
    //Обновление дерева
    treeWidget->clear();

    for(int i = 0; i < listTaskAmmFim.count(); i++)
    {/*Задачи*/
        TaskAmmFim* task = listTaskAmmFim.at(i);

        QTreeWidgetItem* itemTask = new QTreeWidgetItem();

        itemTask->setText(0, task->title);
        itemTask->setText(1, QString::number(task->id));
        //itemTask->setFlags(itemTask->flags() | Qt::ItemIsUserCheckable);
        //itemTask->setCheckState(0, Qt::Checked);

        if(task->status == "completed")
        {
            itemTask->setText(2, tr("completed"));
            itemTask->setIcon(2, QIcon(QStringLiteral(":/resources/icons/circleGreen.png")));
        }
        else if(task->status == "failed")
        {
            itemTask->setText(2, tr("failed"));
            itemTask->setIcon(2, QIcon(QStringLiteral(":/resources/icons/circleRed.png")));
        }
        else if(task->status == "checkup")
        {
            itemTask->setText(2, tr("checkup"));
            itemTask->setIcon(2, QIcon(QStringLiteral(":/resources/icons/circleYellow.png")));
        }
        else
        {
            itemTask->setText(2, tr("new"));
            itemTask->setIcon(2, QIcon(QStringLiteral(":/resources/icons/circleGray.png")));
        }


        itemTask->setIcon(0, QIcon(":/resources/icons/procedure.png"));
        itemTask->setToolTip(0, task->title);

        treeWidget->addTopLevelItem(itemTask);

        for (int j = 0; j < task->malfunctionList.count(); j++)
        {/*Неисправности*/
            Malfunction malfunction = task->malfunctionList.at(j);

            QTreeWidgetItem* itemMalfunction = new QTreeWidgetItem();

            itemMalfunction->setText(0, malfunction.description);
            if(type == TypeList::listCommon)
            {
                itemMalfunction->setFlags(itemMalfunction->flags() | Qt::ItemIsUserCheckable);
                itemMalfunction->setCheckState(0, Qt::Checked);
            }

            itemMalfunction->setIcon(0, QIcon(":/resources/icons/malfunction.png"));
            itemMalfunction->setToolTip(0, malfunction.description);

            itemTask->addChild(itemMalfunction);

            for (int k = 0; k < malfunction.malfunctionSigns.count(); k++)
            {/*Сигнализация*/
                MalfunctionSign sign = malfunction.malfunctionSigns.at(k);

                QTreeWidgetItem* itemSign = new QTreeWidgetItem();

                itemSign->setText(0, sign.description);
                //itemSign->setFlags(itemSign->flags() | Qt::ItemIsUserCheckable);
                //itemSign->setCheckState(0, Qt::Checked);
                itemSign->setIcon(0, QIcon(":/resources/icons/sign.png"));
                itemSign->setToolTip(0, sign.description);

                itemMalfunction->addChild(itemSign);
            }
        }
    }

    QTreeWidgetItem * item = treeWidget->topLevelItem(0);
    if(item != nullptr)
    {
        treeWidget->setCurrentItem(item);

        if(type == TypeList::listOneTask)
        {
            treeWidget->expandAll();
        }
    }
}

/*
void FIMtasksWidget::prepareListTasksForTrainee(QList<TaskAmmFim> listTask)
{
    deleteAllTaskAmmFim();

    for(TaskAmmFim task : listTask)
    {
        TaskAmmFim* newTask = new TaskAmmFim();
        *newTask = task;

        listTaskAmmFim.append(newTask);
    }
}
*/
#endif


void FIMtasksWidget::slot_NeedUpdateUI()
{
    qDebug() << "FIMtasksWidget::slot_NeedUpdateUI thread ID " << QThread::currentThreadId();
    loadTasksFIM();
}

void FIMtasksWidget::slot_traineeSelected(QString login)
{
    qDebug() << "FIMtasksWidget::slot_traineeSelected thread ID " << QThread::currentThreadId();
    loginTraineeSelected = login;
    idTraineeSelected = connectorToServer->getIdTraineeByLogin(loginTraineeSelected);

    if(type == TypeList::listForTrainee)
    {
        waitAnimationWidget->showWithPlay();
        connectorToServer->sendQueryToDB(TypeQueryToDB::TYPE_QUERY_GET_TASKS_FIM_FOR_TRAINEE, idTraineeSelected);
    }
}

void FIMtasksWidget::slot_UpdateTasksFIMforTrainee(int trainee_id)
{
    qDebug() << "slot_UpdateTasksFIMforTrainee" << QThread::currentThreadId();
    if(type == TypeList::listForTrainee)
    {
        if(idTraineeSelected == trainee_id)
        {
            QList<TaskAmmFim> listTask = connectorToServer->getListTasksFIMforTrainee(trainee_id);
            emit signal_prepareFIMListItemsForTrainee(listTask, &listTaskAmmFim);
            //prepareListTasksForTrainee(listTask);
            //fillTree();
            //waitAnimationWidget->hideWithStop();
        }
    }
}

void FIMtasksWidget::loadTasksFIM()
{
    //Обновление дерева
    treeWidget->clear();

    waitAnimationWidget->showWithPlay();

    QByteArray arrayFIM = connectorToServer->getListTaskFimArray();

    //loadFIMtasksFromXML(arrayFIM);
    //собственно обновление дерева
    //fillTree();
    //waitAnimationWidget->hideWithStop();

    emit signal_prepareFIMListItems(arrayFIM, &listTaskAmmFim);
}

void FIMtasksWidget::slot_FIMlistItemsReady(QList<QTreeWidgetItem *> listItems)
{
    //Обновление дерева
    treeWidget->clear();

    for(QTreeWidgetItem * item : listItems)
        treeWidget->addTopLevelItem(item);

    QTreeWidgetItem * item = treeWidget->topLevelItem(0);
    if(item != nullptr)
        treeWidget->setCurrentItem(item);

    waitAnimationWidget->hideWithStop();
}

TaskAmmFim* FIMtasksWidget::getTaskByID(int id)
{
    for(int i = 0; i < listTaskAmmFim.count(); i++)
    {/*Задачи*/
        TaskAmmFim* task = listTaskAmmFim.at(i);
        if(task->id == id)
            return task;
    }

    return nullptr;
}

void FIMtasksWidget::preparationTreeWidget()
{
    treeWidget->setColumnCount(clmnFIM_count);

    reSetHeadTreeWidget();

    if(type == TypeList::listCommon || type == TypeList::listOneTask)
    {
        treeWidget->setColumnHidden(ColumnsTreeFIM::clmnFIM_ID, true);
        treeWidget->setColumnHidden(ColumnsTreeFIM::clmnFIM_status, true);
    }
}

void FIMtasksWidget::reSetHeadTreeWidget()
{
    QStringList listHeaders;

    if(type == TypeList::listForTrainee)
        listHeaders = QStringList{tr("Task FIM"), tr("ID"), tr("Status")};
    else
        listHeaders = QStringList{tr("Title"), tr("ID"), tr("Status")};

    treeWidget->setHeaderLabels(listHeaders);
}

void FIMtasksWidget::on_btnUpdateTasks_clicked()
{
    connectorToServer->sendQueryTasksXML("fim");
}

void FIMtasksWidget::assignTaskFIMtoTrainee()
{
    QTreeWidgetItem *current = treeWidget->currentItem();

    if(current == nullptr)
        return;

    int id = current->text(ColumnsTreeFIM::clmnFIM_ID).toInt();

    TaskAmmFim* task = getTaskByID(id);

    if(task)
    {
        int trainee_id = connectorToServer->getIdTraineeByLogin(loginTraineeSelected);

        TaskAmmFim taskNew;
        taskNew.title = task->title;

        //Назначенные неисправности
        for (int i = 0; i < current->childCount(); i++)
        {
            QTreeWidgetItem* itemMalfunction = current->child(i);

            if(itemMalfunction->checkState(0) == Qt::Checked)
            {
                Malfunction malfunction = task->malfunctionList.at(i);
                taskNew.malfunctionList.append(malfunction);
            }
        }

        connectorToServer->sendQueryToDB(TypeQueryToDB::TYPE_QUERY_ASSIGN_TASK_FIM_TO_TRAINEE, trainee_id, &taskNew);

        updateTaskItem(current); //TODO ?
    }
}

void FIMtasksWidget::on_btnDelete_clicked()
{
    QTreeWidgetItem *treeItemCurrent = treeWidget->currentItem();

    if(treeItemCurrent != nullptr)
    {
        QTreeWidgetItem *treeItemParent = treeItemCurrent->parent();
        if(treeItemParent == nullptr)
        {//Выбрана задача

            int id = treeItemCurrent->text(ColumnsTreeFIM::clmnFIM_ID).toInt();

            if(QMessageBox::warning(this, tr("Attention!"), tr("The deletion will be irrevocable.\nDelete it anyway?"), QMessageBox::Ok, QMessageBox::Cancel) == QMessageBox::Ok)
            {
                connectorToServer->sendQueryToDB(TypeQueryToDB::TYPE_QUERY_DEL_TASK_FIM_TO_TRAINEE, id);
            }
        }
    }
}

void FIMtasksWidget::on_btnCheck_clicked()
{
    QTreeWidgetItem *treeItemCurrent = treeWidget->currentItem();

    if(treeItemCurrent != nullptr)
    {
        QTreeWidgetItem *treeItemParent = treeItemCurrent->parent();
        if(treeItemParent == nullptr)
        {//Выбрана задача

            int id = treeItemCurrent->text(ColumnsTreeFIM::clmnFIM_ID).toInt();

            TaskAmmFim* task = getTaskByID(id);

            DialogCheckTask dlg(connectorToServer, this);

            dlg.setTask(task);

            QDialog* dialog = new QDialog(this);
            QHBoxLayout *layout = new QHBoxLayout(dialog);
            layout->addWidget(&dlg);
            dialog->setWindowTitle(tr("Check Task"));
            dialog->setMinimumSize(1600, 800);
            dialog->setStyleSheet(this->styleSheet());
            dialog->exec();
        }
    }
}

void FIMtasksWidget::on_btnAssignTask_clicked()
{
    if(QMessageBox::question(this, tr("New task"), tr("Assign this task?"), QMessageBox::Ok, QMessageBox::Cancel) == QMessageBox::Ok)
        assignTaskFIMtoTrainee();
}

void FIMtasksWidget::updateTaskItem(QTreeWidgetItem *itemTask)
{
    for (int i = 0; i < itemTask->childCount(); i++)
    {
        QTreeWidgetItem* itemMalfunction = itemTask->child(i);
        itemMalfunction->setCheckState(0, Qt::Checked);
        itemMalfunction->setExpanded(false);
    }
    itemTask->setExpanded(false);
}