#include <gtest/gtest.h>

#include <XCEngine/Components/CameraComponent.h>
#include <XCEngine/Components/LightComponent.h>
#include <XCEngine/Resources/BuiltinResources.h>

#include <sstream>

using namespace XCEngine::Components;

namespace {

TEST(CameraComponent_Test, DefaultValues) {
    CameraComponent camera;

    EXPECT_EQ(camera.GetProjectionType(), CameraProjectionType::Perspective);
    EXPECT_FLOAT_EQ(camera.GetFieldOfView(), 60.0f);
    EXPECT_FLOAT_EQ(camera.GetOrthographicSize(), 5.0f);
    EXPECT_FLOAT_EQ(camera.GetNearClipPlane(), 0.1f);
    EXPECT_FLOAT_EQ(camera.GetFarClipPlane(), 1000.0f);
    EXPECT_TRUE(camera.IsPrimary());
    EXPECT_EQ(camera.GetClearMode(), CameraClearMode::Auto);
    EXPECT_EQ(camera.GetStackType(), CameraStackType::Base);
    EXPECT_EQ(camera.GetCullingMask(), 0xFFFFFFFFu);
    EXPECT_FLOAT_EQ(camera.GetViewportRect().x, 0.0f);
    EXPECT_FLOAT_EQ(camera.GetViewportRect().y, 0.0f);
    EXPECT_FLOAT_EQ(camera.GetViewportRect().width, 1.0f);
    EXPECT_FLOAT_EQ(camera.GetViewportRect().height, 1.0f);
    EXPECT_FALSE(camera.IsSkyboxEnabled());
    EXPECT_TRUE(camera.GetSkyboxMaterialPath().empty());
    EXPECT_FALSE(camera.GetSkyboxMaterialAssetRef().IsValid());
    EXPECT_FLOAT_EQ(camera.GetSkyboxTopColor().r, 0.18f);
    EXPECT_FLOAT_EQ(camera.GetSkyboxHorizonColor().g, 0.84f);
    EXPECT_FLOAT_EQ(camera.GetSkyboxBottomColor().b, 0.95f);
    EXPECT_TRUE(camera.GetPostProcessPasses().empty());
    EXPECT_FALSE(camera.IsColorScalePostProcessEnabled());
    EXPECT_FLOAT_EQ(camera.GetColorScalePostProcessScale().x, 1.0f);
    EXPECT_FLOAT_EQ(camera.GetColorScalePostProcessScale().y, 1.0f);
    EXPECT_FLOAT_EQ(camera.GetColorScalePostProcessScale().z, 1.0f);
    EXPECT_FLOAT_EQ(camera.GetColorScalePostProcessScale().w, 1.0f);
    EXPECT_TRUE(camera.GetColorScalePostProcessPasses().empty());
}

TEST(CameraComponent_Test, SetterClamping) {
    CameraComponent camera;

    camera.SetFieldOfView(500.0f);
    camera.SetOrthographicSize(-1.0f);
    camera.SetNearClipPlane(-10.0f);
    camera.SetFarClipPlane(0.0f);

    EXPECT_FLOAT_EQ(camera.GetFieldOfView(), 179.0f);
    EXPECT_FLOAT_EQ(camera.GetOrthographicSize(), 0.001f);
    EXPECT_FLOAT_EQ(camera.GetNearClipPlane(), 0.001f);
    EXPECT_GT(camera.GetFarClipPlane(), camera.GetNearClipPlane());
}

TEST(CameraComponent_Test, ViewportRectIsClampedToNormalizedSurfaceRange) {
    CameraComponent camera;
    camera.SetViewportRect(XCEngine::Math::Rect(-0.25f, 0.2f, 1.5f, 1.1f));

    EXPECT_FLOAT_EQ(camera.GetViewportRect().x, 0.0f);
    EXPECT_FLOAT_EQ(camera.GetViewportRect().y, 0.2f);
    EXPECT_FLOAT_EQ(camera.GetViewportRect().width, 1.0f);
    EXPECT_FLOAT_EQ(camera.GetViewportRect().height, 0.8f);
}

TEST(CameraComponent_Test, SerializeRoundTripPreservesViewportAndClearState) {
    CameraComponent source;
    source.SetClearMode(CameraClearMode::DepthOnly);
    source.SetStackType(CameraStackType::Overlay);
    source.SetCullingMask(0x0000000Fu);
    source.SetViewportRect(XCEngine::Math::Rect(0.25f, 0.125f, 0.5f, 0.625f));
    source.SetSkyboxEnabled(true);
    source.SetSkyboxMaterialPath(XCEngine::Resources::GetBuiltinDefaultPrimitiveMaterialPath().CStr());
    source.SetSkyboxTopColor(XCEngine::Math::Color(0.12f, 0.21f, 0.64f, 1.0f));
    source.SetSkyboxHorizonColor(XCEngine::Math::Color(0.71f, 0.76f, 0.88f, 1.0f));
    source.SetSkyboxBottomColor(XCEngine::Math::Color(0.92f, 0.82f, 0.58f, 1.0f));
    source.SetPostProcessPasses({
        XCEngine::Rendering::CameraPostProcessPassDesc::MakeColorScale(
            XCEngine::Math::Vector4(0.55f, 0.8f, 1.2f, 1.0f)),
        XCEngine::Rendering::CameraPostProcessPassDesc::MakeColorScale(
            XCEngine::Math::Vector4(1.0f, 0.95f, 0.75f, 1.0f))
    });

    std::stringstream stream;
    source.Serialize(stream);

    CameraComponent target;
    target.Deserialize(stream);

    EXPECT_EQ(target.GetClearMode(), CameraClearMode::DepthOnly);
    EXPECT_EQ(target.GetStackType(), CameraStackType::Overlay);
    EXPECT_EQ(target.GetCullingMask(), 0x0000000Fu);
    EXPECT_FLOAT_EQ(target.GetViewportRect().x, 0.25f);
    EXPECT_FLOAT_EQ(target.GetViewportRect().y, 0.125f);
    EXPECT_FLOAT_EQ(target.GetViewportRect().width, 0.5f);
    EXPECT_FLOAT_EQ(target.GetViewportRect().height, 0.625f);
    EXPECT_TRUE(target.IsSkyboxEnabled());
    EXPECT_EQ(target.GetSkyboxMaterialPath(), XCEngine::Resources::GetBuiltinDefaultPrimitiveMaterialPath().CStr());
    EXPECT_FLOAT_EQ(target.GetSkyboxTopColor().b, 0.64f);
    EXPECT_FLOAT_EQ(target.GetSkyboxHorizonColor().g, 0.76f);
    EXPECT_FLOAT_EQ(target.GetSkyboxBottomColor().r, 0.92f);
    ASSERT_EQ(target.GetPostProcessPasses().size(), 2u);
    EXPECT_EQ(
        target.GetPostProcessPasses()[0].type,
        XCEngine::Rendering::CameraPostProcessPassType::ColorScale);
    EXPECT_EQ(
        target.GetPostProcessPasses()[1].type,
        XCEngine::Rendering::CameraPostProcessPassType::ColorScale);
    EXPECT_TRUE(target.IsColorScalePostProcessEnabled());
    EXPECT_FLOAT_EQ(target.GetColorScalePostProcessScale().x, 0.55f);
    EXPECT_FLOAT_EQ(target.GetColorScalePostProcessScale().y, 0.8f);
    EXPECT_FLOAT_EQ(target.GetColorScalePostProcessScale().z, 1.2f);
    EXPECT_FLOAT_EQ(target.GetColorScalePostProcessScale().w, 1.0f);
    ASSERT_EQ(target.GetColorScalePostProcessPasses().size(), 2u);
    EXPECT_FLOAT_EQ(target.GetColorScalePostProcessPasses()[1].x, 1.0f);
    EXPECT_FLOAT_EQ(target.GetColorScalePostProcessPasses()[1].y, 0.95f);
    EXPECT_FLOAT_EQ(target.GetColorScalePostProcessPasses()[1].z, 0.75f);
    EXPECT_FLOAT_EQ(target.GetColorScalePostProcessPasses()[1].w, 1.0f);
}

TEST(CameraComponent_Test, DeserializeLegacyColorScalePostProcessFields) {
    std::stringstream stream;
    stream
        << "colorScalePostProcessEnabled=1;"
        << "colorScalePostProcessScale=0.55,0.8,1.2,1;"
        << "colorScalePostProcessPassCount=2;"
        << "colorScalePostProcessPass0=0.55,0.8,1.2,1;"
        << "colorScalePostProcessPass1=1,0.95,0.75,1;";

    CameraComponent camera;
    camera.Deserialize(stream);

    ASSERT_EQ(camera.GetPostProcessPasses().size(), 2u);
    EXPECT_EQ(
        camera.GetPostProcessPasses()[0].type,
        XCEngine::Rendering::CameraPostProcessPassType::ColorScale);
    EXPECT_TRUE(camera.IsColorScalePostProcessEnabled());
    EXPECT_FLOAT_EQ(camera.GetColorScalePostProcessPasses()[0].x, 0.55f);
    EXPECT_FLOAT_EQ(camera.GetColorScalePostProcessPasses()[1].y, 0.95f);
}

TEST(CameraComponent_Test, LegacyColorScaleAccessorsDriveFirstPass) {
    CameraComponent camera;

    camera.SetColorScalePostProcessScale(XCEngine::Math::Vector4(0.55f, 0.8f, 1.2f, 1.0f));
    EXPECT_FALSE(camera.IsColorScalePostProcessEnabled());

    camera.SetColorScalePostProcessEnabled(true);
    ASSERT_EQ(camera.GetColorScalePostProcessPasses().size(), 1u);
    EXPECT_FLOAT_EQ(camera.GetColorScalePostProcessPasses()[0].x, 0.55f);
    EXPECT_FLOAT_EQ(camera.GetColorScalePostProcessPasses()[0].y, 0.8f);
    EXPECT_FLOAT_EQ(camera.GetColorScalePostProcessPasses()[0].z, 1.2f);
    EXPECT_FLOAT_EQ(camera.GetColorScalePostProcessPasses()[0].w, 1.0f);

    camera.AddColorScalePostProcessPass(XCEngine::Math::Vector4(1.0f, 0.95f, 0.75f, 1.0f));
    camera.SetColorScalePostProcessScale(XCEngine::Math::Vector4(0.6f, 0.7f, 1.1f, 1.0f));

    ASSERT_EQ(camera.GetColorScalePostProcessPasses().size(), 2u);
    EXPECT_FLOAT_EQ(camera.GetColorScalePostProcessPasses()[0].x, 0.6f);
    EXPECT_FLOAT_EQ(camera.GetColorScalePostProcessPasses()[0].y, 0.7f);
    EXPECT_FLOAT_EQ(camera.GetColorScalePostProcessPasses()[0].z, 1.1f);
    EXPECT_FLOAT_EQ(camera.GetColorScalePostProcessPasses()[1].y, 0.95f);
}

TEST(LightComponent_Test, DefaultValues) {
    LightComponent light;

    EXPECT_EQ(light.GetLightType(), LightType::Directional);
    EXPECT_FLOAT_EQ(light.GetIntensity(), 1.0f);
    EXPECT_FLOAT_EQ(light.GetRange(), 10.0f);
    EXPECT_FLOAT_EQ(light.GetSpotAngle(), 30.0f);
    EXPECT_FALSE(light.GetCastsShadows());
}

TEST(LightComponent_Test, SetterClamping) {
    LightComponent light;

    light.SetIntensity(-3.0f);
    light.SetRange(-1.0f);
    light.SetSpotAngle(500.0f);

    EXPECT_FLOAT_EQ(light.GetIntensity(), 0.0f);
    EXPECT_FLOAT_EQ(light.GetRange(), 0.001f);
    EXPECT_FLOAT_EQ(light.GetSpotAngle(), 179.0f);
}

} // namespace