#include "requestmanager.h"

RequestManager::RequestManager()
{
    manager = new QNetworkAccessManager();
    token = "";
    loginStatus = false;
    QObject::connect(manager, &QNetworkAccessManager::sslErrors, this, &RequestManager::onSSLError);
}

Response* RequestManager::login()
{
    Q_ASSERT(!loginResponse);
    loginResponse = new Response;
    QNetworkRequest request;
    QString hash = encryptedPassword(this->password);
    authHeader = getLoginHeader(this->user, hash);
    QJsonObject reqBody = {
                {"password", hash},
                {"username", this->user}
    };
    request.setUrl(this->host + "/AaaManager/authSession");
    request.setRawHeader("Authorization", authHeader.toLocal8Bit());
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json; charset=UTF-8");

    QJsonDocument jsonDocument;
    jsonDocument.setObject(reqBody);
    QNetworkReply* reply = manager->post(request, jsonDocument.toJson());
    loginResponse->setReply(reply);
    QObject::connect(reply, &QNetworkReply::finished, [=]() {
        if (reply->error())
        {
            qDebug() << "Login failed: "<< reply->errorString();
            loginStatus = false;
            reply->deleteLater();
            return;
        }
        //qDebug() << "Logged in successfully.";
        loginStatus = true;
        emit successLogin();
        reply->deleteLater();
        });
    connect(this, &RequestManager::successLogin, loginResponse, &Response::ready);
    connect(this, &RequestManager::successLogin, this, &RequestManager::prepareAuthHeader);
    return loginResponse;
}

QNetworkReply* RequestManager::postRequest(const QString& endpoint, const QByteArray& json)
{
    QNetworkRequest request;
    request.setUrl(host + endpoint);
    request.setRawHeader("Authorization", authHeader.toLocal8Bit());
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json; charset=UTF-8");
    QNetworkReply* reply = manager->post(request, json);
    QObject::connect(reply, &QNetworkReply::finished, [=]() {
        if (reply->error())
        {
            qDebug() << "Authorization failed: " << reply->errorString();
            loginStatus = false;
            reply->deleteLater();
            return;
        }
        //qDebug() << "Authorized successfully, response ready.";
        emit responseReady();
        reply->deleteLater();
    });
    return reply;
}

// This will ensure login is called only once
Response* RequestManager::getLoginResponse() {
    if (!loginResponse){
        loginResponse = login();
    }
    return loginResponse;
}

Response* RequestManager::postRequestReturnLogic(const QString& endpoint, const QByteArray& data)
{
    auto loginResponse = getLoginResponse();
    Q_ASSERT(loginResponse);
    auto* response = new Response;

    if (!loginStatus){
        connect(this, &RequestManager::successLogin, [=](){
            response->setReply(postRequest(endpoint, data));
            connect(response->getReply(), &QNetworkReply::finished, response, &Response::ready);
         });
    }
    else
    {
        response->setReply(postRequest(endpoint, data));
        connect(response->getReply(), &QNetworkReply::finished, response, &Response::ready);
    }
    return response;
}

// get value of member in json
QString RequestManager::getFromJson(const QString& json, const QString &member)
{
    QJsonParseError err{};
    QJsonDocument document = QJsonDocument::fromJson(json.toUtf8(),&err);
    if (err.error != 0)
    {
        qDebug() << err.errorString();
    }
    return document.object().value(member).toString();
}

QString RequestManager::encryptedPassword(const QString& password)
{
     return QCryptographicHash::hash(password.toLocal8Bit(), QCryptographicHash::Sha512).toHex().toUpper();
}

QString RequestManager::getLoginHeader(const QString& username, const QString& hash)
{
    QString authValue = username + ":" + hash;
    return "Basic " + authValue.toLocal8Bit().toBase64();
}

void RequestManager::prepareAuthHeader()
{
    jsonResponse = loginResponse->getJson();
    token = getFromJson(jsonResponse, "id");
    QString authValue = token + ":";
    authHeader = "Basic " + authValue.toLocal8Bit().toBase64();
}

void RequestManager::onSSLError(QNetworkReply *reply, const QList<QSslError> &errors)
{
    //qDebug() << "Network SSL errors";
    for (const auto &error : errors)
    {
        if (error.error() == QSslError::SelfSignedCertificate)
            reply->ignoreSslErrors(errors);
        //qDebug() << error.errorString();
    }

}

QByteArray RequestManager::makeTimestampJson(uint64_t time)
{
    QJsonObject reqBody = {{"timestamp",QJsonValue(static_cast<qint64>(time)) }};
    QJsonDocument doc;
    doc.setObject(reqBody);
    return doc.toJson();
}

QByteArray RequestManager::makeTokensJson(const QHash<QString, QPointer<Token> > &tokens)
{
    QJsonObject items;
    QJsonArray jsonTokens;
    for (const auto& token : tokens)
    {
        jsonTokens.push_back(token->toJSON());
    }
    items.insert("items", jsonTokens);
    QJsonDocument doc;
    doc.setObject(items);
    return doc.toJson();
}

QByteArray RequestManager::makeIdsJson(const QList<QString> &ids)
{
    QJsonArray jsonIds;
    for (const auto& id : ids)
    {
        jsonIds.push_back(id);
    }
    QJsonObject items;
    items.insert("items", jsonIds);
    QJsonDocument doc;
    doc.setObject(items);
    return doc.toJson();
}

Response* RequestManager::getSubjects()
{
    return postRequestReturnLogic("/SubjectManager/getSubjects");
}

Response* RequestManager::getTokens()
{
    return postRequestReturnLogic("/TokenManager/getTokens");
}

Response* RequestManager::getTokenSubject()
{
    return postRequestReturnLogic("/OpenManager/getTokenSubject");
}

Response* RequestManager::getSubjectsUpdated(uint64_t time)
{
    return postRequestReturnLogic("/SubjectManager/getSubjectsUpdated", makeTimestampJson(time));
}

Response* RequestManager::getSubjectsDeleted(uint64_t time)
{
    return postRequestReturnLogic("/SubjectManager/getSubjectsDeleted", makeTimestampJson(time));
}

Response* RequestManager::getTokensUpdated(uint64_t time)
{
    return postRequestReturnLogic("/TokenManager/getTokensUpdated", makeTimestampJson(time));
}

Response* RequestManager::getTokensDeleted(uint64_t time)
{
    return postRequestReturnLogic("/TokenManager/getTokensDeleted", makeTimestampJson(time));
}

Response* RequestManager::getAccessGroups()
{
    return postRequestReturnLogic("/AccessManager/getAccessGroups");
}

Response* RequestManager::getAccessGroupsUpdated(uint64_t time)
{
    return postRequestReturnLogic("/AccessManager/getAccessGroupsUpdated", makeTimestampJson(time));
}

Response* RequestManager::getAccessGroupsDeleted(uint64_t time)
{
    return postRequestReturnLogic("/AccessManager/getAccessGroupsDeleted", makeTimestampJson(time));
}

Response* RequestManager::getAccessGroupMembership()
{
    return postRequestReturnLogic("/AccessManager/getAccessGroupMembership");
}

Response* RequestManager::getAccessGroupMembershipUpdated(uint64_t time)
{
    return postRequestReturnLogic("/AccessManager/getAccessGroupMembershipUpdated", makeTimestampJson(time));
}

Response* RequestManager::getAccessGroupMembershipDeleted(uint64_t time)
{
     return postRequestReturnLogic("/AccessManager/getAccessGroupMembershipDeleted", makeTimestampJson(time));
}

Response* RequestManager::setTokens(const QHash<QString, QPointer<Token> > &tokens)
{
    return postRequestReturnLogic("/TokenManager/setTokens", makeTokensJson(tokens));
}

Response* RequestManager::deleteTokens(const QList<QString> &ids)
{
    return postRequestReturnLogic("/TokenManager/deleteTokens", makeIdsJson(ids));
}