//
//  dice_test.cxx
//  dice-td
//
//  Created by Sam Jaffe on 12/17/18.
//  Copyright © 2018 Sam Jaffe. All rights reserved.
//

#include <gmock/gmock.h>

#include "die.h"
#include "exception.h"

#include <sstream>

using unsigned_die = std::pair<int, int>;
namespace dice {
  bool operator==(die const & lhs, die const & rhs) {
    return lhs.sgn == rhs.sgn && lhs.num == rhs.num && lhs.sides == rhs.sides;
  }
  
  bool operator==(die const & lhs, unsigned_die const & rhs) {
    return lhs.num == rhs.first && lhs.sides == rhs.second;
  }
}

using namespace ::testing;

TEST(DiceTest, ThrowsOnEmptyString) {
  EXPECT_THROW(dice::from_string(""), dice::unexpected_token);
}

TEST(DiceTest, ThrowsOnOpeningArithmetic) {
  EXPECT_THROW(dice::from_string("+5"), dice::unexpected_token);
  EXPECT_THROW(dice::from_string("-5"), dice::unexpected_token);
  EXPECT_THROW(dice::from_string("+1d4"), dice::unexpected_token);
  EXPECT_THROW(dice::from_string("-1d4"), dice::unexpected_token);
}

TEST(DiceTest, Implicit1dN) {
  dice::dice capture;
  EXPECT_NO_THROW(capture = dice::from_string("d4"));
  EXPECT_THAT(capture.num, Eq(1));
  EXPECT_THAT(capture.of, SizeIs(1));
  EXPECT_THAT(capture.of[0], Eq(unsigned_die(1, 4)));
}

TEST(DiceTest, Explicit1dN) {
  dice::dice capture;
  EXPECT_NO_THROW(capture = dice::from_string("1d4"));
  EXPECT_THAT(capture.num, Eq(1));
  EXPECT_THAT(capture.of, SizeIs(1));
  EXPECT_THAT(capture.of[0], Eq(unsigned_die(1, 4)));
}

TEST(DiceTest, CannotImplicitNumberOfSides) {
  EXPECT_THROW(dice::from_string("1d"), dice::unexpected_token);
}

TEST(DiceTest, AllowsMultipleDice) {
  dice::dice capture;
  EXPECT_NO_THROW(capture = dice::from_string("1d4+1d6"));
  EXPECT_THAT(capture.of, SizeIs(2));
  EXPECT_THAT(capture.of, ElementsAre(Eq(unsigned_die(1, 4)),
                                      Eq(unsigned_die(1, 6))));
}

TEST(DiceTest, CanIncludeConstant) {
  dice::dice capture;
  EXPECT_NO_THROW(capture = dice::from_string("1d4+1"));
  EXPECT_THAT(capture.of, SizeIs(1));
  EXPECT_THAT(capture.modifier, SizeIs(1));
  EXPECT_THAT(capture.modifier[0].value, 1);
}

TEST(DiceTest, ConstantSignIsInSgnMember) {
  dice::dice capture;
  EXPECT_NO_THROW(capture = dice::from_string("1d4-1"));
  EXPECT_THAT(capture.of, SizeIs(1));
  EXPECT_THAT(capture.modifier, SizeIs(1));
  EXPECT_THAT(capture.modifier[0].value, 1);
}

TEST(DiceTest, ThrowsIfUnterminatedArithmatic) {
  EXPECT_THROW(dice::from_string("1d4+"), dice::unexpected_token);
}

TEST(DiceTest, CanProduceMultiRollExpression) {
  dice::dice capture;
  EXPECT_NO_THROW(capture = dice::from_string("2{d4}"));
  EXPECT_THAT(capture.num, Eq(2));
  EXPECT_THAT(capture.of, SizeIs(1));
}

TEST(DiceTest, MultiRollWillThrowIfNoEndBrace) {
  EXPECT_THROW(dice::from_string("2{d4"), dice::unexpected_token);
}

TEST(DiceTest, IgnoresWhitespace) {
  dice::dice capture;
  EXPECT_NO_THROW(capture = dice::from_string("2 { d 4 + 5 }"));
  EXPECT_THAT(capture.num, Eq(2));
  EXPECT_THAT(capture.of, SizeIs(1));
  EXPECT_THAT(capture.modifier, SizeIs(1));
}

TEST(DiceSerialTest, StringFormIsExplicit) {
  std::stringstream ss;
  ss << dice::from_string("2{2d6-d4+5}");
  EXPECT_THAT(ss.str(), Eq("2{2d6-1d4+5}"));
}

TEST(DiceSerialTest, StringFormDoesNotPreserveWhitespace) {
  std::stringstream ss;
  ss << dice::from_string("2 { d 4 + 5 }");
  EXPECT_THAT(ss.str(), Eq("2{1d4+5}"));
}