#include <gtest/gtest.h>
#include <XCEngine/Resources/Material/Material.h>
#include <XCEngine/Resources/Shader/Shader.h>
#include <XCEngine/Resources/Texture/Texture.h>
#include <XCEngine/Core/Asset/ResourceTypes.h>
#include <XCEngine/Core/Math/Vector2.h>
#include <XCEngine/Core/Math/Vector3.h>
#include <XCEngine/Core/Math/Vector4.h>

using namespace XCEngine::Resources;
using namespace XCEngine::Math;

namespace {

TEST(Material, DefaultConstructor) {
    Material material;
    EXPECT_EQ(material.GetType(), ResourceType::Material);
    EXPECT_FALSE(material.IsValid());
    EXPECT_EQ(material.GetMemorySize(), 0u);
}

TEST(Material, GetType) {
    Material material;
    EXPECT_EQ(material.GetType(), ResourceType::Material);
}

TEST(Material, SetGetShader) {
    Material material;
    Shader* shader = new Shader();
    
    ResourceHandle<Shader> handle(shader);
    material.SetShader(handle);
    
    EXPECT_EQ(material.GetShader(), shader);
}

TEST(Material, DefaultRenderMetadata) {
    Material material;
    EXPECT_EQ(material.GetRenderQueue(), static_cast<XCEngine::Core::int32>(MaterialRenderQueue::Geometry));
    EXPECT_EQ(material.GetRenderState().cullMode, MaterialCullMode::None);
    EXPECT_FALSE(material.GetRenderState().blendEnable);
    EXPECT_TRUE(material.GetRenderState().depthTestEnable);
    EXPECT_TRUE(material.GetRenderState().depthWriteEnable);
    EXPECT_EQ(material.GetRenderState().depthFunc, MaterialComparisonFunc::Less);
    EXPECT_TRUE(material.GetShaderPass().Empty());
    EXPECT_EQ(material.GetTagCount(), 0u);
}

TEST(Material, SetGetRenderQueue) {
    Material material;

    material.SetRenderQueue(MaterialRenderQueue::Transparent);
    EXPECT_EQ(material.GetRenderQueue(), static_cast<XCEngine::Core::int32>(MaterialRenderQueue::Transparent));

    material.SetRenderQueue(2600);
    EXPECT_EQ(material.GetRenderQueue(), 2600);
}

TEST(Material, SetGetRenderState) {
    Material material;

    MaterialRenderState renderState;
    renderState.cullMode = MaterialCullMode::Back;
    renderState.blendEnable = true;
    renderState.srcBlend = MaterialBlendFactor::SrcAlpha;
    renderState.dstBlend = MaterialBlendFactor::InvSrcAlpha;
    renderState.srcBlendAlpha = MaterialBlendFactor::One;
    renderState.dstBlendAlpha = MaterialBlendFactor::InvSrcAlpha;
    renderState.blendOp = MaterialBlendOp::Add;
    renderState.blendOpAlpha = MaterialBlendOp::Add;
    renderState.depthTestEnable = true;
    renderState.depthWriteEnable = false;
    renderState.depthFunc = MaterialComparisonFunc::LessEqual;
    renderState.colorWriteMask = 0x7;

    material.SetRenderState(renderState);

    const MaterialRenderState& result = material.GetRenderState();
    EXPECT_EQ(result.cullMode, MaterialCullMode::Back);
    EXPECT_TRUE(result.blendEnable);
    EXPECT_EQ(result.srcBlend, MaterialBlendFactor::SrcAlpha);
    EXPECT_EQ(result.dstBlend, MaterialBlendFactor::InvSrcAlpha);
    EXPECT_EQ(result.srcBlendAlpha, MaterialBlendFactor::One);
    EXPECT_EQ(result.dstBlendAlpha, MaterialBlendFactor::InvSrcAlpha);
    EXPECT_EQ(result.blendOp, MaterialBlendOp::Add);
    EXPECT_EQ(result.blendOpAlpha, MaterialBlendOp::Add);
    EXPECT_TRUE(result.depthTestEnable);
    EXPECT_FALSE(result.depthWriteEnable);
    EXPECT_EQ(result.depthFunc, MaterialComparisonFunc::LessEqual);
    EXPECT_EQ(result.colorWriteMask, 0x7);
}

TEST(Material, SetGetShaderPass) {
    Material material;

    material.SetShaderPass("ForwardLit");
    EXPECT_EQ(material.GetShaderPass(), "ForwardLit");
}

TEST(Material, SetGetTags) {
    Material material;

    material.SetTag("LightMode", "ForwardBase");
    material.SetTag("RenderType", "Opaque");

    EXPECT_TRUE(material.HasTag("LightMode"));
    EXPECT_EQ(material.GetTag("LightMode"), "ForwardBase");
    EXPECT_EQ(material.GetTag("RenderType"), "Opaque");
    EXPECT_EQ(material.GetTagCount(), 2u);
}

TEST(Material, SetTagReplacesExistingValue) {
    Material material;

    material.SetTag("LightMode", "ForwardBase");
    material.SetTag("LightMode", "ShadowCaster");

    EXPECT_EQ(material.GetTagCount(), 1u);
    EXPECT_EQ(material.GetTag("LightMode"), "ShadowCaster");
}

TEST(Material, RemoveTag) {
    Material material;

    material.SetTag("LightMode", "ForwardBase");
    EXPECT_TRUE(material.HasTag("LightMode"));

    material.RemoveTag("LightMode");
    EXPECT_FALSE(material.HasTag("LightMode"));
    EXPECT_TRUE(material.GetTag("LightMode").Empty());
}

TEST(Material, ClearTags) {
    Material material;

    material.SetTag("LightMode", "ForwardBase");
    material.SetTag("RenderType", "Opaque");
    ASSERT_EQ(material.GetTagCount(), 2u);

    material.ClearTags();
    EXPECT_EQ(material.GetTagCount(), 0u);
    EXPECT_FALSE(material.HasTag("LightMode"));
    EXPECT_FALSE(material.HasTag("RenderType"));
}

TEST(Material, SetGetFloat) {
    Material material;
    
    material.SetFloat("uTime", 1.5f);
    EXPECT_FLOAT_EQ(material.GetFloat("uTime"), 1.5f);
}

TEST(Material, SetGetFloat2) {
    Material material;
    
    Vector2 value(1.0f, 2.0f);
    material.SetFloat2("uUV", value);
    
    Vector2 result = material.GetFloat2("uUV");
    EXPECT_FLOAT_EQ(result.x, 1.0f);
    EXPECT_FLOAT_EQ(result.y, 2.0f);
}

TEST(Material, SetGetFloat3) {
    Material material;
    
    Vector3 value(1.0f, 2.0f, 3.0f);
    material.SetFloat3("uPosition", value);
    
    Vector3 result = material.GetFloat3("uPosition");
    EXPECT_FLOAT_EQ(result.x, 1.0f);
    EXPECT_FLOAT_EQ(result.y, 2.0f);
    EXPECT_FLOAT_EQ(result.z, 3.0f);
}

TEST(Material, SetGetFloat4) {
    Material material;
    
    Vector4 value(1.0f, 2.0f, 3.0f, 4.0f);
    material.SetFloat4("uColor", value);
    
    Vector4 result = material.GetFloat4("uColor");
    EXPECT_FLOAT_EQ(result.x, 1.0f);
    EXPECT_FLOAT_EQ(result.y, 2.0f);
    EXPECT_FLOAT_EQ(result.z, 3.0f);
    EXPECT_FLOAT_EQ(result.w, 4.0f);
}

TEST(Material, SetGetInt) {
    Material material;
    
    material.SetInt("uIndex", 42);
    EXPECT_EQ(material.GetInt("uIndex"), 42);
}

TEST(Material, SetGetBool) {
    Material material;
    
    material.SetBool("uEnabled", true);
    EXPECT_TRUE(material.GetBool("uEnabled"));
    
    material.SetBool("uEnabled", false);
    EXPECT_FALSE(material.GetBool("uEnabled"));
}

TEST(Material, SetGetTexture) {
    Material material;
    Texture* texture = new Texture();
    
    ResourceHandle<Texture> handle(texture);
    material.SetTexture("uDiffuse", handle);
    
    EXPECT_EQ(material.GetTexture("uDiffuse").Get(), texture);
}

TEST(Material, SetTextureReplacesExistingBinding) {
    Material material;
    Texture* firstTexture = new Texture();
    Texture* secondTexture = new Texture();

    material.SetTexture("uDiffuse", ResourceHandle<Texture>(firstTexture));
    material.SetTexture("uDiffuse", ResourceHandle<Texture>(secondTexture));

    EXPECT_EQ(material.GetTextureBindingCount(), 1u);
    EXPECT_EQ(material.GetTexture("uDiffuse").Get(), secondTexture);
}

TEST(Material, HasProperty) {
    Material material;
    
    EXPECT_FALSE(material.HasProperty("uTime"));
    
    material.SetFloat("uTime", 1.0f);
    EXPECT_TRUE(material.HasProperty("uTime"));
}

TEST(Material, RemoveProperty) {
    Material material;
    
    material.SetFloat("uTime", 1.0f);
    EXPECT_TRUE(material.HasProperty("uTime"));
    
    material.RemoveProperty("uTime");
    EXPECT_FALSE(material.HasProperty("uTime"));
}

TEST(Material, ClearAllProperties) {
    Material material;
    
    material.SetFloat("uTime", 1.0f);
    material.SetFloat3("uPosition", Vector3(1.0f, 2.0f, 3.0f));
    material.SetInt("uIndex", 1);
    
    EXPECT_TRUE(material.HasProperty("uTime"));
    EXPECT_TRUE(material.HasProperty("uPosition"));
    EXPECT_TRUE(material.HasProperty("uIndex"));
    
    material.ClearAllProperties();
    
    EXPECT_FALSE(material.HasProperty("uTime"));
    EXPECT_FALSE(material.HasProperty("uPosition"));
    EXPECT_FALSE(material.HasProperty("uIndex"));
}

} // namespace