#include "pch.h"
#include "MockVideoRenderer.h"

using namespace Microsoft::VisualStudio::CppUnitTestFramework;
using namespace Vav2PlayerUnitTests;

namespace Vav2PlayerUnitTests
{
    TEST_CLASS(VideoRendererTest)
    {
    public:
        TEST_METHOD(MockVideoRenderer_Initialize_Success_ShouldReturnSOK)
        {
            // Arrange
            MockVideoRenderer mockRenderer;

            // Act
            HRESULT result = mockRenderer.Initialize(1920, 1080);

            // Assert
            Assert::AreEqual(S_OK, result);
            Assert::IsTrue(mockRenderer.IsInitialized());
            Assert::AreEqual(1920u, mockRenderer.GetWidth());
            Assert::AreEqual(1080u, mockRenderer.GetHeight());
            Assert::AreEqual(1u, mockRenderer.GetInitializeCallCount());
        }

        TEST_METHOD(MockVideoRenderer_Initialize_Failure_ShouldReturnError)
        {
            // Arrange
            MockVideoRenderer mockRenderer;
            mockRenderer.SetInitializeResult(E_FAIL);

            // Act
            HRESULT result = mockRenderer.Initialize(1920, 1080);

            // Assert
            Assert::AreEqual(E_FAIL, result);
            Assert::IsFalse(mockRenderer.IsInitialized());
        }

        TEST_METHOD(MockVideoRenderer_RenderVideoFrame_WhenInitialized_ShouldSucceed)
        {
            // Arrange
            MockVideoRenderer mockRenderer;
            mockRenderer.Initialize(1920, 1080);

            VideoFrame testFrame;
            testFrame.width = 1920;
            testFrame.height = 1080;
            testFrame.format = PixelFormat::YUV420P;
            testFrame.frame_index = 0;
            testFrame.timestamp_ns = 0;

            // Create test YUV data
            testFrame.y_stride = 1920;
            testFrame.u_stride = 960;
            testFrame.v_stride = 960;

            size_t y_size = testFrame.y_stride * testFrame.height;
            size_t uv_size = testFrame.u_stride * (testFrame.height / 2);

            testFrame.y_plane = std::make_unique<uint8_t[]>(y_size);
            testFrame.u_plane = std::make_unique<uint8_t[]>(uv_size);
            testFrame.v_plane = std::make_unique<uint8_t[]>(uv_size);

            // Fill with test pattern
            std::memset(testFrame.y_plane.get(), 128, y_size);
            std::memset(testFrame.u_plane.get(), 64, uv_size);
            std::memset(testFrame.v_plane.get(), 192, uv_size);

            // Act
            HRESULT result = mockRenderer.RenderVideoFrame(testFrame);

            // Assert
            Assert::AreEqual(S_OK, result);
            Assert::AreEqual(1u, mockRenderer.GetRenderFrameCallCount());
            Assert::AreEqual(1u, mockRenderer.GetTotalRenderedFrames());

            const auto& renderedFrames = mockRenderer.GetRenderedFrames();
            Assert::AreEqual(1u, static_cast<uint32_t>(renderedFrames.size()));
            Assert::AreEqual(1920u, renderedFrames[0].width);
            Assert::AreEqual(1080u, renderedFrames[0].height);
        }

        TEST_METHOD(MockVideoRenderer_TryRenderFrame_WhenInitialized_ShouldReturnTrue)
        {
            // Arrange
            MockVideoRenderer mockRenderer;
            mockRenderer.Initialize(1920, 1080);

            VideoFrame testFrame;
            testFrame.width = 1920;
            testFrame.height = 1080;
            testFrame.format = PixelFormat::YUV420P;

            // Act
            bool result = mockRenderer.TryRenderFrame(testFrame);

            // Assert
            Assert::IsTrue(result);
            Assert::AreEqual(1u, mockRenderer.GetTryRenderFrameCallCount());
        }

        TEST_METHOD(MockVideoRenderer_TryRenderFrame_WhenNotInitialized_ShouldReturnFalse)
        {
            // Arrange
            MockVideoRenderer mockRenderer;

            VideoFrame testFrame;
            testFrame.width = 1920;
            testFrame.height = 1080;

            // Act
            bool result = mockRenderer.TryRenderFrame(testFrame);

            // Assert
            Assert::IsFalse(result);
        }

        TEST_METHOD(MockVideoRenderer_Present_WhenInitialized_ShouldReturnSOK)
        {
            // Arrange
            MockVideoRenderer mockRenderer;
            mockRenderer.Initialize(1920, 1080);

            // Act
            HRESULT result = mockRenderer.Present();

            // Assert
            Assert::AreEqual(S_OK, result);
            Assert::AreEqual(1u, mockRenderer.GetPresentCallCount());
        }

        TEST_METHOD(MockVideoRenderer_Resize_ValidSize_ShouldUpdateDimensions)
        {
            // Arrange
            MockVideoRenderer mockRenderer;
            mockRenderer.Initialize(1920, 1080);

            // Act
            HRESULT result = mockRenderer.Resize(3840, 2160);

            // Assert
            Assert::AreEqual(S_OK, result);
            Assert::AreEqual(3840u, mockRenderer.GetWidth());
            Assert::AreEqual(2160u, mockRenderer.GetHeight());
            Assert::AreEqual(1u, mockRenderer.GetResizeCallCount());
        }

        TEST_METHOD(MockVideoRenderer_Shutdown_ShouldResetState)
        {
            // Arrange
            MockVideoRenderer mockRenderer;
            mockRenderer.Initialize(1920, 1080);

            VideoFrame testFrame;
            testFrame.width = 1920;
            testFrame.height = 1080;
            mockRenderer.RenderVideoFrame(testFrame);

            // Act
            mockRenderer.Shutdown();

            // Assert
            Assert::IsFalse(mockRenderer.IsInitialized());
            Assert::AreEqual(0u, mockRenderer.GetWidth());
            Assert::AreEqual(0u, mockRenderer.GetHeight());
            Assert::AreEqual(0u, mockRenderer.GetTotalRenderedFrames());
        }

        TEST_METHOD(MockVideoRenderer_SetAspectFitMode_ShouldUpdateState)
        {
            // Arrange
            MockVideoRenderer mockRenderer;

            // Act
            mockRenderer.SetAspectFitMode(true);

            // Assert
            Assert::IsTrue(mockRenderer.GetAspectFitMode());

            // Act
            mockRenderer.SetAspectFitMode(false);

            // Assert
            Assert::IsFalse(mockRenderer.GetAspectFitMode());
        }

        TEST_METHOD(MockVideoRenderer_UpdateContainerSize_ShouldUpdateDimensions)
        {
            // Arrange
            MockVideoRenderer mockRenderer;

            // Act
            mockRenderer.UpdateContainerSize(1280, 720);

            // Assert
            Assert::AreEqual(1280u, mockRenderer.GetContainerWidth());
            Assert::AreEqual(720u, mockRenderer.GetContainerHeight());
        }

        TEST_METHOD(MockVideoRenderer_SimulateFailures_ShouldBehaveCorrectly)
        {
            // Arrange
            MockVideoRenderer mockRenderer;

            // Test initialization failure
            mockRenderer.SimulateInitializationFailure(true);
            HRESULT initResult = mockRenderer.Initialize(1920, 1080);
            Assert::AreEqual(E_FAIL, initResult);
            Assert::IsFalse(mockRenderer.IsInitialized());

            // Reset and test rendering failure
            mockRenderer.SimulateInitializationFailure(false);
            mockRenderer.Initialize(1920, 1080);

            mockRenderer.SimulateRenderingFailure(true);

            VideoFrame testFrame;
            testFrame.width = 1920;
            testFrame.height = 1080;

            // Act
            HRESULT renderResult = mockRenderer.RenderVideoFrame(testFrame);
            bool tryRenderResult = mockRenderer.TryRenderFrame(testFrame);

            // Assert
            Assert::AreEqual(E_FAIL, renderResult);
            Assert::IsFalse(tryRenderResult);
        }

        TEST_METHOD(MockVideoRenderer_PerformanceSimulation_ShouldTrackTime)
        {
            // Arrange
            MockVideoRenderer mockRenderer;
            mockRenderer.Initialize(1920, 1080);
            mockRenderer.SetRenderDelay(10); // 10ms delay

            VideoFrame testFrame;
            testFrame.width = 1920;
            testFrame.height = 1080;

            // Act
            auto startTime = std::chrono::high_resolution_clock::now();
            mockRenderer.RenderVideoFrame(testFrame);
            auto endTime = std::chrono::high_resolution_clock::now();

            auto actualDuration = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);

            // Assert
            Assert::IsTrue(actualDuration.count() >= 10); // Should take at least 10ms
            Assert::IsTrue(mockRenderer.GetTotalRenderTime() >= 10); // Should track the time
        }

        TEST_METHOD(MockVideoRenderer_MultipleFrames_ShouldTrackAll)
        {
            // Arrange
            MockVideoRenderer mockRenderer;
            mockRenderer.Initialize(1920, 1080);

            // Act - Render 5 frames
            for (uint32_t i = 0; i < 5; ++i) {
                VideoFrame testFrame;
                testFrame.width = 1920;
                testFrame.height = 1080;
                testFrame.frame_index = i;
                testFrame.timestamp_ns = i * 33333333; // ~30fps

                mockRenderer.RenderVideoFrame(testFrame);
            }

            // Assert
            Assert::AreEqual(5u, mockRenderer.GetRenderFrameCallCount());
            Assert::AreEqual(5u, mockRenderer.GetTotalRenderedFrames());

            const auto& renderedFrames = mockRenderer.GetRenderedFrames();
            Assert::AreEqual(5u, static_cast<uint32_t>(renderedFrames.size()));

            // Verify frame indices are correct
            for (uint32_t i = 0; i < 5; ++i) {
                Assert::AreEqual(static_cast<uint64_t>(i), renderedFrames[i].frame_index);
            }
        }
    };
}