#include "controllers/AdminController.h"

#include "common/Auth.h"
#include "common/Http.h"
#include "services/AdminService.h"

#include <optional>

using drogon::HttpResponsePtr;

namespace
{
std::optional<std::string> queryValue(const drogon::HttpRequestPtr &req,
                                      const std::string &key)
{
    const auto value = req->getParameter(key);
    if (value.empty())
    {
        return std::nullopt;
    }
    return value;
}

std::optional<visione::auth::UserContext> requireUser(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &callback)
{
    const auto user = visione::auth::authenticate(req);
    if (!user)
    {
        callback(visione::http::error("unauthorized", drogon::k401Unauthorized));
    }
    return user;
}

bool blockPasswordChangeRequired(
    const visione::auth::UserContext &user,
    std::function<void(const HttpResponsePtr &)> &callback)
{
    if (!visione::auth::mustChangePassword(user))
    {
        return false;
    }
    callback(visione::http::error("password_change_required",
                                  drogon::k403Forbidden));
    return true;
}

void sendAdmin(Json::Value body,
               std::function<void(const HttpResponsePtr &)> &&callback)
{
    if (body.get("ok", false).asBool())
    {
        callback(visione::http::json(std::move(body)));
        return;
    }

    const auto error = body.get("error", "").asString();
    drogon::HttpStatusCode status = drogon::k400BadRequest;
    if (error == "forbidden" || error.rfind("cannot_", 0) == 0)
    {
        status = drogon::k403Forbidden;
    }
    else if (error.ends_with("_not_found"))
    {
        status = drogon::k404NotFound;
    }
    else if (error == "invalid_status_transition")
    {
        status = drogon::k409Conflict;
    }
    else if (error == "invalid_reference" || error.starts_with("invalid_"))
    {
        status = drogon::k422UnprocessableEntity;
    }
    else if (error == "area_outside_allowed_boundary")
    {
        status = drogon::k422UnprocessableEntity;
    }
    callback(visione::http::json(std::move(body), status));
}
}  // namespace

void AdminController::createCategory(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback)
{
    auto user = requireUser(req, callback);
    if (!user || blockPasswordChangeRequired(*user, callback))
    {
        return;
    }
    visione::services::AdminService service;
    sendAdmin(service.createCategory(*user, visione::http::requireJson(req)),
              std::move(callback));
}

void AdminController::createArea(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback)
{
    auto user = requireUser(req, callback);
    if (!user || blockPasswordChangeRequired(*user, callback))
    {
        return;
    }
    visione::services::AdminService service;
    sendAdmin(service.createArea(*user, visione::http::requireJson(req)),
              std::move(callback));
}

void AdminController::createTeam(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback)
{
    auto user = requireUser(req, callback);
    if (!user || blockPasswordChangeRequired(*user, callback))
    {
        return;
    }
    visione::services::AdminService service;
    sendAdmin(service.createTeam(*user, visione::http::requireJson(req)),
              std::move(callback));
}

void AdminController::updateCategory(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback,
    long long categoryId)
{
    auto user = requireUser(req, callback);
    if (!user || blockPasswordChangeRequired(*user, callback))
    {
        return;
    }
    visione::services::AdminService service;
    sendAdmin(service.updateCategory(*user, categoryId, visione::http::requireJson(req)),
              std::move(callback));
}

void AdminController::deleteCategory(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback,
    long long categoryId)
{
    auto user = requireUser(req, callback);
    if (!user || blockPasswordChangeRequired(*user, callback))
    {
        return;
    }
    visione::services::AdminService service;
    sendAdmin(service.deleteCategory(*user, categoryId), std::move(callback));
}

void AdminController::updateArea(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback,
    long long areaId)
{
    auto user = requireUser(req, callback);
    if (!user || blockPasswordChangeRequired(*user, callback))
    {
        return;
    }
    visione::services::AdminService service;
    sendAdmin(service.updateArea(*user, areaId, visione::http::requireJson(req)),
              std::move(callback));
}

void AdminController::deleteArea(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback,
    long long areaId)
{
    auto user = requireUser(req, callback);
    if (!user || blockPasswordChangeRequired(*user, callback))
    {
        return;
    }
    visione::services::AdminService service;
    sendAdmin(service.deleteArea(*user, areaId), std::move(callback));
}

void AdminController::updateTeam(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback,
    long long teamId)
{
    auto user = requireUser(req, callback);
    if (!user || blockPasswordChangeRequired(*user, callback))
    {
        return;
    }
    visione::services::AdminService service;
    sendAdmin(service.updateTeam(*user, teamId, visione::http::requireJson(req)),
              std::move(callback));
}

void AdminController::deleteTeam(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback,
    long long teamId)
{
    auto user = requireUser(req, callback);
    if (!user || blockPasswordChangeRequired(*user, callback))
    {
        return;
    }
    visione::services::AdminService service;
    sendAdmin(service.deleteTeam(*user, teamId), std::move(callback));
}

void AdminController::overviewStats(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback)
{
    auto user = requireUser(req, callback);
    if (!user || blockPasswordChangeRequired(*user, callback))
    {
        return;
    }
    visione::services::AdminService service;
    sendAdmin(service.overviewStats(*user), std::move(callback));
}

void AdminController::listModeration(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback)
{
    auto user = requireUser(req, callback);
    if (!user || blockPasswordChangeRequired(*user, callback))
    {
        return;
    }
    visione::services::AdminService service;
    sendAdmin(service.listModeration(*user,
                                     queryValue(req, "status"),
                                     queryValue(req, "page"),
                                     queryValue(req, "per_page")),
              std::move(callback));
}

void AdminController::updateModeration(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback,
    long long flagId)
{
    auto user = requireUser(req, callback);
    if (!user || blockPasswordChangeRequired(*user, callback))
    {
        return;
    }
    visione::services::AdminService service;
    sendAdmin(service.updateModeration(*user, flagId, visione::http::requireJson(req)),
              std::move(callback));
}

void AdminController::listUsers(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback)
{
    auto user = requireUser(req, callback);
    if (!user || blockPasswordChangeRequired(*user, callback))
    {
        return;
    }
    visione::services::AdminService service;
    sendAdmin(service.listUsers(*user), std::move(callback));
}

void AdminController::updateUserRoles(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback,
    long long userId)
{
    auto user = requireUser(req, callback);
    if (!user || blockPasswordChangeRequired(*user, callback))
    {
        return;
    }
    visione::services::AdminService service;
    sendAdmin(service.updateUserRoles(*user, userId, visione::http::requireJson(req)),
              std::move(callback));
}

void AdminController::updateUserBan(
    const drogon::HttpRequestPtr &req,
    std::function<void(const HttpResponsePtr &)> &&callback,
    long long userId)
{
    auto user = requireUser(req, callback);
    if (!user || blockPasswordChangeRequired(*user, callback))
    {
        return;
    }
    visione::services::AdminService service;
    sendAdmin(service.updateUserBan(*user, userId, visione::http::requireJson(req)),
              std::move(callback));
}