/*
 * Copyright 2016-2025, Andrew Lindesay <apl@lindesay.co.nz>.
 * Copyright 2013-2014, Stephan Aßmus <superstippi@gmx.de>.
 * All rights reserved. Distributed under the terms of the MIT License.
 *
 * Note that this file included code earlier from `Model.cpp` and
 * copyrights have been latterly been carried across in 2024.
 */


#include "PopulatePkgUserRatingsFromServerProcess.h"

#include <Autolock.h>
#include <Catalog.h>

#include "Logger.h"
#include "PackageUtils.h"
#include "ServerHelper.h"


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "PopulatePkgUserRatingsFromServerProcess"


PopulatePkgUserRatingsFromServerProcess::PopulatePkgUserRatingsFromServerProcess(
        const BString& packageName, Model* model)
        :
        fModel(model),
        fPackageName(packageName)
{
}


PopulatePkgUserRatingsFromServerProcess::~PopulatePkgUserRatingsFromServerProcess()
{
}


const char*
PopulatePkgUserRatingsFromServerProcess::Name() const
{
        return "PopulatePkgUserRatingsFromServerProcess";
}


const char*
PopulatePkgUserRatingsFromServerProcess::Description() const
{
        return B_TRANSLATE("Fetching user ratings for package");
}


status_t
PopulatePkgUserRatingsFromServerProcess::RunInternal()
{
        if (!ServerHelper::IsNetworkAvailable()) {
                HDINFO("no network so will not populate user ratings");
                return B_OK;
        }

        // TODO; use API spec to code generation techniques instead of this manually written client.

        status_t status = B_OK;

        // Retrieve info from web-app
        BMessage info;
        BString webAppRepositoryCode = _WebAppRepositoryCode();

        if (webAppRepositoryCode.IsEmpty()) {
                HDERROR("unable to get the web app repository code for pkg [%s]", fPackageName.String());
                status = B_ERROR;
        }

        if (status == B_OK) {
                status = fModel->WebApp()->RetrieveUserRatingsForPackageForDisplay(fPackageName,
                        webAppRepositoryCode, BString(), 0, PACKAGE_INFO_MAX_USER_RATINGS, info);
                        // ^ note intentionally not using the repository source code as this would then show
                        // too few results as it would be architecture specific.
        }

        PackageUserRatingInfoBuilder userRatingInfoBuilder;

        if (status == B_OK) {
                // Parse message
                BMessage result;
                BMessage items;

                status = info.FindMessage("result", &result);

                if (status == B_OK) {

                        if (result.FindMessage("items", &items) == B_OK) {

                                int32 index = 0;
                                while (true) {
                                        BString name;
                                        name << index++;

                                        BMessage item;
                                        if (items.FindMessage(name, &item) != B_OK)
                                                break;

                                        BString code;
                                        if (item.FindString("code", &code) != B_OK) {
                                                HDERROR("corrupt user rating at index %" B_PRIi32, index);
                                                continue;
                                        }

                                        BString user;
                                        BMessage userInfo;
                                        if (item.FindMessage("user", &userInfo) != B_OK
                                                || userInfo.FindString("nickname", &user) != B_OK) {
                                                HDERROR("ignored user rating [%s] without a user nickname", code.String());
                                                continue;
                                        }

                                        // Extract basic info, all items are optional
                                        BString languageCode;
                                        BString comment;
                                        double rating;
                                        item.FindString("naturalLanguageCode", &languageCode);
                                        item.FindString("comment", &comment);
                                        if (item.FindDouble("rating", &rating) != B_OK)
                                                rating = -1;
                                        if (comment.Length() == 0 && rating == -1) {
                                                HDERROR("rating [%s] has no comment or rating so will"
                                                                " be ignored",
                                                        code.String());
                                                continue;
                                        }

                                        // For which version of the package was the rating?
                                        BString major = "?";
                                        BString minor = "?";
                                        BString micro = "";
                                        double revision = -1;
                                        BString architectureCode = "";
                                        BMessage version;
                                        if (item.FindMessage("pkgVersion", &version) == B_OK) {
                                                version.FindString("major", &major);
                                                version.FindString("minor", &minor);
                                                version.FindString("micro", &micro);
                                                version.FindDouble("revision", &revision);
                                                version.FindString("architectureCode", &architectureCode);
                                        }
                                        BString versionString = major;
                                        versionString << ".";
                                        versionString << minor;
                                        if (!micro.IsEmpty()) {
                                                versionString << ".";
                                                versionString << micro;
                                        }
                                        if (revision > 0) {
                                                versionString << "-";
                                                versionString << (int)revision;
                                        }

                                        if (!architectureCode.IsEmpty()) {
                                                versionString << " " << STR_MDASH << " ";
                                                versionString << architectureCode;
                                        }

                                        double createTimestamp;
                                        item.FindDouble("createTimestamp", &createTimestamp);

                                        // Add the rating to the PackageInfo
                                        UserRatingRef userRating(
                                                new UserRating(UserInfo(user), rating, comment, languageCode,
                                                        // note that language identifiers are "code" in HDS and "id" in Haiku
                                                        versionString, static_cast<uint64>(createTimestamp)),
                                                true);
                                        userRatingInfoBuilder.AddUserRating(userRating);
                                        HDDEBUG("rating [%s] retrieved from server", code.String());
                                }

                                userRatingInfoBuilder.WithUserRatingsPopulated();
                                HDDEBUG("did retrieve %" B_PRIi32 " user ratings for [%s]", index - 1,
                                        fPackageName.String());
                        }
                } else {
                        int32 errorCode = WebAppInterface::ErrorCodeFromResponse(info);

                        if (errorCode != ERROR_CODE_NONE)
                                ServerHelper::NotifyServerJsonRpcError(info);
                }
        } else {
                ServerHelper::NotifyTransportError(status);
        }

        // Now fetch the user rating summary which is derived separately as it is
        // not just based on the user-ratings downloaded; it is calculated according
        // to an algorithm. This is best executed server-side to avoid discrepancy.

        BMessage summaryResponse;

        if (status == B_OK) {
                status = fModel->WebApp()->RetrieveUserRatingSummaryForPackage(fPackageName,
                        webAppRepositoryCode, summaryResponse);
        }

        if (status == B_OK) {
                // Parse message
                UserRatingSummaryBuilder userRatingSummaryBuilder;

                BMessage result;

                // TODO; this entire BMessage handling is historical and needs to be swapped out with
                //      generated code from the API spec; it just takes time unfortunately.

                status = summaryResponse.FindMessage("result", &result);

                double sampleSizeF;
                int sampleSize = 0;
                bool hasData;

                if (status == B_OK)
                        status = result.FindDouble("sampleSize", &sampleSizeF);

                if (status == B_OK) {
                        sampleSize = static_cast<int>(sampleSizeF);
                        userRatingSummaryBuilder.WithRatingCount(sampleSize);
                }

                hasData = status == B_OK && sampleSize > 0;

                if (hasData) {
                        double ratingF;

                        if (status == B_OK)
                                status = result.FindDouble("rating", &ratingF);

                        if (status == B_OK)
                                userRatingSummaryBuilder.WithAverageRating(ratingF);
                }

                if (hasData) {
                        BMessage ratingDistributionItems;
                        BMessage item;

                        status = result.FindMessage("ratingDistribution", &ratingDistributionItems);

                        int32 index = 0;
                        while (status == B_OK) {
                                BString name;
                                name << index++;

                                BMessage ratingDistributionItem;
                                if (ratingDistributionItems.FindMessage(name, &ratingDistributionItem) != B_OK)
                                        break;

                                double ratingDistributionRatingF;

                                if (status == B_OK) {
                                        status
                                                = ratingDistributionItem.FindDouble("rating", &ratingDistributionRatingF);
                                }

                                double ratingDistributionTotalF;

                                if (status == B_OK)
                                        status = ratingDistributionItem.FindDouble("total", &ratingDistributionTotalF);

                                userRatingSummaryBuilder.AddRatingByStar(
                                        static_cast<int>(ratingDistributionRatingF),
                                        static_cast<int>(ratingDistributionTotalF));
                        }

                        userRatingInfoBuilder.WithSummary(userRatingSummaryBuilder.BuildRef());
                } else {
                        int32 errorCode = WebAppInterface::ErrorCodeFromResponse(summaryResponse);

                        if (errorCode != ERROR_CODE_NONE)
                                ServerHelper::NotifyServerJsonRpcError(summaryResponse);
                }
        } else {
                ServerHelper::NotifyTransportError(status);
        }

        if (status == B_OK) {
                PackageInfoRef package = fModel->PackageForName(fPackageName);

                PackageInfoRef updatedPackage = PackageInfoBuilder(package)
                                                                                        .WithUserRatingInfo(userRatingInfoBuilder.BuildRef())
                                                                                        .BuildRef();

                fModel->AddPackage(updatedPackage);
        }

        return status;
}


const BString
PopulatePkgUserRatingsFromServerProcess::_WebAppRepositoryCode() const
{
        const PackageInfoRef package = fModel->PackageForName(fPackageName);
        const BString depotName = PackageUtils::DepotName(package);
        const DepotInfoRef depot = fModel->DepotForName(depotName);

        if (depot.IsSet())
                return depot->WebAppRepositoryCode();

        return BString();
}