////////////////////////////////////////////////////////////////////////////////
// (c) Copyright, Ubisoft Entertainment Inc. ||  Created by Harbour Group     //
////////////////////////////////////////////////////////////////////////////////
#include "tests/config.h"
#include "tests/common/testJsonHelper.h"
#include "tests/fixture/memoryCheckFixture.h"
#include <ubiservices/core/JSON/json.h>
#include <ubiservices/core/JSON/jsonWriter.h>
#include <ubiservices/services/moderation/moderationInfo.h>

namespace US_NS {;
US_DEFINE_TEST(TestModeration);

typedef LeakChecker MODERATIONUNIT;

namespace TestModerationInfo_BF
{
    const bool STATUS = false;
    const char * REDACTED_TEXT = "*****";
    const char * MATCHED_TEXT = "idiot";
    const char * ROOT_TEXT = "idiot";
    const char * SEVERITY = "mild";
    const char * CATEGORY = "bullying,global-username";
    const char * CATEGORY_BULLYING = "bullying";
    const char * CATEGORY_USERNAME = "global-username";
    const char * LOCALE = "en-US";

    JsonWriter renderModerationOffensive(bool isRedactedTextReturn = false)
    {
        JsonWriter writer;
        writer["status"] = STATUS;
        if (isRedactedTextReturn)
        {
            writer["redactedText"] = REDACTED_TEXT;
        }

        JsonWriter reason;
        {
            reason["matchedText"] = MATCHED_TEXT;
            reason["rootText"] = ROOT_TEXT;
            reason["severity"] = SEVERITY;
            reason["category"] = CATEGORY;
            reason["locale"] = LOCALE;
        }
        JsonWriter reasons(JsonWriterType::Array);
        reasons.addItemToArray(reason.getJson());
        writer["reasons"] = reasons.getJson();
        writer["extraData"] = "extraData";

        return writer;
    };

    void checkModerationOffensive(ModerationInfo& moderation, bool isRedactedTextReturn = false)
    {
        EXPECT_EQ(STATUS, moderation.m_status);

        if (isRedactedTextReturn)
        {
            ASSERT_TRUE(moderation.m_redactedText.isSpecified());
            EXPECT_STREQ(REDACTED_TEXT, moderation.m_redactedText.value().getUtf8());
        }
        else
        {
            ASSERT_FALSE(moderation.m_redactedText.isSpecified());
        }

        ASSERT_GE(moderation.m_reasons.size(), 1u);
        EXPECT_STREQ(MATCHED_TEXT, moderation.m_reasons[0].m_matchedText.getUtf8());
        EXPECT_STREQ(ROOT_TEXT, moderation.m_reasons[0].m_rootText.getUtf8());
        EXPECT_EQ(ModerationSeverityTypeHelper::getEnumValue(SEVERITY), moderation.m_reasons[0].m_severity);
        ASSERT_EQ(2u, moderation.m_reasons[0].m_categories.size());
        EXPECT_STREQ(CATEGORY_BULLYING, moderation.m_reasons[0].m_categories[0].getUtf8());
        EXPECT_STREQ(CATEGORY_USERNAME, moderation.m_reasons[0].m_categories[1].getUtf8());
        EXPECT_STREQ(LOCALE, moderation.m_reasons[0].m_locale.getUtf8());
    }
}

#if !defined(US_DLL)
namespace ModerationInfoPrivate
{
    bool extractData(const Json& json, ModerationInfo& target);
};

////////////////////////////////////////////////////////////////////////////////
// ModerationInfo
TEST_F(MODERATIONUNIT, LOCAL_ModerationInfoParsingOffensive)
{
    JsonWriter writer = TestModerationInfo_BF::renderModerationOffensive(); // don't return redacted text

    {
        ModerationInfo moderation;
        EXPECT_TRUE(ModerationInfoPrivate::extractData(Json(writer.renderContent()), moderation));

        TestModerationInfo_BF::checkModerationOffensive(moderation);
    }
}

TEST_F(MODERATIONUNIT, LOCAL_ModerationInfoParsingOffensiveReturnRedactedText)
{
    JsonWriter writer = TestModerationInfo_BF::renderModerationOffensive(true); // return redacted text

    {
        ModerationInfo moderation;
        EXPECT_TRUE(ModerationInfoPrivate::extractData(Json(writer.renderContent()), moderation));

        TestModerationInfo_BF::checkModerationOffensive(moderation, true);
    }
}

TEST_F(MODERATIONUNIT, LOCAL_ModerationInfoParsingNonOffensive)
{
    JsonWriter writer;
    writer["status"] = true;

    {
        ModerationInfo moderation;
        EXPECT_TRUE(ModerationInfoPrivate::extractData(Json(writer.renderContent()), moderation));

        EXPECT_TRUE(moderation.m_status);
        ASSERT_FALSE(moderation.m_redactedText.isSpecified());
        ASSERT_EQ(0u, moderation.m_reasons.size());
    }
}

TEST_F(MODERATIONUNIT, LOCAL_ModerationInfoParsingSeverityType)
{
    Json jsonData = TestModerationInfo_BF::renderModerationOffensive().getJson();

    // Create RapidJson Document to manipulate Json
    rapidjson::Document document;
    document.Parse(jsonData.renderContent().getUtf8());

    {
        document["reasons"][0]["severity"].SetString("mild");

        ModerationInfo moderation;
        EXPECT_TRUE(ModerationInfoPrivate::extractData(TestJsonHelper::getJson(document), moderation));
        ASSERT_GE(moderation.m_reasons.size(), 1u);
        EXPECT_EQ(ModerationSeverityType::Mild, moderation.m_reasons[0].m_severity);
    }

    {
        document["reasons"][0]["severity"].SetString("medium");

        ModerationInfo moderation;
        EXPECT_TRUE(ModerationInfoPrivate::extractData(TestJsonHelper::getJson(document), moderation));
        ASSERT_GE(moderation.m_reasons.size(), 1u);
        EXPECT_EQ(ModerationSeverityType::Medium, moderation.m_reasons[0].m_severity);
    }

    {
        document["reasons"][0]["severity"].SetString("high");

        ModerationInfo moderation;
        EXPECT_TRUE(ModerationInfoPrivate::extractData(TestJsonHelper::getJson(document), moderation));
        ASSERT_GE(moderation.m_reasons.size(), 1u);
        EXPECT_EQ(ModerationSeverityType::High, moderation.m_reasons[0].m_severity);
    }

    {
        document["reasons"][0]["severity"].SetString("severe");

        ModerationInfo moderation;
        EXPECT_TRUE(ModerationInfoPrivate::extractData(TestJsonHelper::getJson(document), moderation));
        ASSERT_GE(moderation.m_reasons.size(), 1u);
        EXPECT_EQ(ModerationSeverityType::Severe, moderation.m_reasons[0].m_severity);
    }

    {
        document["reasons"][0]["severity"].SetString("invalid");

        ModerationInfo moderation;
        EXPECT_TRUE(ModerationInfoPrivate::extractData(TestJsonHelper::getJson(document), moderation));
        ASSERT_GE(moderation.m_reasons.size(), 1u);
        EXPECT_EQ(ModerationSeverityType::Undefined, moderation.m_reasons[0].m_severity);
    }

}

TEST_F(MODERATIONUNIT, LOCAL_ModerationInfoParsingStatusMissing)
{
    Json jsonData = TestModerationInfo_BF::renderModerationOffensive().getJson();

    // Create RapidJson Document to manipulate Json
    rapidjson::Document document;
    document.Parse(jsonData.renderContent().getUtf8());
    document.RemoveMember("status");

    {
        ModerationInfo moderation;
        EXPECT_FALSE(ModerationInfoPrivate::extractData(TestJsonHelper::getJson(document), moderation));
    }
}

TEST_F(MODERATIONUNIT, LOCAL_ModerationInfoParsingStatusNull)
{
    JsonWriter writer = TestModerationInfo_BF::renderModerationOffensive();
    writer["status"].setToNull();

    {
        ModerationInfo moderation;
        EXPECT_FALSE(ModerationInfoPrivate::extractData(Json(writer.renderContent()), moderation));
    }
}

TEST_F(MODERATIONUNIT, LOCAL_ModerationInfoParsingRedactedTextNull)
{
    JsonWriter writer = TestModerationInfo_BF::renderModerationOffensive();
    writer["redactedText"].setToNull();

    {
        ModerationInfo moderation;
        EXPECT_TRUE(ModerationInfoPrivate::extractData(Json(writer.renderContent()), moderation));
    }
}

TEST_F(MODERATIONUNIT, LOCAL_ModerationInfoParsingMatchedTextNull)
{
    Json jsonData = TestModerationInfo_BF::renderModerationOffensive().getJson();

    // Create RapidJson Document to manipulate Json
    rapidjson::Document document;
    document.Parse(jsonData.renderContent().getUtf8());
    document["reasons"][0].RemoveMember("matchedText");

    {
        ModerationInfo moderation;
        EXPECT_TRUE(ModerationInfoPrivate::extractData(TestJsonHelper::getJson(document), moderation));
    }
}

TEST_F(MODERATIONUNIT, LOCAL_ModerationInfoParsingRootTextNull)
{
    Json jsonData = TestModerationInfo_BF::renderModerationOffensive().getJson();

    // Create RapidJson Document to manipulate Json
    rapidjson::Document document;
    document.Parse(jsonData.renderContent().getUtf8());
    document["reasons"][0].RemoveMember("rootText");

    {
        ModerationInfo moderation;
        EXPECT_TRUE(ModerationInfoPrivate::extractData(TestJsonHelper::getJson(document), moderation));
    }
}

TEST_F(MODERATIONUNIT, LOCAL_ModerationInfoParsingSeverityNull)
{
    Json jsonData = TestModerationInfo_BF::renderModerationOffensive().getJson();

    // Create RapidJson Document to manipulate Json
    rapidjson::Document document;
    document.Parse(jsonData.renderContent().getUtf8());
    document["reasons"][0].RemoveMember("severity");

    {
        ModerationInfo moderation;
        EXPECT_TRUE(ModerationInfoPrivate::extractData(TestJsonHelper::getJson(document), moderation));
    }
}

TEST_F(MODERATIONUNIT, LOCAL_ModerationInfoParsingCategoryNull)
{
    Json jsonData = TestModerationInfo_BF::renderModerationOffensive().getJson();

    // Create RapidJson Document to manipulate Json
    rapidjson::Document document;
    document.Parse(jsonData.renderContent().getUtf8());
    document["reasons"][0].RemoveMember("category");

    {
        ModerationInfo moderation;
        EXPECT_TRUE(ModerationInfoPrivate::extractData(TestJsonHelper::getJson(document), moderation));
    }
}

TEST_F(MODERATIONUNIT, LOCAL_ModerationInfoParsingLocaleNull)
{
    Json jsonData = TestModerationInfo_BF::renderModerationOffensive().getJson();

    // Create RapidJson Document to manipulate Json
    rapidjson::Document document;
    document.Parse(jsonData.renderContent().getUtf8());
    document["reasons"][0].RemoveMember("locale");

    {
        ModerationInfo moderation;
        EXPECT_TRUE(ModerationInfoPrivate::extractData(TestJsonHelper::getJson(document), moderation));
    }
}
#endif

};