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

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

#include "shared_random_generator/random_impl.h"

#include "dice-roll/die.h"
#include "dice-roll/roll.h"

struct MockRandomImpl : public engine::detail::random_impl {
  MOCK_METHOD1(exclusive, unsigned int(unsigned int));
  double exclusive(double, double) { throw; }
  double inclusive(double, double) { throw; }
};

class RollTest : public ::testing::Test {
protected:
  void SetUp() override {
    pRandom = std::make_shared<MockRandomImpl>();
  }
  
  void TearDown() override {
    pRandom.reset();
  }
  
protected:
  std::shared_ptr<MockRandomImpl> pRandom;
};

using namespace ::testing;

TEST_F(RollTest, CanConstructNoThrow) {
  EXPECT_NO_THROW(dice::roller{});
  EXPECT_NO_THROW(dice::roller{pRandom});
}

TEST_F(RollTest, RollsOncePerDie) {
  dice::dice mydice{1, {{dice::ZERO, 3, 4}}, {{dice::PLUS, 1}}};
  EXPECT_CALL(*pRandom, exclusive(4)).WillOnce(Return(2)).WillOnce(Return(1))
      .WillOnce(Return(3));
  
  auto roll = dice::roller{pRandom}(mydice);
  EXPECT_THAT(roll, SizeIs(1));
  EXPECT_THAT(roll[0].sub_rolls, SizeIs(1));
  EXPECT_THAT(roll[0].sub_rolls[0].rolled, ElementsAre(3, 2, 4));
}

TEST_F(RollTest, DoesNotRollForConstants) {
  dice::dice mydice{1, {}, {{dice::PLUS, 1}}};
  EXPECT_CALL(*pRandom, exclusive(_)).Times(0);
  
  auto roll = dice::roller{pRandom}(mydice);
  EXPECT_THAT(roll, SizeIs(1));
  EXPECT_THAT(roll[0].sub_rolls, SizeIs(0));
  EXPECT_THAT(roll[0].modifiers, SizeIs(1));
  EXPECT_THAT(roll[0].modifiers[0].value, Eq(1));
}

TEST_F(RollTest, OperatorInSumsElements) {
  dice::dice mydice{1, {{dice::ZERO, 3, 4}}, {{dice::PLUS, 1}}};
  EXPECT_CALL(*pRandom, exclusive(4)).WillOnce(Return(2)).WillOnce(Return(1))
  .WillOnce(Return(3));
  
  auto roll = dice::roller{pRandom}(mydice);
  // 3 + 2 + 4 + 1 = 10
  EXPECT_THAT(int(roll[0]), Eq(10));
}

TEST(RollSerialTest, CanPrint0dN) {
  dice::dice_roll roll{{{}}};
  std::stringstream ss;
  ss << roll;
  EXPECT_THAT(ss.str(), Eq("0"));
}

TEST(RollSerialTest, Prints1dNAsRollNumber) {
  dice::dice_roll roll{{{dice::ZERO, {3}}}};
  std::stringstream ss;
  ss << roll;
  EXPECT_THAT(ss.str(), Eq("3"));
}

TEST(RollSerialTest, PrintsNdMAsList) {
  dice::dice_roll roll{{{dice::ZERO, {3, 2, 4}}}};
  std::stringstream ss;
  ss << roll;
  EXPECT_THAT(ss.str(), Eq("[ 3, 2, 4 ]"));
}