//
//  argument_test.cpp
//  program_args-test
//
//  Created by Sam Jaffe on 2/7/21.
//

#include "program_args/arguments.h"

#include "xcode_gtest_helper.h"

using testing::ElementsAre;
using testing::Eq;
using testing::IsEmpty;

template <typename T, size_t N> static T parse(char const * const (&argv)[N]) {
  return T(N, argv);
}

struct ArgumentTest : program::Arguments<ArgumentTest> {
  using Arguments::Arguments;

  std::string arg0 = argument(0, "arg0");
};

TEST(ArgumentTest, ThrowsIfMissingArg) {
  EXPECT_THROW(parse<ArgumentTest>({""}), program::IllegalPositionError);
}

TEST(ArgumentTest, ProcessesArgument) {
  auto const options = parse<ArgumentTest>({"", "value"});
  EXPECT_THAT(options.arg0, Eq("value"));
}

TEST(ArgumentTest, HasNoIssueWithOverflowArg) {
  auto const options = parse<ArgumentTest>({"", "value", "extra"});
  EXPECT_THAT(options.arg0, Eq("value"));
  EXPECT_THAT(options.args(), ElementsAre("extra"));
}

struct OptionalArgumentTest : program::Arguments<OptionalArgumentTest> {
  using Arguments::Arguments;

  std::string arg0 = argument(0, "arg0");
  std::string arg1 = argument(1, "arg1") = "second";
};

TEST(OptionalArgumentTest, DoesNotRequireOptionalArg) {
  EXPECT_NO_THROW(parse<OptionalArgumentTest>({"", "value"}));
}

TEST(OptionalArgumentTest, DefaultsOutValueAsExpected) {
  auto const options = parse<OptionalArgumentTest>({"", "value"});
  EXPECT_THAT(options.arg1, Eq("second"));
}

TEST(OptionalArgumentTest, DoesNotOverflowSecondArg) {
  auto const options = parse<OptionalArgumentTest>({"", "value", "extra"});
  EXPECT_THAT(options.arg0, Eq("value"));
  EXPECT_THAT(options.arg1, Eq("extra"));
  EXPECT_THAT(options.args(), ElementsAre());
}

struct DuplicateArgumentTest : program::Arguments<DuplicateArgumentTest> {
  using Arguments::Arguments;

  std::string arg0 = argument(0, "arg0");
  std::string arg1 = argument(0, "arg1");
};

TEST(DuplicateArgumentTest, ThrowsOnConstruction) {
  EXPECT_THROW(DuplicateArgumentTest(), program::IllegalPositionError);
}

struct SkippedArgumentTest : program::Arguments<SkippedArgumentTest> {
  using Arguments::Arguments;

  std::string arg0 = argument(1, "arg0");
};

TEST(SkippedArgumentTest, ThrowsOnParsing) {
  EXPECT_NO_THROW(SkippedArgumentTest());
  EXPECT_THROW(parse<SkippedArgumentTest>({"", "", ""}),
               program::IllegalPositionError);
}

struct OOOArgumentTest : program::Arguments<OOOArgumentTest> {
  using Arguments::Arguments;

  std::string arg0 = argument(0, "arg0") = "";
  std::string arg1 = argument(1, "arg1");
};

TEST(OOOArgumentTest, ThrowsOnConstruction) {
  EXPECT_THROW(OOOArgumentTest(), program::ArgumentStructureError);
}

struct RestArgsTest : program::Arguments<RestArgsTest> {
  using Arguments::Arguments;
  
  std::string arg0 = argument(0, "arg0") = "";
  std::vector<std::string> args = rest();
};

TEST(RestArgsTest, SetsOptionalArgFirst) {
  auto const options = parse<RestArgsTest>({"", "A"});
  EXPECT_THAT(options.arg0, "A");
  EXPECT_THAT(options.args, IsEmpty());
}

TEST(RestArgsTest, ForwardsOverflowIntoRest) {
  auto const options = parse<RestArgsTest>({"", "A", "B", "C"});
  EXPECT_THAT(options.arg0, "A");
  EXPECT_THAT(options.args, ElementsAre("B", "C"));
}

struct RestDefaultArgsTest : program::Arguments<RestDefaultArgsTest> {
  using Arguments::Arguments;

  std::string arg0 = argument(0, "arg0") = "";
  std::vector<std::string> args = rest() = "REST";
};

TEST(RestDefaultArgsTest, SetsRest) {
  auto const options = parse<RestDefaultArgsTest>({""});
  EXPECT_THAT(options.args, ElementsAre("REST"));
}

TEST(RestDefaultArgsTest, OverridesRest) {
  auto const options = parse<RestDefaultArgsTest>({"", "A", "B"});
  EXPECT_THAT(options.args, ElementsAre("B"));
}