#include "databaselms.h"

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

const QString DataBaseLMS::TypeUserDBInstructor = "instructor";
const QString DataBaseLMS::TypeUserDBTrainee = "trainee";

DataBaseLMS::DataBaseLMS(QWidget *ownerWidget, QObject *parent):
    QObject(parent),
    db(nullptr),
    ownerWidget(ownerWidget)
{

}

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

void DataBaseLMS::slot_LanguageChanged(QString language)
{
    qtLanguageTranslator.load(QString(QStringLiteral("translations/DataBaseLMS_")) + language, QStringLiteral("."));
    QCoreApplication::installTranslator(&qtLanguageTranslator);
}

bool DataBaseLMS::checkDriverQPSQLavailable()
{
    return QSqlDatabase::isDriverAvailable("QPSQL");
}

bool DataBaseLMS::checkUserLMSexist()
{
    DataBaseSettings dbSett = getDataBaseSettings();
    QSqlDatabase dbCheck = QSqlDatabase::addDatabase("QPSQL");

    dbCheck.setUserName("postgres");
    dbCheck.setPassword("12345678");
    dbCheck.setHostName(dbSett.dbHostName);
    dbCheck.setPort(dbSett.dbPort);

    if (dbCheck.open())
    {
        QSqlQuery query = QSqlQuery(dbCheck);
        query.prepare("SELECT 1 FROM pg_roles WHERE rolname = :username");
        query.bindValue(":username", dbSett.dbUserName);

        if (query.exec() && query.next())
        {
            qDebug() << "Пользователь существует.";
            return true;
        }
        else
        {
            qDebug() << "Пользователь не существует.";
            return false;
        }
    }
    else
    {
        qDebug() << "Ошибка подключения к PostreSQL.";
        return false;
    }
}

bool DataBaseLMS::checkDataBaseLMSexist()
{
    DataBaseSettings dbSett = getDataBaseSettings();
    QSqlDatabase dbCheck = QSqlDatabase::addDatabase("QPSQL");

    bool flDBexist = false;

    dbCheck.setUserName("postgres");
    dbCheck.setPassword("12345678");
    dbCheck.setHostName(dbSett.dbHostName);
    dbCheck.setPort(dbSett.dbPort);

    if (dbCheck.open())
    {
        QString queryStr = QString("SELECT datname FROM pg_database");
        QSqlQuery query = QSqlQuery(dbCheck);

        if(queryExec(queryStr, &query))
        {
            while (query.next())
            {//Инструктор
                QString nameDB = "";
                nameDB = query.value(0).toString();
                if(nameDB == dbSettings.dbName)
                {
                    flDBexist = true;
                    break;
                }
            }
        }
    }
    else
    {
        qDebug() << "Ошибка подключения к PostreSQL.";
        return false;
    }
    return flDBexist;
}

bool DataBaseLMS::createUser(QString name)
{
    DataBaseSettings dbSett = getDataBaseSettings();
    QSqlDatabase dbCheck = QSqlDatabase::addDatabase("QPSQL");

    dbCheck.setUserName("postgres");
    dbCheck.setPassword("12345678");
    dbCheck.setHostName(dbSett.dbHostName);
    dbCheck.setPort(dbSett.dbPort);

    if (dbCheck.open())
    {
        QString queryStr = QString("CREATE USER %1 WITH ENCRYPTED PASSWORD '%2'").arg(dbSett.dbUserName, dbSett.dbPassword);
        QSqlQuery query = QSqlQuery(dbCheck);

        if(queryExec(queryStr, &query))
        {
            qDebug() << "Пользователь создан.";
            return true;
        }
        else
        {
            qDebug() << "Пользователь не создан.";
            return false;
        }
    }
    else
    {
        qDebug() << "Ошибка подключения к PostreSQL.";
        return false;
    }
}

bool DataBaseLMS::createDB(QString name)
{
    DataBaseSettings dbSett = getDataBaseSettings();
    QSqlDatabase dbCheck = QSqlDatabase::addDatabase("QPSQL");

    dbCheck.setUserName("postgres");
    dbCheck.setPassword("12345678");
    dbCheck.setHostName(dbSett.dbHostName);
    dbCheck.setPort(dbSett.dbPort);

    if (dbCheck.open())
    {
        //Создание БД
        QString queryStr = QString("CREATE DATABASE %1").arg(dbSett.dbName);
        QSqlQuery query = QSqlQuery(dbCheck);

        if(queryExec(queryStr, &query))
        {
            qDebug() << "БД создана.";

            //Залитие БД

            QProcess process;
            //QString pgRestorePath = "C:\\restoreDB.bat"; // Замените на актуальный путь
            QString pgRestorePath = "restoreDB.bat"; // Замените на актуальный путь

            /*
            QString dbName = "databaselms2";
            QString user = "postgres";
            QString backupFile = "C:\\DBLMS_EMPTY_30_09_2025.backup";

            QStringList arguments;
            arguments << "-d" << dbName;
            arguments << "-U" << user;
            arguments << backupFile;
            */

            process.start("cmd /C " + pgRestorePath);
            process.waitForFinished(-1); // Ждать бесконечно, пока процесс не завершится


            //Назначение владельца
            QString queryStr = QString("ALTER DATABASE %1 OWNER TO %2").arg(dbSett.dbName, dbSett.dbUserName);
            QSqlQuery query = QSqlQuery(dbCheck);
            if(queryExec(queryStr, &query))
            {

            }
            else
                return false;



            //return true;
        }
        else
        {
            qDebug() << "БД не создана.";
            return false;
        }





    }
    else
    {
        qDebug() << "Ошибка подключения к PostreSQL.";
        return false;
    }

    dbCheck.close();

    QSqlDatabase dbCheck2 = QSqlDatabase::addDatabase("QPSQL");

    dbCheck2.setUserName("postgres");
    dbCheck2.setPassword("12345678");
    dbCheck2.setHostName(dbSett.dbHostName);
    dbCheck2.setPort(dbSett.dbPort);
    dbCheck2.setDatabaseName(dbSett.dbName);

    if (dbCheck2.open())
    {
        QString newOwner = dbSett.dbUserName;

        // Получаем список таблиц
        QSqlQuery query(dbCheck2);
        query.exec("SELECT tablename FROM pg_catalog.pg_tables WHERE schemaname = 'public';");

        while (query.next())
        {
            QString tableName = query.value(0).toString();
            QString alterQuery = QString("ALTER TABLE %1 OWNER TO %2;").arg(tableName).arg(newOwner);
            qDebug() << "Executing: " << alterQuery;
            dbCheck2.exec(alterQuery);
            /*
            if (dbCheck2.exec(alterQuery))
            {
                qDebug() << "Error changing owner for table " << tableName << ":" << dbCheck2.lastError().text();
                return false;
            }*/
        }
    }

    return true;
}

bool DataBaseLMS::createConnection()
{
    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)
    {
        deleteConnection();
        return false;
    }
    else
    {
        bool flHas = db->driver()->hasFeature(QSqlDriver::Transactions);
        //qDebug() << "db->driver()->hasFeature(QSqlDriver::Transactions): " << flHas;
        return true;
    }
}

void DataBaseLMS::deleteConnection()
{
    if(db != nullptr)
    {
        if(db->isOpen())
            db->close();

        delete  db;
        db = nullptr;
    }
}

bool DataBaseLMS::isConnected()
{
    if(db == nullptr)
    {
        return false;
    }
    else
    {
        if(db->isOpen())
        {
            return true;
        }
    }
    return false;
}

DataBaseSettings DataBaseLMS::getDataBaseSettings()
{
    DataBaseSettings settings;
    QFile file("config/settings.xml");
    if(!file.open(QIODevice::ReadOnly))
    {
        QMessageBox::critical(ownerWidget, tr("Attention!"), tr("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;
}

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;
    if(! (res = query->exec(queryStr)) )
            messageWarningErrorQuery(queryStr, query);
    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());
}