//
//  text_engine_test.cxx
//  engine-test
//
//  Created by Sam Jaffe on 7/7/19.
//  Copyright © 2019 Sam Jaffe. All rights reserved.
//

#include "game/engine/text_engine.hpp"

#include <testing/xcode_gtest_helper.h>

#include "mock_renderer.h"

#ifdef __APPLE__
namespace env::osx {
extern void bundle(std::string const &);
}
#endif

using testing::Eq;
using testing::Le;
using testing::SizeIs;

struct TextEngineTest : testing::Test {
  void SetUp() override;
  void TearDown() override;
  std::shared_ptr<graphics::manager> manager;
};

void TextEngineTest::SetUp() {
#ifdef __APPLE__
  env::osx::bundle("leumasjaffe.engine-test");
#endif
  manager.reset(new stub_manager_impl);
}

void TextEngineTest::TearDown() { manager.reset(); }

TEST_F(TextEngineTest, CanBuildFromFont) {
  EXPECT_NO_THROW(engine::text_engine("font", manager));
}

TEST_F(TextEngineTest, ThrowsOnInvalidFile) {
  EXPECT_ANY_THROW(engine::text_engine("missing", manager));
}

struct CreateTextTest : TextEngineTest {
  void SetUp() override;
  void TearDown() override;

  std::vector<graphics::object> out;
  std::unique_ptr<engine::text_engine> engine;
  engine::text_engine::cell const data{math::vec2(0.f, 0.f),
                                       math::vec2(10.f, 20.f), "HELLO"};
};

void CreateTextTest::SetUp() {
  TextEngineTest::SetUp();
  engine.reset(new engine::text_engine("font", manager));
}

void CreateTextTest::TearDown() {
  engine.reset();
  TextEngineTest::TearDown();
}

TEST_F(CreateTextTest, TextGenIsNoThrow) {
  EXPECT_NO_THROW(engine->create_text_cells(out, data));
}

TEST_F(CreateTextTest, GeneratesOneObjectPerChar) {
  engine->create_text_cells(out, data);
  EXPECT_THAT(out, SizeIs(5));
}

TEST_F(CreateTextTest, ShrinksOutVectorIfNeeded) {
  out.resize(10, {{}, {}, cast<graphics::material>(1), {}});
  engine->create_text_cells(out, data);
  EXPECT_THAT(out, SizeIs(5));
}

TEST_F(CreateTextTest, ObjectsDoNotOverlap) {
  engine->create_text_cells(out, data);
  for (std::size_t i = 0; i < out.size() - 1; ++i) {
    EXPECT_THAT(out[i].location.origin[0] + data.size[0],
                Le(out[i + 1].location.origin[0]));
  }
}

TEST_F(CreateTextTest, ObjectsAreOnSameHeight) {
  engine->create_text_cells(out, data);
  for (std::size_t i = 0; i < out.size(); ++i) {
    EXPECT_THAT(out[i].location.origin[1], Eq(data.origin[1]));
  }
}

TEST_F(CreateTextTest, EachObjectIsSizedByTheCell) {
  engine->create_text_cells(out, data);
  for (auto & obj : out) {
    EXPECT_THAT(obj.location.size, Eq(data.size));
  }
}