#include "authservice.h"

#include "authdbusservice.h"

#include "configuration.h"

#include "utils.h"

#include <QDebug>

#include <QMap>

#include <QProcess>

#include <QStringList>
#include <QtDBus/QtDBus>

#include <algorithm>

AuthService::AuthService(QObject *parent)

    : QObject(parent)
    , config(new Configuration(this, "/mos-auth/mos-auth.conf"))
    , registerUserProcess(new QProcess(this))
    , prepareGuestProcess(new QProcess(this))

{

    // Удаляем гостя, если он выключен в настройках.

    if (!guestEnabled()) {
        QProcess *deleteGuest = new QProcess(this);

        const QString cmd = R"( sudo /bin/loginctl kill-user --signal KILL 830 ;
                                sudo /usr/sbin/userdel -rf guest
                            )";

        deleteGuest->start("/bin/sh", QStringList() << "-c" << cmd);
    }

    // clang-format off

    connect(registerUserProcess, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
            [=](int exitCode, QProcess::ExitStatus /*exitStatus*/)
    {

        Q_EMIT registerUserFinished(exitCode == 0);

    });

    connect(prepareGuestProcess, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
            [=](int exitCode, QProcess::ExitStatus /*exitStatus*/)
    {

        Q_EMIT prepareGuestFinished(exitCode == 0);

    });

    // clang-format on

    this->dbusConnect();
}

void AuthService::dbusConnect()
{
    if (!QDBusConnection::systemBus().isConnected()) {
        qWarning() << "Cannot connect to the D-Bus system bus.";
        return;
    }

    if (!QDBusConnection::systemBus().registerService("org.mos.auth")) {
        qWarning() << qPrintable(QDBusConnection::systemBus().lastError().message());
        return;
    }

    AuthDBusService *dbus = new AuthDBusService(this);
    QDBusConnection::systemBus().registerObject("/", dbus, QDBusConnection::ExportAllSlots);

    connect(dbus, &AuthDBusService::loginCalled, this, &AuthService::login);

}

QMap<int, QString> AuthService::initMapRoleToGroup()
{
    QMap<int, QString> res;

    res.insert(Role::Admin, "mos-admin");
    res.insert(Role::Teacher, "mos-teacher");
    res.insert(Role::Student, "mos-student");

    return res;
}

QString AuthService::getGroupsFromRoles(const QList<int> &roles, const QString &separator)
{
    QString groups = "";

    for (int role : roles) {
        if (groups.length() > 0) {

            groups += separator;
        }

        groups += mapRoleToGroup.value(role);
    }

    return groups;
}

QString AuthService::getExcludeGroupsFromRoles(const QList<int> &userRoles, const QString &separator)
{
    // Все роли.
    QList<int> allRoles = mapRoleToGroup.keys();

    // Роли, не относящиеся к пользователю (группы, к которым он не принадлежит).
    QList<int> excludedRoles;

    std::set_difference(allRoles.begin(), //
                        allRoles.end(),
                        userRoles.begin(),
                        userRoles.end(),
                        std::inserter(excludedRoles, excludedRoles.begin()));

    return getGroupsFromRoles(excludedRoles, separator);
}

void AuthService::registerUser(const QString &obrId, //

                               const QString &_name,
                               const QString &_login,

                               const QString &_pin,

                               QList<int> roles)

{

    bool obrIdToNumberResult = false;
    const qint64 numericObrId = obrId.toLongLong(&obrIdToNumberResult);

    if (!obrIdToNumberResult) {

        return Q_EMIT registerUserFinished(false);

    }

    const qint64 uid = 10'000'000 + numericObrId;

    const QString uid_arg = QString::number(uid);

    const QString login = Utils::shellQuote(_login);
    const QString pin = Utils::shellQuote(_pin);
    const QString name = Utils::shellQuote(_name);

    if (roles.empty()) {

        roles.push_back(Role::Student);

    }

    // Вообще такого не должно быть, что список групп от ролей пустой,
    // так как выше в случае пустого массива с ролями добавляется группа студента (как fallback),
    // но на всякий случай обработаем и этот случай при добавлении commonGroup
    const QString groupsListFromRoles = getGroupsFromRoles(roles);

    const QString groups = Utils::shellQuote(groupsListFromRoles != "" //
                                                 ? groupsListFromRoles + "," + commonGroup
                                                 : commonGroup);

    const QString exclude_groups = Utils::shellQuote(getExcludeGroupsFromRoles(roles));

    // Создаем группы mos-teacher, mos-student и mos-admin, если их вдруг нет.

    const QString _cmd_admin_group = "(getent group 310 || sudo /usr/sbin/groupadd -g 310 mos-admin)";

    const QString _cmd_teacher_group = "(getent group 311 || sudo /usr/sbin/groupadd -g 311 mos-teacher)";
    const QString _cmd_student_group = "(getent group 312 || sudo /usr/sbin/groupadd -g 312 mos-student)";
    const QString cmd_create_groups = _cmd_admin_group + " && " + _cmd_teacher_group + " && " + _cmd_student_group;

    // Создаем группу для пользователя с gid = `uid_arg`, если её не существует.
    const QString _cmd_groupadd = "sudo /usr/sbin/groupadd -g " + uid_arg + " " + login;
    const QString cmd_create_group = "(getent group " + login + " || " + _cmd_groupadd + ")";

    // Проверяем, существует ли пользователь.

    const QString cmd_check_user_exist = "/bin/id -u " + login;

    // Обновляем группы пользователя (на тот случай, если он уже существует в системе).

    const QString _cmd_exclude_user_groups =
        "sudo /usr/sbin/usermod -G $(/bin/id -nGz " + login + " | grep -zxv " + exclude_groups + " | tr '\\0' ',' | sed 's/.$/\\n/') " + login;

    const QString cmd_update_user_groups = "(" + _cmd_exclude_user_groups + " && " + "sudo /usr/sbin/usermod -a -G " + groups + " " + login + ")";

    // Создаем нового пользователя (если его не было в системе).
    const QString cmd_create_user = "sudo /usr/sbin/useradd -c " + name + " -u " + uid_arg + " -g " + uid_arg + " -G " + groups + " " + login;

    // Задаем пароль.

    const QString cmd_pass = "sudo /usr/sbin/chpasswd <<< " + Utils::shellQuote(_login + ":" + _pin);

    // Сбрасываем блокировку пароля (если была).
    const QString cmd_reset_faillock = "sudo /sbin/faillock --user " + login + " --reset";

    const QString cmd = cmd_create_groups + " && " + cmd_create_group + " && " + "(" + cmd_check_user_exist + " && " + cmd_update_user_groups + " || "
        + cmd_create_user + ")" + " && " + cmd_pass + " && " + cmd_reset_faillock;

    registerUserProcess->start("/bin/sh", QStringList() << "-c" << cmd);
}

void AuthService::prepareGuest()
{

    const QString _cmd_create_guest = R"(sudo /usr/sbin/useradd -u 830 -c "Гость" -M guest -G )" + commonGroup;

    const QString cmd =
        "sudo /bin/loginctl kill-user --signal KILL 830 ; "
        "sudo /usr/sbin/userdel -rf guest ; "
        + _cmd_create_guest + " && " + "sudo /usr/bin/passwd -d guest";

    prepareGuestProcess->start("/bin/sh", QStringList() << "-c" << cmd);
}

void AuthService::handleEapWifi(const QString &ssid, const QString &login, const QString &pass)
{
    const QString connectionName = "temp-corp-сonnection";

    QProcess *createWifi = new QProcess(this);

    const QString deleteIfExist = QString("nmcli connection delete %1").arg(connectionName);
    const QString checkExist = QString("nmcli connection show %1").arg(connectionName);
    const QString create = QString("nmcli connection add save no type wifi con-name %1 "
                                   "autoconnect no connection.permissions sddm "
                                   "wifi-sec.key-mgmt wpa-eap 802-1x.password-flags 2 "
                                   "802-1x.eap peap 802-1x.phase2-auth mschapv2 "
                                   "802-1x.identity \"%2\" 802-1x.domain-suffix-match %3 ssid %4")
                            .arg(connectionName).arg(login).arg("hq.corp.mos.ru").arg(ssid);
    const QString connectTo = QString("echo %1 | nmcli connection up %2 --ask").arg(pass).arg(connectionName);

    const QString cmd = deleteIfExist + " ; " + checkExist + " || (" + create + " && " + connectTo + ")";
    createWifi->start("/bin/sh", QStringList() << "-c" << cmd);
}

bool AuthService::guestEnabled() const
{

    return config->guestEnabled();

}

bool AuthService::mosAuthBtnEnabled() const
{

    return config->mosAuthBtnEnabled();

}

bool AuthService::loginLowercaseOnly() const
{
    return config->loginLowercaseOnly();
}