//
//  serial_test.cxx
//  engine-test
//
//  Created by Sam Jaffe on 6/2/19.
//  Copyright © 2019 Sam Jaffe. All rights reserved.
//
#include "game/engine/serial.hpp"

#include <sstream>

#include <json/json.h>
#include <json/reader.h>

#include <game/graphics/object.hpp>
#include <testing/xcode_gtest_helper.h>

#include "mock_renderer.h"

Json::Value to_json(std::string const & str) {
  Json::Value json;
  std::stringstream(str) >> json;
  return json;
}

struct SerialTest : testing::Test {};

using testing::Eq;

TEST_F(SerialTest, ReadsIntegerVector) {
  math::vec2i const expected{{1, 5}};
  std::string const data = "[1,5]";
  EXPECT_THAT(engine::to_vec2i(to_json(data)), Eq(expected));
}

TEST_F(SerialTest, ReadsIntegerVectorFromFloats) {
  math::vec2i const expected{{1, 5}};
  std::string const data = "[1.5,5.01]";
  EXPECT_THAT(engine::to_vec2i(to_json(data)), Eq(expected));
}

TEST_F(SerialTest, ReadsFloatVector) {
  math::vec2 const expected{{1.5, 5.01}};
  std::string const data = "[1.5,5.01]";
  EXPECT_THAT(engine::to_vec2(to_json(data)), Eq(expected));
}

TEST_F(SerialTest, ReadsFloatVectorFromInts) {
  math::vec2 const expected{{1, 5}};
  std::string const data = "[1,5]";
  EXPECT_THAT(engine::to_vec2(to_json(data)), Eq(expected));
}

TEST_F(SerialTest, MissingFloatDataIsZero) {
  math::vec2 const expected{{1, 0}};
  std::string const data = "[1]";
  EXPECT_THAT(engine::to_vec2(to_json(data)), Eq(expected));
}

TEST_F(SerialTest, FallbackReaderDoesntInvokeIfArray) {
  math::vec2 const expected{{0, 0}};
  std::string const data = "[]";
  EXPECT_THAT(engine::to_vec2(to_json(data), {{1, 5}}), Eq(expected));
}

TEST_F(SerialTest, FallbackReaderActivatesOnNull) {
  math::vec2 const expected{{1, 5}};
  std::string const data = "null";
  EXPECT_THAT(engine::to_vec2(to_json(data), {{1, 5}}), Eq(expected));
}

std::string const object_data = R"(
{
  "material": {
    "shaderProgram": {
      "fragmentShader": "serial/fragment.test",
      "vertexShader": "serial/vertex.test"
    },
    "texture": {
      "uniform": "u_normalMap"
    }
  },
  "position": [0, 0],
  "scale": 1.0
}
)";

struct ObjectSerialTest : testing::Test {
  stub_manager_impl mgr;
};

TEST_F(ObjectSerialTest, CanConstructFromJson) {
  EXPECT_NO_THROW(engine::to_object(to_json(object_data), mgr));
}

TEST_F(ObjectSerialTest, DoesNotRequireShaderProgramDefinition) {
  Json::Value json = to_json(object_data);
  json["material"].removeMember("shaderProgram");
  EXPECT_NO_THROW(engine::to_object(json, mgr));
}

TEST_F(ObjectSerialTest, UsesPositionFromJsonForLocation) {
  Json::Value json = to_json(object_data);
  {
    graphics::object const obj = engine::to_object(json, mgr);
    EXPECT_THAT(obj.location.origin, Eq(math::vec2(0.0f, 0.0f)));
  }
  {
    json["position"][0] = 5.f;
    graphics::object const obj = engine::to_object(json, mgr);
    EXPECT_THAT(obj.location.origin, Eq(math::vec2(5.0f, 0.0f)));
  }
}

TEST_F(ObjectSerialTest, SizeIsTextureSizeTimesScale) {
  Json::Value json = to_json(object_data);
  {
    graphics::object const obj = engine::to_object(json, mgr);
    EXPECT_THAT(obj.location.size, Eq(math::vec2(1.0f, 1.0f)));
  }
  {
    json["scale"] = 0.5f;
    graphics::object const obj = engine::to_object(json, mgr);
    EXPECT_THAT(obj.location.size, Eq(math::vec2(0.5f, 0.5f)));
  }
}

TEST_F(ObjectSerialTest, DefaultFrameIsEntireTex) {
  graphics::object const obj = engine::to_object(to_json(object_data), mgr);
  EXPECT_THAT(obj.frame.size, Eq(math::vec2(1.f, 1.f)));
}

TEST_F(ObjectSerialTest, OverridesFrameSize) {
  Json::Value json = to_json(object_data);
  json["frameSize"][0] = 0.125f;
  json["frameSize"][1] = 0.125f;
  graphics::object const obj = engine::to_object(json, mgr);
  EXPECT_THAT(obj.frame.size, Eq(math::vec2(0.125f, 0.125f)));
}