#include "databaselms.h"

#include <QtSql>
#include <QSqlDatabase>
#include <QSqlDriver>
#include <QMessageBox>
#include <QDomDocument>

DataBaseLMS::DataBaseLMS(QWidget *ownerWidget):
    db(nullptr),
    transactionBegined(false),
    ownerWidget(ownerWidget)
{

}

DataBaseLMS::~DataBaseLMS()
{
    deleteConnection();
}

bool DataBaseLMS::createConnection()
{
    mtxAccess.lock();

    dbSettings = getDataBaseSettings();

    dbSettings.connectionName = "Connection_" + dbSettings.dbName;

    db = new QSqlDatabase(QSqlDatabase::addDatabase(dbSettings.dbType, dbSettings.connectionName));
    db->setDatabaseName(dbSettings.dbName);
    db->setUserName(dbSettings.dbUserName);
    db->setPassword(dbSettings.dbPassword);
    db->setHostName(dbSettings.dbHostName);
    db->setPort(dbSettings.dbPort);

    bool res = db->open();

    if(!res)
    {
        mtxAccess.unlock();
        deleteConnection();
        return false;
    }
    else
    {
        bool flHas = db->driver()->hasFeature(QSqlDriver::Transactions);
        qDebug() << "db->driver()->hasFeature(QSqlDriver::Transactions): " << flHas;
        mtxAccess.unlock();
        return true;
    }
}

void DataBaseLMS::deleteConnection()
{
    mtxAccess.lock();

    if(transactionBegined)
        QSqlDatabase::database().rollback();

    if(db != nullptr)
    {
        if(db->isOpen())
            db->close();

        delete  db;
        db = nullptr;
    }

    mtxAccess.unlock();
}

bool DataBaseLMS::isConnected()
{
    mtxAccess.lock();

    if(db == nullptr)
    {
        mtxAccess.unlock();
        return false;
    }
    else
    {
        if(db->isOpen())
        {
            mtxAccess.unlock();
            return true;
        }
    }

    mtxAccess.unlock();
    return false;
}

DataBaseSettings DataBaseLMS::getDataBaseSettings()
{
    DataBaseSettings settings;
    QFile file("config/settings.xml");
    if(!file.open(QIODevice::ReadOnly))
    {
        QMessageBox::critical(nullptr, "Attention!", "The file could not be opened: config/settings.xml");
        return settings;
    }
    QXmlStreamReader xmlReader(&file);

    while (!xmlReader.atEnd()){

        if(xmlReader.isStartElement()){

            if(xmlReader.name() == "DataBaseSettings")
            {

                foreach(const QXmlStreamAttribute &attr, xmlReader.attributes())
                {
                    QString name = attr.name().toString();
                    QString value = attr.value().toString();

                    if(name == "Type"){
                        settings.dbType = value;
                    }

                    if(name == "Name"){
                        settings.dbName = value;
                    }

                    if(name == "UserName"){
                        settings.dbUserName = value;
                    }

                    if(name == "Password"){
                        settings.dbPassword = value;
                    }

                    if(name == "HostName"){
                        settings.dbHostName = value;
                    }

                    if(name == "Port"){
                        settings.dbPort = value.toInt();
                    }

                }
            }
        }

        xmlReader.readNext();
    }

    file.close();
    return settings;
}

bool DataBaseLMS::transactionBegin()
{
    /*
    if(transactionBegined)
    {//Отмена предыдущей незаконченной
        if(QSqlDatabase::database().rollback())
            transactionBegined = false;
        else
            return false;
    }
    return (transactionBegined = QSqlDatabase::database().transaction());
    */
    return true;
}

bool DataBaseLMS::transactionEnd()
{
    /*
    if(transactionBegined)
    {
        return !(transactionBegined = !QSqlDatabase::database().commit());
    }
    return false;
    */
    return true;
}

int DataBaseLMS::queryExecInt(QString queryStr)
{
    QSqlQuery query = QSqlQuery(*db);

    if(queryExec(queryStr, &query))
    {
        if(query.first())
            return query.value(0).toInt();
    }

    return 0;
}

QString DataBaseLMS::queryExecString(QString queryStr)
{
    QSqlQuery query = QSqlQuery(*db);

    if(queryExec(queryStr, &query))
    {
        if(query.first())
            return query.value(0).toString();
    }

    return QStringLiteral("");
}

bool DataBaseLMS::queryExecBool(QString queryStr)
{
    QSqlQuery query = QSqlQuery(*db);

    if(queryExec(queryStr, &query))
    {
        if(query.first())
            return query.value(0).toBool();
    }

    return false;
}

bool DataBaseLMS::queryExec(QString queryStr, QSqlQuery *query)
{
    bool res  = false;
    mtxAccess.lock();
    if(! (res = query->exec(queryStr)) )
            messageWarningErrorQuery(queryStr, query);
    mtxAccess.unlock();
    return res;
}

void DataBaseLMS::messageWarningErrorQuery(QString queryStr, QSqlQuery* query)
{
    //Запись в файл ошибок БД
    QDomDocument commonDOM;

    QFile blankFile(":/resources/blankXML/ErrorDB.xml");

    if (! blankFile.open(QFile::ReadOnly | QFile::Text))
        qDebug() << QString("messageWarningErrorQuery: Couldn't read the file: ") + ":/resources/blankXML/ErrorDB.xml";
    else
    {
        commonDOM.setContent(blankFile.readAll());
        blankFile.close();

        QDomNode errorDBNode = commonDOM.namedItem("ErrorDB");

        QDomNode errorQueryNode = commonDOM.createElement("ErrorQuery");
        errorDBNode.appendChild(errorQueryNode);
        errorQueryNode.toElement().setAttribute("text", query->lastError().text());

        QDomNode stringOfQueryNode = commonDOM.createElement("StringOfQuery");
        errorDBNode.appendChild(stringOfQueryNode);
        stringOfQueryNode.toElement().setAttribute("text", queryStr);

        QDomNode executedQueryNode = commonDOM.createElement("ExecutedQuery");
        errorDBNode.appendChild(executedQueryNode);
        executedQueryNode.toElement().setAttribute("text", query->executedQuery());

        QFile xmlOutFile("ErrorDB.xml");
        if (!xmlOutFile.open(QFile::WriteOnly | QFile::Text))
            qDebug() << QString("messageWarningErrorQuery: Failed to write a file: ") + "ErrorDB.xml";
        else
        {
            QTextStream outFile(&xmlOutFile);
            commonDOM.save(outFile, 4);
            xmlOutFile.close();
        }
    }


    //Сообщение об ошибке
    QMessageBox::warning(ownerWidget, dbSettings.dbName,
                         "Error query:\n" + query->lastError().text() + "\n" +
                         "String of query:\n" + queryStr + "\n" +
                         "Executed query:\n" + query->executedQuery());
}