#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include <json/value.h>

#include <jvalidate/adapters/jsoncpp.h>
#include <jvalidate/detail/array_iterator.h>
#include <jvalidate/detail/object_iterator.h>

using namespace jvalidate::adapter;

using testing::Eq;
using testing::Optional;
using testing::StartsWith;

TEST(AdapterTest, NullIsMaybeNull) {
  Json::Value null = Json::nullValue;
  EXPECT_TRUE(JsonCppAdapter(null).maybe_null(true));
  EXPECT_TRUE(JsonCppAdapter(null).maybe_null(false));
}

TEST(AdapterTest, ZeroIsNotMaybeNull) {
  Json::Value zero = 0;
  EXPECT_FALSE(JsonCppAdapter(zero).maybe_null(true));
  EXPECT_FALSE(JsonCppAdapter(zero).maybe_null(false));
}

TEST(AdapterTest, EmptyStringCanBeMaybeNull) {
  Json::Value empty = "";
  EXPECT_FALSE(JsonCppAdapter(empty).maybe_null(true));
  EXPECT_TRUE(JsonCppAdapter(empty).maybe_null(false));
}

TEST(AdapterTest, BooleanIsMaybeBool) {
  Json::Value json = true;
  EXPECT_THAT(JsonCppAdapter(json).maybe_boolean(true), Optional(true));
  EXPECT_THAT(JsonCppAdapter(json).maybe_boolean(false), Optional(true));
}

TEST(AdapterTest, IntegerIsNotMaybeBool) {
  Json::Value json = 0;
  EXPECT_THAT(JsonCppAdapter(json).maybe_boolean(true), Eq(std::nullopt));
  EXPECT_THAT(JsonCppAdapter(json).maybe_boolean(false), Eq(std::nullopt));
}

TEST(AdapterTest, StringLiteralCanBeMaybeBool) {
  {
    Json::Value json = "true";
    EXPECT_THAT(JsonCppAdapter(json).maybe_boolean(true), Eq(std::nullopt));
    EXPECT_THAT(JsonCppAdapter(json).maybe_boolean(false), Optional(true));
  }

  {
    Json::Value json = "false";
    EXPECT_THAT(JsonCppAdapter(json).maybe_boolean(true), Eq(std::nullopt));
    EXPECT_THAT(JsonCppAdapter(json).maybe_boolean(false), Optional(false));
  }
}

TEST(AdapterTest, IntegerIsMaybeInt) {
  Json::Value json = 0;
  EXPECT_THAT(JsonCppAdapter(json).maybe_integer(true), Optional(0));
  EXPECT_THAT(JsonCppAdapter(json).maybe_integer(false), Optional(0));
}

TEST(AdapterTest, BooleanCanBeMaybeInt) {
  {
    Json::Value json = true;
    EXPECT_THAT(JsonCppAdapter(json).maybe_integer(true), Eq(std::nullopt));
    EXPECT_THAT(JsonCppAdapter(json).maybe_integer(false), Optional(1));
  }
  {
    Json::Value json = false;
    EXPECT_THAT(JsonCppAdapter(json).maybe_integer(true), Eq(std::nullopt));
    EXPECT_THAT(JsonCppAdapter(json).maybe_integer(false), Optional(0));
  }
}

TEST(AdapterTest, StringCanBeMaybeInt) {
  {
    Json::Value json = "1";
    EXPECT_THAT(JsonCppAdapter(json).maybe_integer(true), Eq(std::nullopt));
    EXPECT_THAT(JsonCppAdapter(json).maybe_integer(false), Optional(1));
  }
  {
    Json::Value json = "1.5";
    EXPECT_THAT(JsonCppAdapter(json).maybe_integer(true), Eq(std::nullopt));
    EXPECT_THAT(JsonCppAdapter(json).maybe_integer(false), Eq(std::nullopt));
  }
}

TEST(AdapterTest, NumberCanBeMaybeInt) {
  {
    Json::Value json = Json::realValue;
    EXPECT_THAT(JsonCppAdapter(json).maybe_integer(false), Optional(0));
  }
  {
    Json::Value json = 1.5;
    EXPECT_THAT(JsonCppAdapter(json).maybe_integer(true), Eq(std::nullopt));
    EXPECT_THAT(JsonCppAdapter(json).maybe_integer(false), Eq(std::nullopt));
  }
  {
    Json::Value json = 10000000000000000000000.0;
    EXPECT_THAT(JsonCppAdapter(json).maybe_integer(true), Eq(std::nullopt));
    EXPECT_THAT(JsonCppAdapter(json).maybe_integer(false), Eq(std::nullopt));
  }
}

TEST(AdapterTest, NumberIsMaybeNumber) {
  {
    Json::Value json = Json::realValue;
    EXPECT_THAT(JsonCppAdapter(json).maybe_number(true), Optional(0));
    EXPECT_THAT(JsonCppAdapter(json).maybe_number(false), Optional(0));
  }
  {
    Json::Value json = 1.5;
    EXPECT_THAT(JsonCppAdapter(json).maybe_number(true), Optional(1.5));
    EXPECT_THAT(JsonCppAdapter(json).maybe_number(false), Optional(1.5));
  }
}

TEST(AdapterTest, IntIsMaybeNumber) {
  Json::Value json = 1;
  EXPECT_THAT(JsonCppAdapter(json).maybe_number(true), Optional(1));
  EXPECT_THAT(JsonCppAdapter(json).maybe_number(false), Optional(1));
}

TEST(AdapterTest, BooleanIsNotMaybeNumber) {
  Json::Value json = true;
  EXPECT_THAT(JsonCppAdapter(json).maybe_number(true), Eq(std::nullopt));
  EXPECT_THAT(JsonCppAdapter(json).maybe_number(false), Eq(std::nullopt));
}

TEST(AdapterTest, StringCanBeMaybeNumber) {
  {
    Json::Value json = "1";
    EXPECT_THAT(JsonCppAdapter(json).maybe_number(true), Eq(std::nullopt));
    EXPECT_THAT(JsonCppAdapter(json).maybe_number(false), Optional(1));
  }
  {
    Json::Value json = "1.5";
    EXPECT_THAT(JsonCppAdapter(json).maybe_number(true), Eq(std::nullopt));
    EXPECT_THAT(JsonCppAdapter(json).maybe_number(false), Optional(1.5));
  }
}

TEST(AdapterTest, StringIsMaybeString) {
  Json::Value json = "lorem ipsum";
  EXPECT_THAT(JsonCppAdapter(json).maybe_string(true), Optional(Eq("lorem ipsum")));
  EXPECT_THAT(JsonCppAdapter(json).maybe_string(false), Optional(Eq("lorem ipsum")));
}

TEST(AdapterTest, NullCanBeMaybeString) {
  Json::Value json = Json::nullValue;
  EXPECT_THAT(JsonCppAdapter(json).maybe_string(true), Eq(std::nullopt));
  EXPECT_THAT(JsonCppAdapter(json).maybe_string(false), Optional(Eq("")));
}

TEST(AdapterTest, IntCanBeMaybeString) {
  Json::Value json = 5;
  EXPECT_THAT(JsonCppAdapter(json).maybe_string(true), Eq(std::nullopt));
  EXPECT_THAT(JsonCppAdapter(json).maybe_string(false), Optional(Eq("5")));
}

TEST(AdapterTest, NumberCanBeMaybeString) {
  Json::Value json = 1.5;
  EXPECT_THAT(JsonCppAdapter(json).maybe_string(true), Eq(std::nullopt));
  EXPECT_THAT(JsonCppAdapter(json).maybe_string(false), Optional(StartsWith("1.5")));
}

TEST(AdapterTest, BooleanCanBeMaybeString) {
  {
    Json::Value json = false;
    EXPECT_THAT(JsonCppAdapter(json).maybe_string(true), Eq(std::nullopt));
    EXPECT_THAT(JsonCppAdapter(json).maybe_string(false), Optional(Eq("false")));
  }
  {
    Json::Value json = true;
    EXPECT_THAT(JsonCppAdapter(json).maybe_string(true), Eq(std::nullopt));
    EXPECT_THAT(JsonCppAdapter(json).maybe_string(false), Optional(Eq("true")));
  }
}

TEST(AdapterTest, ArrayIsMaybeArraySize) {
  Json::Value json = Json::arrayValue;
  json.append(1);
  EXPECT_THAT(JsonCppAdapter(json).maybe_array_size(true), Optional(1));
  EXPECT_THAT(JsonCppAdapter(json).maybe_array_size(false), Optional(1));
}

TEST(AdapterTest, StringIsNotMaybeArraySize) {
  Json::Value json = "hello";
  EXPECT_THAT(JsonCppAdapter(json).maybe_array_size(true), Eq(std::nullopt));
  EXPECT_THAT(JsonCppAdapter(json).maybe_array_size(false), Eq(std::nullopt));
}

TEST(AdapterTest, NullCanBeMaybeArraySize) {
  Json::Value json = Json::nullValue;
  EXPECT_THAT(JsonCppAdapter(json).maybe_array_size(true), Eq(std::nullopt));
  EXPECT_THAT(JsonCppAdapter(json).maybe_array_size(false), Optional(0));
}

TEST(AdapterTest, EmptyObjectCanBeMaybeArraySize) {
  Json::Value json = Json::objectValue;
  EXPECT_THAT(JsonCppAdapter(json).maybe_array_size(true), Eq(std::nullopt));
  EXPECT_THAT(JsonCppAdapter(json).maybe_array_size(false), Optional(0));
}

TEST(AdapterTest, ObjectIsMaybeObjectSize) {
  Json::Value json = Json::objectValue;
  json["A"] = 1;
  EXPECT_THAT(JsonCppAdapter(json).maybe_object_size(true), Optional(1));
  EXPECT_THAT(JsonCppAdapter(json).maybe_object_size(false), Optional(1));
}

TEST(AdapterTest, StringIsNotMaybeObjectSize) {
  Json::Value json = "hello";
  EXPECT_THAT(JsonCppAdapter(json).maybe_object_size(true), Eq(std::nullopt));
  EXPECT_THAT(JsonCppAdapter(json).maybe_object_size(false), Eq(std::nullopt));
}

TEST(AdapterTest, NullCanBeMaybeObjectSize) {
  Json::Value json = Json::nullValue;
  EXPECT_THAT(JsonCppAdapter(json).maybe_object_size(true), Eq(std::nullopt));
  EXPECT_THAT(JsonCppAdapter(json).maybe_object_size(false), Optional(0));
}

TEST(AdapterTest, EmptyArrayCanBeMaybeObjectSize) {
  Json::Value json = Json::arrayValue;
  EXPECT_THAT(JsonCppAdapter(json).maybe_object_size(true), Eq(std::nullopt));
  EXPECT_THAT(JsonCppAdapter(json).maybe_object_size(false), Optional(0));
}

#if !defined(JVALIDATE_MONOTEST)
int main(int argc, char ** argv) {
  testing::InitGoogleMock(&argc, argv);
  return RUN_ALL_TESTS();
}
#endif