#include "ChatAdminController.h"
#include "../services/ChatService.h"
#include "../services/AuthService.h"
#include "../services/RedisMessageStore.h"
#include "../services/StickerService.h"
#include "../services/CensorService.h"
#include <json/json.h>

void ChatAdminController::getGlobalSettings(const HttpRequestPtr& req,
                                              std::function<void(const HttpResponsePtr&)>&& callback) {
    // Verify admin
    auto& authService = services::AuthService::getInstance();
    auto token = req->getHeader("Authorization");
    if (token.find("Bearer ") == 0) token = token.substr(7);

    auto claims = authService.verifyToken(token);
    if (!claims.has_value() || !claims->isAdmin) {
        Json::Value error;
        error["error"] = "Unauthorized";
        auto resp = HttpResponse::newHttpJsonResponse(error);
        resp->setStatusCode(k401Unauthorized);
        callback(resp);
        return;
    }

    auto& chatService = services::ChatService::getInstance();
    auto settings = chatService.getGlobalSettings();

    auto resp = HttpResponse::newHttpJsonResponse(settings.toJson());
    callback(resp);
}

void ChatAdminController::updateGlobalSettings(const HttpRequestPtr& req,
                                                 std::function<void(const HttpResponsePtr&)>&& callback) {
    auto jsonPtr = req->getJsonObject();
    if (!jsonPtr) {
        Json::Value error;
        error["error"] = "Invalid JSON";
        auto resp = HttpResponse::newHttpJsonResponse(error);
        resp->setStatusCode(k400BadRequest);
        callback(resp);
        return;
    }

    // Verify admin
    auto& authService = services::AuthService::getInstance();
    auto token = req->getHeader("Authorization");
    if (token.find("Bearer ") == 0) token = token.substr(7);

    auto claims = authService.verifyToken(token);
    if (!claims.has_value() || !claims->isAdmin) {
        Json::Value error;
        error["error"] = "Unauthorized";
        auto resp = HttpResponse::newHttpJsonResponse(error);
        resp->setStatusCode(k401Unauthorized);
        callback(resp);
        return;
    }

    auto settings = models::GlobalChatSettings::fromJson(*jsonPtr);

    auto& chatService = services::ChatService::getInstance();
    bool success = chatService.updateGlobalSettings(settings);

    Json::Value response;
    response["success"] = success;
    response["settings"] = settings.toJson();
    auto resp = HttpResponse::newHttpJsonResponse(response);
    callback(resp);
}

void ChatAdminController::getStats(const HttpRequestPtr& req,
                                     std::function<void(const HttpResponsePtr&)>&& callback) {
    // Verify admin
    auto& authService = services::AuthService::getInstance();
    auto token = req->getHeader("Authorization");
    if (token.find("Bearer ") == 0) token = token.substr(7);

    auto claims = authService.verifyToken(token);
    if (!claims.has_value() || !claims->isAdmin) {
        Json::Value error;
        error["error"] = "Unauthorized";
        auto resp = HttpResponse::newHttpJsonResponse(error);
        resp->setStatusCode(k401Unauthorized);
        callback(resp);
        return;
    }

    // TODO: Collect comprehensive chat statistics
    Json::Value stats;
    stats["totalMessages"] = 0;
    stats["activeConnections"] = 0;
    stats["totalRealms"] = 0;

    auto resp = HttpResponse::newHttpJsonResponse(stats);
    callback(resp);
}

void ChatAdminController::refreshStickers(const HttpRequestPtr& req,
                                          std::function<void(const HttpResponsePtr&)>&& callback) {
    // Internal endpoint called by backend after sticker modifications
    // No auth required - only accessible within Docker network
    LOG_INFO << "Sticker cache refresh requested";

    auto& stickerService = services::StickerService::getInstance();
    stickerService.refreshCache();

    Json::Value response;
    response["success"] = true;
    response["message"] = "Sticker cache refresh initiated";
    auto resp = HttpResponse::newHttpJsonResponse(response);
    callback(resp);
}

void ChatAdminController::refreshCensoredWords(const HttpRequestPtr& req,
                                               std::function<void(const HttpResponsePtr&)>&& callback) {
    // Internal endpoint called by backend after censored words modifications
    // No auth required - only accessible within Docker network
    LOG_INFO << "Censored words cache refresh requested";

    auto& censorService = services::CensorService::getInstance();
    censorService.invalidateCache();

    Json::Value response;
    response["success"] = true;
    response["message"] = "Censored words cache refresh initiated";
    auto resp = HttpResponse::newHttpJsonResponse(response);
    callback(resp);
}