//
//  variant_test.cpp
//  variant-test
//
//  Created by Sam Jaffe on 8/14/20.
//  Copyright © 2020 Sam Jaffe. All rights reserved.
//

#include "variant/variant.hpp"

#include <map>
#include <string>
#include <utility>

#include <gmock/gmock.h>

#include "gtest_variant_matchers.h"
#include "gtest_variant_printers.h"

using test_variant =
    variant::variant<int, bool, std::string, std::map<int, int>>;

TEST(VariantTest, DefaultVariantIsTypeless) {
  test_variant test;
  EXPECT_THAT(test, testing::Not(IsValid()));
  EXPECT_THAT(test.index(), 0xFFFFFFFF);
}

TEST(VariantTest, CanSetValue) {
  test_variant test;
  test.set<int>(0);
  EXPECT_THAT(test, IsValid());
  EXPECT_THAT(test, IsStoringType<int>());
}

TEST(VariantTest, CanConstructFromValue) {
  EXPECT_NO_THROW(test_variant{int(0)});
}

TEST(VariantTest, CanGetValueByTypeId) {
  test_variant test(int(0));
  EXPECT_NO_THROW(test.get<int>());
  EXPECT_THAT(test.get<int>(), 0);
}

TEST(VariantTest, CanGetValueByTypeIndex) {
  test_variant test(int(0));
  EXPECT_NO_THROW(test.get<0>());
  EXPECT_THAT(test.get<0>(), 0);
}

TEST(VariantTest, CanInvokeStdGet) {
  test_variant test(int(0));
  EXPECT_NO_THROW(std::get<0>(test));
  EXPECT_THAT(std::get<0>(test), 0);
}

TEST(VariantTest, WillThrowOnInvalidGetType) {
  test_variant test(int(0));
  EXPECT_THROW(test.get<bool>(), std::bad_cast);
}

TEST(VariantConstTest, CanGetValueByTypeId) {
  test_variant const test(int(0));
  EXPECT_NO_THROW(test.get<int>());
  EXPECT_THAT(test.get<int>(), 0);
}

TEST(VariantConstTest, CanGetValueByTypeIndex) {
  test_variant const test(int(0));
  EXPECT_NO_THROW(test.get<0>());
  EXPECT_THAT(test.get<0>(), 0);
}

TEST(VariantConstTest, CanInvokeStdGet) {
  test_variant const test(int(0));
  EXPECT_NO_THROW(std::get<0>(test));
  EXPECT_THAT(std::get<0>(test), 0);
}

TEST(VariantConstTest, WillThrowOnInvalidGetType) {
  test_variant const test(int(0));
  EXPECT_THROW(test.get<bool>(), std::bad_cast);
}

TEST(VariantCopyTest, CtorIsInvalidSafe) {
  test_variant const test;
  test_variant copy(test);
  EXPECT_THAT(test, testing::Not(IsValid()));
  EXPECT_THAT(copy, testing::Not(IsValid()));
}

TEST(VariantCopyTest, CtorIsPODSafe) {
  test_variant const test(int(0));
  test_variant copy(test);
  EXPECT_THAT(test, IsValid());
  EXPECT_THAT(copy, IsValid());
  EXPECT_THAT(copy, IsStoringType<int>());
  EXPECT_THAT(copy.get<int>(), 0);
}

TEST(VariantCopyTest, CtorIsObjectSafe) {
  test_variant const test(std::string("hello"));
  test_variant copy(test);
  EXPECT_THAT(test, IsValid());
  EXPECT_THAT(copy, IsValid());
  EXPECT_THAT(copy, IsStoringType<std::string>());
  EXPECT_THAT(copy.get<std::string>(), "hello");
}

TEST(VariantCopyTest, CtorIsSelfReferentialObjectSafe) {
  std::map<int, int> map{{1, 2}, {2, 3}};
  test_variant const test(map);
  test_variant copy(test);
  EXPECT_THAT(test, IsValid());
  EXPECT_THAT(copy, IsValid());
  EXPECT_THAT(copy, IsStoringType<decltype(map)>());
  EXPECT_THAT(copy.get<decltype(map)>(), map);
}

TEST(VariantCopyTest, AssignIsInvalidSafe) {
  test_variant const test;
  test_variant copy;
  copy = test;
  EXPECT_THAT(test, testing::Not(IsValid()));
  EXPECT_THAT(copy, testing::Not(IsValid()));
}

TEST(VariantCopyTest, AssignIsPODSafe) {
  test_variant const test(int(0));
  test_variant copy;
  copy = test;
  EXPECT_THAT(test, IsValid());
  EXPECT_THAT(copy, IsValid());
  EXPECT_THAT(copy, IsStoringType<int>());
  EXPECT_THAT(copy.get<int>(), 0);
}

TEST(VariantCopyTest, AssignIsObjectSafe) {
  test_variant const test(std::string("hello"));
  test_variant copy;
  copy = test;
  EXPECT_THAT(test, IsValid());
  EXPECT_THAT(copy, IsValid());
  EXPECT_THAT(copy, IsStoringType<std::string>());
  EXPECT_THAT(copy.get<std::string>(), "hello");
}

TEST(VariantCopyTest, AssignIsSelfReferentialObjectSafe) {
  std::map<int, int> map{{1, 2}, {2, 3}};
  test_variant const test(map);
  test_variant copy;
  copy = test;
  EXPECT_THAT(test, IsValid());
  EXPECT_THAT(copy, IsValid());
  EXPECT_THAT(copy, IsStoringType<decltype(map)>());
  EXPECT_THAT(copy.get<decltype(map)>(), map);
}

TEST(VariantMoveTest, CtorIsInvalidSafe) {
  test_variant test;
  test_variant copy(std::move(test));
  EXPECT_THAT(test, testing::Not(IsValid()));
  EXPECT_THAT(copy, testing::Not(IsValid()));
}

TEST(VariantMoveTest, CtorIsPODSafe) {
  test_variant test(int(0));
  test_variant copy(std::move(test));
  EXPECT_THAT(test, testing::Not(IsValid()));
  EXPECT_THAT(copy, IsValid());
  EXPECT_THAT(copy, IsStoringType<int>());
  EXPECT_THAT(copy.get<int>(), 0);
}

TEST(VariantMoveTest, CtorIsObjectSafe) {
  test_variant test(std::string("hello"));
  test_variant copy(std::move(test));
  EXPECT_THAT(test, testing::Not(IsValid()));
  EXPECT_THAT(copy, IsValid());
  EXPECT_THAT(copy, IsStoringType<std::string>());
  EXPECT_THAT(copy.get<std::string>(), "hello");
}

TEST(VariantMoveTest, CtorIsSelfReferentialObjectSafe) {
  std::map<int, int> map{{1, 2}, {2, 3}};
  test_variant test(map);
  test_variant copy(std::move(test));
  EXPECT_THAT(test, testing::Not(IsValid()));
  EXPECT_THAT(copy, IsValid());
  EXPECT_THAT(copy, IsStoringType<decltype(map)>());
  EXPECT_THAT(copy.get<decltype(map)>(), map);
}

TEST(VariantMoveTest, AssignIsInvalidSafe) {
  test_variant test;
  test_variant copy;
  copy = std::move(test);
  EXPECT_THAT(test, testing::Not(IsValid()));
  EXPECT_THAT(copy, testing::Not(IsValid()));
}

TEST(VariantMoveTest, AssignIsPODSafe) {
  test_variant test(int(0));
  test_variant copy;
  copy = std::move(test);
  EXPECT_THAT(test, testing::Not(IsValid()));
  EXPECT_THAT(copy, IsValid());
  EXPECT_THAT(copy, IsStoringType<int>());
  EXPECT_THAT(copy.get<int>(), 0);
}

TEST(VariantMoveTest, AssignIsObjectSafe) {
  test_variant test(std::string("hello"));
  test_variant copy;
  copy = std::move(test);
  EXPECT_THAT(test, testing::Not(IsValid()));
  EXPECT_THAT(copy, IsValid());
  EXPECT_THAT(copy, IsStoringType<std::string>());
  EXPECT_THAT(copy.get<std::string>(), "hello");
}

TEST(VariantMoveTest, AssignIsSelfReferentialObjectSafe) {
  std::map<int, int> map{{1, 2}, {2, 3}};
  test_variant test(map);
  test_variant copy;
  copy = std::move(test);
  EXPECT_THAT(test, testing::Not(IsValid()));
  EXPECT_THAT(copy, IsValid());
  EXPECT_THAT(copy, IsStoringType<decltype(map)>());
  EXPECT_THAT(copy.get<decltype(map)>(), map);
}