#include "StarFormattedJson.hpp"
#include "StarJsonPath.hpp"

#include "gtest/gtest.h"

using namespace Star;

TEST(FormattedJsonTest, JsonInterop) {
  Json array1 = JsonArray{1, 2, 3, 4};
  Json array2 = JsonArray{4, 3, 2, 1};
  FormattedJson farray1 = array1;
  FormattedJson farray2 = array2;

  EXPECT_EQ(farray1.toJson(), array1);
  EXPECT_EQ(farray2.toJson(), array2);
  EXPECT_NE(farray1.toJson(), array2);
  EXPECT_NE(farray2.toJson(), array1);
}

TEST(FormattedJsonTest, Parsing) {
  FormattedJson json1 = FormattedJson::parse(R"JSON(
    {
      "foo": "bar",
      "hello" : "world",
      "abc" :123
      // Comment
      ,"wat": {
        "thing": [
          49,
          27]
      }
    }
)JSON");
  FormattedJson::ElementList expectedElements = {
    WhitespaceElement{"\n      "},
    ObjectKeyElement{"foo"},
    ColonElement{},
    WhitespaceElement{" "},
    ValueElement{Json{"bar"}},
    CommaElement{},
    WhitespaceElement{"\n      "},
    ObjectKeyElement{"hello"},
    WhitespaceElement{" "},
    ColonElement{},
    WhitespaceElement{" "},
    ValueElement{Json{"world"}},
    CommaElement{},
    WhitespaceElement{"\n      "},
    ObjectKeyElement{"abc"},
    WhitespaceElement{" "},
    ColonElement{},
    ValueElement{Json{123}},
    WhitespaceElement{"\n      // Comment\n      "},
    CommaElement{},
    ObjectKeyElement{"wat"},
    ColonElement{},
    WhitespaceElement{" "},
    ValueElement{Json{JsonObject{{"thing", JsonArray{49, 27}}}}},
    WhitespaceElement{"\n    "}
  };
  EXPECT_EQ(json1.elements(), expectedElements);
  EXPECT_EQ(json1.get("foo"), FormattedJson{"bar"});
  EXPECT_EQ(json1.get("abc"), FormattedJson{123});
  EXPECT_EQ(json1.get("wat").get("thing").get(1), FormattedJson{27});
  EXPECT_NE(json1.get("wat").get("thing").get(0), FormattedJson{66});

  ASSERT_THROW(FormattedJson::parse(" "), JsonParsingException);
  ASSERT_THROW(FormattedJson::parse("/* */"), JsonParsingException);
  ASSERT_THROW(FormattedJson::parse("x"), JsonParsingException);
  ASSERT_THROW(FormattedJson::parseJson("123"), JsonParsingException);
  ASSERT_THROW(FormattedJson::parseJson("\"foo\""), JsonParsingException);
  EXPECT_TRUE(FormattedJson::parse("123").isType(Json::Type::Int));
  EXPECT_TRUE(FormattedJson::parse("\"foo\"").isType(Json::Type::String));
}

List<String> keyOrder(FormattedJson const& json) {
  List<String> keys;
  for (JsonElement const& elem : json.elements()) {
    if (elem.is<ObjectKeyElement>())
      keys.append(elem.get<ObjectKeyElement>().key);
  }
  return keys;
}

TEST(FormattedJsonTest, ObjectInsertion) {
  FormattedJson json = FormattedJson::ofType(Json::Type::Object);
  List<String> expectedKeys;

  EXPECT_EQ(keyOrder(json), expectedKeys);

  json = json.set("foo", Json{"bar"});
  expectedKeys.append("foo");
  EXPECT_EQ(keyOrder(json), expectedKeys);

  json = json.set("baz", Json{"..."});
  expectedKeys.append("baz");
  EXPECT_EQ(keyOrder(json), expectedKeys);

  json = json.prepend("hello", Json{"world"});
  expectedKeys.insertAt(0, "hello");
  EXPECT_EQ(keyOrder(json), expectedKeys);

  json = json.insertBefore("lala", Json{"alal"}, "foo");
  expectedKeys.insertAt(1, "lala");
  EXPECT_EQ(keyOrder(json), expectedKeys);

  json = json.insertAfter("lorem", Json{"ipsum"}, "foo");
  expectedKeys.insertAt(3, "lorem");
  EXPECT_EQ(keyOrder(json), expectedKeys);

  json = json.append("dolor", Json{"sit amet"});
  expectedKeys.append("dolor");
  EXPECT_EQ(keyOrder(json), expectedKeys);

  // If the key already exists, the key order doesn't change.
  json = json.set("foo", Json{123}).append("hello", Json{123}).insertAfter("dolor", Json{123}, "baz");
  EXPECT_EQ(keyOrder(json), expectedKeys);

  FormattedJson::ElementList expectedElements = {ObjectKeyElement{"hello"},
      ColonElement{},
      ValueElement{Json{123}},
      CommaElement{},
      ObjectKeyElement{"lala"},
      ColonElement{},
      ValueElement{Json{"alal"}},
      CommaElement{},
      ObjectKeyElement{"foo"},
      ColonElement{},
      ValueElement{Json{123}},
      CommaElement{},
      ObjectKeyElement{"lorem"},
      ColonElement{},
      ValueElement{Json{"ipsum"}},
      CommaElement{},
      ObjectKeyElement{"baz"},
      ColonElement{},
      ValueElement{Json{"..."}},
      CommaElement{},
      ObjectKeyElement{"dolor"},
      ColonElement{},
      ValueElement{Json{123}}};
  EXPECT_EQ(json.elements(), expectedElements);

  FormattedJson emptyObject = FormattedJson::ofType(Json::Type::Object);
  ASSERT_THROW(emptyObject.insertBefore("foo", Json{}, "bar"), JsonException);
  ASSERT_THROW(emptyObject.insertAfter("foo", Json{}, "bar"), JsonException);
  ASSERT_THROW(FormattedJson::ofType(Json::Type::Array).set("foo", Json{}), JsonException);
}

TEST(FormattedJsonTest, ObjectInsertionWithWhitespace) {
  FormattedJson json = FormattedJson::parse(" {  \"foo\": 123  } ");
  json = json.append("hello", Json{"world"});
  json = json.prepend("lorem", Json{"ipsum"});
  EXPECT_EQ(json.repr(),
      R"JSON({  "lorem": "ipsum",  "foo": 123,  "hello": "world"  })JSON");
}

TEST(FormattedJsonTest, ArrayInsertion) {
  FormattedJson json = FormattedJson::parse(R"JSON([
    12,
    34
  ])JSON");
  json = json.insert(1, Json{23});
  json = json.append(Json{45});
  json = json.set(0, Json{"01"});
  json = json.insert(0, Json{0});
  char const* expected = R"JSON([
    0,
    "01",
    23,
    34,
    45
  ])JSON";
  EXPECT_EQ(json.repr(), expected);

  FormattedJson emptyArray = FormattedJson::ofType(Json::Type::Array);
  EXPECT_EQ(emptyArray.insert(0, Json{}).size(), 1u);
  ASSERT_THROW(emptyArray.insert(1, Json{}), JsonException);
  ASSERT_THROW(FormattedJson::ofType(Json::Type::Object).insert(0, Json{}), JsonException);
}

TEST(FormattedJsonTest, ObjectErase) {
  FormattedJson json = FormattedJson::parse(R"JSON({
    "zzz": 123,
    "mmm": 456,
    "aaa": 789
  })JSON");
  json = json.eraseKey("mmm");
  char const* expected = R"JSON({
    "zzz": 123,
    "aaa": 789
  })JSON";
  EXPECT_EQ(json.repr(), expected);

  FormattedJson jsonNoZ = json.eraseKey("zzz");
  expected = R"JSON({
    "aaa": 789
  })JSON";
  EXPECT_EQ(jsonNoZ.repr(), expected);

  FormattedJson jsonNoA = json.eraseKey("aaa");
  expected = R"JSON({
    "zzz": 123
  })JSON";
  EXPECT_EQ(jsonNoA.repr(), expected);

  ASSERT_EQ(json.eraseKey("bbb"), json);
  ASSERT_THROW(FormattedJson::ofType(Json::Type::Array).eraseKey("foo"), JsonException);
}

TEST(FormattedJsonTest, ArrayErase) {
  FormattedJson json = FormattedJson::parse("[123, 456, 789]");
  EXPECT_EQ(json.eraseIndex(0).repr(), "[456, 789]");
  EXPECT_EQ(json.eraseIndex(1).repr(), "[123, 789]");
  EXPECT_EQ(json.eraseIndex(2).repr(), "[123, 456]");
  EXPECT_EQ(json.eraseIndex(0).eraseIndex(0).repr(), "[789]");
  EXPECT_EQ(json.eraseIndex(0).eraseIndex(0).eraseIndex(0).repr(), "[]");

  ASSERT_THROW(FormattedJson::ofType(Json::Type::Object).eraseIndex(0), JsonException);
}

TEST(FormattedJsonTest, CommentPreservation) {
  FormattedJson json = FormattedJson::parse(R"JSON({
    // This is a comment
    "hello": 1,
    "world": 2
  })JSON");
  json = json.insertBefore("goodbye", Json{1}, "world");
  json = json.eraseKey("hello");
  char const* expected = R"JSON({
    // This is a comment
    "goodbye": 1,
    "world": 2
  })JSON";
  EXPECT_EQ(json.repr(), expected);
}

TEST(FormattedJsonTest, StylePreservation) {
  FormattedJson json = FormattedJson::parse(R"JSON({

    "hello"        :          1234

  })JSON");
  json = json.append("world", Json{5678});
  char const* expected = R"JSON({

    "hello"        :          1234,

    "world"        :          5678

  })JSON";
  EXPECT_EQ(json.repr(), expected);
}

TEST(FormattedJsonTest, Queries) {
  FormattedJson json0 = FormattedJson::parse("[]");
  FormattedJson json1 = FormattedJson::parse("{\"a\":1}");
  FormattedJson json2 = FormattedJson::parse("[1,2]");
  FormattedJson json3 = FormattedJson::parse(R"({"a":1,"b":2,"c":3})");

  EXPECT_EQ(json0.size(), 0u);
  EXPECT_EQ(json1.size(), 1u);
  EXPECT_EQ(json2.size(), 2u);
  EXPECT_EQ(json3.size(), 3u);

  EXPECT_TRUE(json1.contains("a"));
  EXPECT_FALSE(json1.contains("b"));
  EXPECT_TRUE(json3.contains("c"));
  EXPECT_TRUE(json3.contains("b"));

  ASSERT_THROW(FormattedJson::parse("123").size(), JsonException);
  ASSERT_THROW(json2.contains("1"), JsonException);
}

TEST(FormattedJsonTest, Types) {
  FormattedJson jsonNull = Json{};
  FormattedJson jsonBool = Json{true};
  FormattedJson jsonInt = Json{1};
  FormattedJson jsonFloat = Json{2.0};
  FormattedJson jsonString = Json{"foo"};
  FormattedJson jsonArray = Json::ofType(Json::Type::Array);
  FormattedJson jsonObject = Json::ofType(Json::Type::Object);

  EXPECT_EQ(jsonNull.type(), Json::Type::Null);
  EXPECT_TRUE(jsonNull.isType(Json::Type::Null));
  EXPECT_EQ(jsonNull.typeName(), "null");

  EXPECT_EQ(jsonBool.type(), Json::Type::Bool);
  EXPECT_TRUE(jsonBool.isType(Json::Type::Bool));
  EXPECT_EQ(jsonBool.typeName(), "bool");

  EXPECT_EQ(jsonInt.type(), Json::Type::Int);
  EXPECT_TRUE(jsonInt.isType(Json::Type::Int));
  EXPECT_EQ(jsonInt.typeName(), "int");

  EXPECT_EQ(jsonFloat.type(), Json::Type::Float);
  EXPECT_TRUE(jsonFloat.isType(Json::Type::Float));
  EXPECT_EQ(jsonFloat.typeName(), "float");

  EXPECT_EQ(jsonString.type(), Json::Type::String);
  EXPECT_TRUE(jsonString.isType(Json::Type::String));
  EXPECT_EQ(jsonString.typeName(), "string");

  EXPECT_EQ(jsonArray.type(), Json::Type::Array);
  EXPECT_TRUE(jsonArray.isType(Json::Type::Array));
  EXPECT_EQ(jsonArray.typeName(), "array");

  EXPECT_EQ(jsonObject.type(), Json::Type::Object);
  EXPECT_TRUE(jsonObject.isType(Json::Type::Object));
  EXPECT_EQ(jsonObject.typeName(), "object");
}

TEST(FormattedJsonTest, JsonPath) {
  FormattedJson json = FormattedJson::parse(R"JSON({
      "foo": {
        "bar": [
          12,
          {
            "hello": "world"
          },
          45
        ]
      },
      "baz": [{"a":1}, {"a":2}, {"a":3}]
    })JSON");

  FormattedJson expectedHelloWorld = Json{JsonObject{{"hello", "world"}}};
  EXPECT_EQ(JsonPath::Pointer("/foo/bar/1").get(json), expectedHelloWorld);
  EXPECT_EQ(JsonPath::QueryPath("foo.bar[1]").get(json), expectedHelloWorld);
  EXPECT_EQ(JsonPath::Pointer("/baz/0/a").get(json), FormattedJson{Json{1}});
  EXPECT_EQ(JsonPath::QueryPath("baz[0].a").get(json), FormattedJson{Json{1}});

  json = JsonPath::Pointer("/baz/0/a").set(json, FormattedJson{Json{0}});
  json = JsonPath::QueryPath("baz[1].a").set(json, FormattedJson{Json{4}});

  json = JsonPath::Pointer("/baz/1").add(json, FormattedJson::parse("{\"b\":1}"));
  json = JsonPath::QueryPath("baz[1]").add(json, FormattedJson::parse("{\"c\":0.5}"));

  EXPECT_EQ(json.get("baz").repr(),
      R"([{"a":0},{"c":0.5},{"b":1}, {"a":4}, {"a":3}])");

  json = JsonPath::Pointer("/plz").set(json, FormattedJson{JsonArray{}});
  json = JsonPath::Pointer("/plz/-").set(json, FormattedJson{Json{"thx"}});
  json = JsonPath::Pointer("/plz/-").add(json, FormattedJson{Json{"bye"}});
  FormattedJson expectedThxBye = Json{JsonArray{"thx", "bye"}};
  EXPECT_EQ(json.get("plz"), expectedThxBye);

  // Set and add are almost the same, but:
  //    Set 0 => replaces the first array element
  json = JsonPath::Pointer("/plz/0").set(json, FormattedJson{Json{"kthx"}});
  //    Add 0 => inserts a new element at the beginning
  json = JsonPath::Pointer("/plz/0").add(json, FormattedJson{Json{"kbye"}});
  FormattedJson expectedKByeKThxBye = Json{JsonArray{"kbye", "kthx", "bye"}};
  EXPECT_EQ(json.get("plz"), expectedKByeKThxBye);

  json = JsonPath::Pointer("/foo/bar/1").remove(json);
  FormattedJson expectedBar = Json{JsonArray{12, 45}};
  EXPECT_EQ(JsonPath::Pointer("/foo/bar").get(json), expectedBar);
  json = JsonPath::QueryPath("foo.bar[1]").remove(json);
  EXPECT_EQ(JsonPath::QueryPath("foo.bar").get(json).toJson(), JsonArray{12});
}

TEST(FormattedJsonTest, NumberFormatPreservation) {
  EXPECT_EQ(FormattedJson::parse("1.0").repr(), "1.0");
  EXPECT_EQ(FormattedJson::parse("1").repr(), "1");
  EXPECT_EQ(FormattedJson::parse("-0").repr(), "-0");
  EXPECT_EQ(FormattedJson::parse("0").repr(), "0");

  EXPECT_EQ(FormattedJson::parseJson("[-0.0,1.0,-0]").repr(), "[-0.0,1.0,-0]");
  EXPECT_EQ(FormattedJson::parseJson("[1,0]").repr(), "[1,0]");
}