#include "legacyapplication.h"
#include "models/lotrodatmanager.h"
#include "models/patchlist.h"
#include "widgets/mainwindow.h"

#include <QLockFile>
#include <QMessageBox>
#include <QResource>
#include <QFontDatabase>
#include <QMessageLogContext>

#include "utils.h"

extern Q_CORE_EXPORT int qt_ntfs_permission_lookup;


LegacyApplication::LegacyApplication(int &argc, char **argv)
    : QApplication(argc, argv)
{
    qInstallMessageHandler(logMessageHandler);

    try_to_init_functional_modules_timer_.setInterval(1 * 1000); // one second
    connect(&try_to_init_functional_modules_timer_, &QTimer::timeout, this, &LegacyApplication::TryToInitFunctionalModules);
    try_to_init_functional_modules_timer_.stop();
}

bool LegacyApplication::init()
{
    qt_ntfs_permission_lookup++;
    qDebug() << "Starting initialisation...";

    QCoreApplication::setOrganizationName("LotroLegacy");
    QCoreApplication::setOrganizationDomain("translate.lotros.ru");
    QCoreApplication::setApplicationName("Legacy_v2");

    QSettings::setDefaultFormat(QSettings::IniFormat);
    QSettings::setPath(QSettings::IniFormat, QSettings::UserScope, QApplication::applicationDirPath());
    QSettings::setPath(QSettings::IniFormat, QSettings::SystemScope, QApplication::applicationDirPath());

    qDebug() << "Checking if there's another instance of Legacy";

    QLockFile lockFile(QDir::temp().absoluteFilePath("rulotro.lock"));
    if(!lockFile.tryLock(1)){
        qDebug() << "Lock file already exists! Some other application is already running...";
        QMessageBox msgBox;
        msgBox.setIcon(QMessageBox::Warning);
        msgBox.setText("Приложение уже запущено.\nРазрешено запускать только один экземпляр приложения.");
        msgBox.exec();
        return false;
    }

    qDebug() << "Initialising fonts and resources";
    QDir::setCurrent(QApplication::applicationDirPath());
    if (!FileSystem::folderExists("backup")) {
        QDir dir;
        dir.mkdir("backup");
    }

    QResource::registerResource(QApplication::applicationDirPath() + "/data01.gtr");
    QResource::registerResource(QApplication::applicationDirPath() + "/data02.gtr");

    QFontDatabase::addApplicationFont(":/fonts/trpro.ttf");
    QFontDatabase::addApplicationFont(":/fonts/CrimsonText.ttf");
    QFontDatabase::addApplicationFont(":/fonts/EBGaramond.ttf");
    QFontDatabase::addApplicationFont(":/fonts/aniron.ttf");

    qDebug() << "Starting Lotro Manager initialization...";

    lotro_dat_manager = new LotroDatManager();
    lotro_dat_manager_thread = new QThread();
    connect(lotro_dat_manager_thread, &QThread::finished, lotro_dat_manager, &LotroDatManager::deleteLater);
    lotro_dat_manager->moveToThread(lotro_dat_manager_thread);
    lotro_dat_manager_thread->start();

    qDebug() << "Starting Patch list initialisation...";

    patch_list = new PatchList(lotro_dat_manager);

    qDebug() << "Starting GUI initialisation...";

    gui = new MainWindow(patch_list);
    connect(this, &LegacyApplication::ErrorStatusChanged, gui, &MainWindow::onErrorStatusChanged);
    connect(this, &LegacyApplication::SecondsToNextTryToInitChanged, gui, &MainWindow::onSecondsToNextTryToInitChanged);

    qDebug() << "Starting functional modules initialisation...";

    TryToInitFunctionalModules();
    return true;
}

LegacyApplication::ErrorStatus LegacyApplication::CheckErrorStatus()
{
    size_t status = E_NO_ERRORS;
    QString game_folder_path = Settings::getValue("Lotro/game_path").toString();
    QString locale_prefix = Settings::getValue("Lotro/original_locale").toString();

    // Checking LotroLauncher.exe availability
    QFileInfo lotro_launcher_exe(game_folder_path + "/LotroLauncher.exe");
    if (!lotro_launcher_exe.exists()) {
        status |= E_WRONG_GAME_FOLDER;
    } else {
        if (!QFile::setPermissions(lotro_launcher_exe.absoluteFilePath(),
                QFileDevice::ReadUser | QFileDevice::WriteUser | QFileDevice::ExeUser)) {
            status |= E_WRONG_FILE_PERMISSIONS;
        }
    }

    // Checking DAT files availability & correctness
    if (!patch_list->getManager()->Initialised() || !patch_list->getManager()->DatPathIsRelevant()) {
        QString client_local_filepath = game_folder_path + "/client_local_" + locale_prefix + ".dat";
        QString client_general_filepath = game_folder_path + "/client_general.dat";

        QFileInfo client_local_file(client_local_filepath);
        QFileInfo client_general_file(client_general_filepath);

        if (!client_general_file.exists() || !client_local_file.exists()) {
            status |= E_DAT_FILES_MISSING;
        } else {
            if (!QFile::setPermissions(client_general_filepath,
                                       QFileDevice::ReadUser |
                                       QFileDevice::WriteUser |
                                       QFileDevice::ExeUser)) {
                status |= E_WRONG_FILE_PERMISSIONS;
                status |= E_CANNOT_ACCESS_DAT_FILES;
            }

            if (!QFile::setPermissions(client_local_filepath,
                                       QFileDevice::ReadUser |
                                       QFileDevice::WriteUser |
                                       QFileDevice::ExeUser)) {
                status |= E_WRONG_FILE_PERMISSIONS;
                status |= E_CANNOT_ACCESS_DAT_FILES;
            }
        }

        LOTRO_DAT::DatFile test_file;
        auto result = test_file.Initialise(client_local_filepath.toStdString(), 0);
        if (!result.result) {
            if (result.msg == "DATINIT: Error, cannot initialize dat due to internal IO error") {
                status |= E_CANNOT_ACCESS_DAT_FILES;
            } else {
                status |= E_DAT_FILE_INCORRECT;
            }
        }

        result = test_file.Initialise(client_general_filepath.toStdString(), 0);
        if (!result.result) {
            if (result.msg == "DATINIT: Error, cannot initialize dat due to internal IO error") {
                status |= E_CANNOT_ACCESS_DAT_FILES;
            } else {
                status |= E_DAT_FILE_INCORRECT;
            }
        }
    }

    if (!checkInternetConnection(QUrl(Settings::getValue("Network/patch_updates_url").toString()))) {
        status |= E_NO_SERVER_CONNECTION;
    }

    qDebug() << "LegacyApplication: StatusCheck: " << ErrorStatus(status);
    return ErrorStatus(status);
}

void LegacyApplication::TryToInitFunctionalModules()
{
    if (seconds_after_previous_try_to_init_ + 1 < try_to_init_timeout_) {
        seconds_after_previous_try_to_init_++;
        emit SecondsToNextTryToInitChanged(try_to_init_timeout_ - seconds_after_previous_try_to_init_);
        return;
    }

    try_to_init_functional_modules_timer_.stop();
    seconds_after_previous_try_to_init_ = 0;
    ErrorStatus status = CheckErrorStatus();
    emit ErrorStatusChanged(status);

    if (status == E_NO_ERRORS) {
        patch_list->initialize();
        patch_list->startAutoUpdate();
    } else {
        qWarning() << "LegacyApplication: Couldnt init functional modules!";
        try_to_init_functional_modules_timer_.start();
    }
}

QDebug operator<<(QDebug dbg, const LegacyApplication::ErrorStatus &status)
{
    bool wrong_game_folder = (status & LegacyApplication::E_WRONG_GAME_FOLDER);
    bool dat_files_missing = (status & LegacyApplication::E_DAT_FILES_MISSING);
    bool wrong_file_permissions = (status & LegacyApplication::E_WRONG_FILE_PERMISSIONS);
    bool cannot_access_dat_files = (status & LegacyApplication::E_CANNOT_ACCESS_DAT_FILES);
    bool dat_file_incorrect = (status & LegacyApplication::E_DAT_FILE_INCORRECT);
    bool no_server_connection = (status & LegacyApplication::E_NO_SERVER_CONNECTION);

    dbg.nospace() << "ErrorStatus ( "
        << (wrong_game_folder ? "Wrong game folder! " : "")
        << (dat_files_missing ? "Dat files missing! " : "")
        << (wrong_file_permissions ? "Wrong file permissions! " : "")
        << (cannot_access_dat_files ? "Cannot access dat files! " : "")
        << (dat_file_incorrect ? "Incorrect dat file! " : "")
        << (no_server_connection ? "No server connection! " : "")
        << ")";

    return dbg;
}