#include "network/proclamation_sync.h"
#include <gtest/gtest.h>

using namespace radiantwave::db;
using namespace radiantwave::sync;

TEST(ProclamationSyncTest, ParseProclamationsJson) {
    const std::string body =
        R"([{"id":"p1","name":"Peace","content":"<p>I am <b>peace</b>.</p>","categoryId":3,"solfeggioFrequencyId":2,"subscriptionLevelId":3},
            {"id":"p2","name":"Joy &amp; Calm","content":"text","categoryId":0,"solfeggioFrequencyId":0},
            {"notAnObject":true}])";

    std::vector<ProclamationRecord> out;
    EXPECT_TRUE(parseProclamationsJson(body, out));
    ASSERT_EQ(out.size(), 2u);

    EXPECT_EQ(out[0].id, "p1");
    EXPECT_EQ(out[0].title, "Peace");
    EXPECT_EQ(out[0].content, "I am peace.");
    EXPECT_EQ(out[0].category_id, 3);
    EXPECT_EQ(out[0].solfeggio_frequency_id, 2);
    EXPECT_EQ(out[0].required_level_id, 3);

    EXPECT_EQ(out[1].id, "p2");
    EXPECT_EQ(out[1].title, "Joy & Calm");
    EXPECT_EQ(out[1].content, "text");
    EXPECT_EQ(out[1].category_id, 0);
    // Missing subscriptionLevelId defaults to the least privileged level.
    EXPECT_EQ(out[1].required_level_id, 1);
}

TEST(ProclamationSyncTest, ParseLevelIdDefaultsToBasic) {
    std::vector<ProclamationRecord> out;
    EXPECT_TRUE(parseProclamationsJson(
        R"([{"id":"a","name":"A","subscriptionLevelId":0},
            {"id":"b","name":"B","subscriptionLevelId":2}])", out));
    ASSERT_EQ(out.size(), 2u);
    EXPECT_EQ(out[0].required_level_id, 1);
    EXPECT_EQ(out[1].required_level_id, 2);
}

TEST(ProclamationSyncTest, ParseCategoriesJson) {
    const std::string body =
        R"([{"id":3,"name":"Spiritual","parentId":0,"sortOrder":1},
            {"id":7,"name":"Inner","parentId":3,"sortOrder":2}])";

    std::vector<ProclamationCategoryRecord> out;
    EXPECT_TRUE(parseCategoriesJson(body, out));
    ASSERT_EQ(out.size(), 2u);

    EXPECT_EQ(out[0].id, 3);
    EXPECT_EQ(out[0].name, "Spiritual");
    EXPECT_EQ(out[0].parent_id, 0);
    EXPECT_EQ(out[0].sort_order, 1);

    EXPECT_EQ(out[1].id, 7);
    EXPECT_EQ(out[1].name, "Inner");
    EXPECT_EQ(out[1].parent_id, 3);
    EXPECT_EQ(out[1].sort_order, 2);
}

TEST(ProclamationSyncTest, RejectMalformedJson) {
    std::vector<ProclamationRecord> procs;
    std::vector<ProclamationCategoryRecord> cats;

    EXPECT_FALSE(parseProclamationsJson("not json", procs));
    EXPECT_FALSE(parseProclamationsJson(R"({"id":"p1"})", procs)); // object, not array
    EXPECT_FALSE(parseProclamationsJson(R"([{"id":"p1"}", ])", procs));

    EXPECT_FALSE(parseCategoriesJson("garbage", cats));
    // Non-numeric ids are tolerated (row skipped), not fatal.
    EXPECT_TRUE(parseCategoriesJson(R"([{"id":"x"}])", cats));
    EXPECT_EQ(cats.size(), 0u);
}

TEST(ProclamationSyncTest, ParseSkipsMissingIdAndZeroCategory) {
    std::vector<ProclamationRecord> procs;
    EXPECT_TRUE(parseProclamationsJson(R"([{"name":"NoId"},{"id":"ok","name":"Fine","categoryId":4}])", procs));
    ASSERT_EQ(procs.size(), 1u);
    EXPECT_EQ(procs[0].id, "ok");

    std::vector<ProclamationCategoryRecord> cats;
    EXPECT_TRUE(parseCategoriesJson(R"([{"id":0,"name":"Bad"},{"id":9,"name":"Good","parentId":0}])", cats));
    ASSERT_EQ(cats.size(), 1u);
    EXPECT_EQ(cats[0].id, 9);
}

TEST(ProclamationSyncTest, StripHtmlEntities) {
    std::vector<ProclamationRecord> out;
    const std::string body =
        R"([{"id":"p1","name":"N","content":"A &amp; B &lt;C&gt; &#39;quoted&#39; &nbsp;end"}] )";
    EXPECT_TRUE(parseProclamationsJson(body, out));
    ASSERT_EQ(out.size(), 1u);
    EXPECT_EQ(out[0].content, "A & B <C> 'quoted'  end");
}