#include "pch.h"
#include "MockWebMFileReader.h"
#include "../../VavCore/src/Decoder/AV1Decoder.h"
#include "../../VavCore/src/Decoder/VideoDecoderFactory.h"

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

namespace Vav2PlayerUnitTests
{
    TEST_CLASS(AV1DecoderTest)
    {
    public:
        TEST_METHOD(AV1Decoder_Initialize_ValidMetadata_ShouldReturnTrue)
        {
            // Arrange
            auto decoder = VideoDecoderFactory::CreateDecoder(VideoCodecType::AV1, VideoDecoderFactory::DecoderType::DAV1D);

            VideoMetadata metadata;
            metadata.width = 1920;
            metadata.height = 1080;
            metadata.codec_type = VideoCodecType::AV1;
            metadata.frame_rate = 30.0;

            // Act
            bool result = decoder->Initialize(metadata);

            // Assert
            Assert::IsTrue(result);
            Assert::IsTrue(decoder->IsInitialized());
        }

        TEST_METHOD(AV1Decoder_Initialize_InvalidMetadata_ShouldReturnFalse)
        {
            // Arrange
            auto decoder = VideoDecoderFactory::CreateDecoder(VideoCodecType::AV1, VideoDecoderFactory::DecoderType::DAV1D);

            VideoMetadata metadata;
            metadata.width = 0; // Invalid width
            metadata.height = 1080;
            metadata.codec_type = VideoCodecType::AV1;

            // Act
            bool result = decoder->Initialize(metadata);

            // Assert
            Assert::IsFalse(result);
            Assert::IsFalse(decoder->IsInitialized());
        }

        TEST_METHOD(VideoDecoderFactory_CreateAV1Decoder_ShouldReturnValidDecoder)
        {
            // Act
            auto decoder = VideoDecoderFactory::CreateDecoder(VideoCodecType::AV1, VideoDecoderFactory::DecoderType::DAV1D);

            // Assert
            Assert::IsNotNull(decoder.get());
            Assert::IsFalse(decoder->IsInitialized()); // Should not be initialized until Initialize() is called
        }

        TEST_METHOD(VideoDecoderFactory_CreateAutoDecoder_ShouldReturnValidDecoder)
        {
            // Act
            auto decoder = VideoDecoderFactory::CreateDecoder(VideoCodecType::AV1, VideoDecoderFactory::DecoderType::AUTO);

            // Assert
            Assert::IsNotNull(decoder.get());
            Assert::IsFalse(decoder->IsInitialized());
        }

        TEST_METHOD(AV1Decoder_Reset_AfterInitialization_ShouldSucceed)
        {
            // Arrange
            auto decoder = VideoDecoderFactory::CreateDecoder(VideoCodecType::AV1, VideoDecoderFactory::DecoderType::DAV1D);

            VideoMetadata metadata;
            metadata.width = 1920;
            metadata.height = 1080;
            metadata.codec_type = VideoCodecType::AV1;
            metadata.frame_rate = 30.0;

            decoder->Initialize(metadata);

            // Act
            bool result = decoder->Reset();

            // Assert
            Assert::IsTrue(result);
            Assert::IsTrue(decoder->IsInitialized()); // Should remain initialized after reset
        }

        TEST_METHOD(AV1Decoder_Cleanup_ShouldSetNotInitialized)
        {
            // Arrange
            auto decoder = VideoDecoderFactory::CreateDecoder(VideoCodecType::AV1, VideoDecoderFactory::DecoderType::DAV1D);

            VideoMetadata metadata;
            metadata.width = 1920;
            metadata.height = 1080;
            metadata.codec_type = VideoCodecType::AV1;
            metadata.frame_rate = 30.0;

            decoder->Initialize(metadata);
            Assert::IsTrue(decoder->IsInitialized());

            // Act
            decoder->Cleanup();

            // Assert
            Assert::IsFalse(decoder->IsInitialized());
        }

        // Note: GetSupportedFormats and GetAvailableDecoders methods don't exist yet
        // Commenting out until these methods are implemented
        /*
        TEST_METHOD(AV1Decoder_GetSupportedFormats_ShouldReturnAV1)
        {
            // Arrange
            auto decoder = VideoDecoderFactory::CreateDecoder(VideoCodecType::AV1, VideoDecoderFactory::DecoderType::DAV1D);

            // Act
            auto formats = decoder->GetSupportedFormats();

            // Assert
            Assert::IsTrue(formats.size() > 0);

            // Check if AV1 is in the supported formats
            bool foundAV1 = false;
            for (const auto& format : formats) {
                if (format == VideoCodecType::AV1) {
                    foundAV1 = true;
                    break;
                }
            }
            Assert::IsTrue(foundAV1);
        }

        TEST_METHOD(VideoDecoderFactory_GetAvailableDecoders_ShouldIncludeAV1)
        {
            // Act
            auto decoders = VideoDecoderFactory::GetAvailableDecoders();

            // Assert
            Assert::IsTrue(decoders.size() > 0);

            // Check if AV1 decoder info is present
            bool foundAV1 = false;
            for (const auto& decoderInfo : decoders) {
                if (decoderInfo.codec_type == VideoCodecType::AV1) {
                    foundAV1 = true;
                    Assert::IsFalse(decoderInfo.name.empty());
                    break;
                }
            }
            Assert::IsTrue(foundAV1);
        }
        */

        TEST_METHOD(AV1Decoder_HardwareDecoder_CreationTest)
        {
            // Act - Try to create hardware decoder (may fail on systems without hardware support)
            auto decoder = VideoDecoderFactory::CreateDecoder(VideoCodecType::AV1, VideoDecoderFactory::DecoderType::MEDIA_FOUNDATION);

            // Assert - Should either succeed or return nullptr (graceful failure)
            // This test mainly verifies that factory doesn't crash
            if (decoder) {
                // If hardware decoder is available, test basic functionality
                VideoMetadata metadata;
                metadata.width = 1920;
                metadata.height = 1080;
                metadata.codec_type = VideoCodecType::AV1;
                metadata.frame_rate = 30.0;

                // Hardware decoder may fail initialization on systems without support
                // This is expected behavior, not a test failure
                decoder->Initialize(metadata);
            }

            // Test passes if we reach here without crashing
            Assert::IsTrue(true);
        }

        TEST_METHOD(AV1Decoder_Integration_WithMockReader)
        {
            // Arrange
            MockWebMFileReader mockReader;
            auto decoder = VideoDecoderFactory::CreateDecoder(VideoCodecType::AV1, VideoDecoderFactory::DecoderType::DAV1D);

            mockReader.OpenFile("test.webm");
            mockReader.SelectVideoTrack(1);

            const auto& metadata = mockReader.GetVideoMetadata();
            decoder->Initialize(metadata);

            // Act - Try to decode first packet
            VideoPacket packet;
            bool readResult = mockReader.ReadNextPacket(packet);

            VideoFrame frame;
            bool decodeResult = false;
            if (readResult && packet.data && packet.size > 0) {
                // Note: This will likely fail with mock data since it's not real AV1
                // But the test verifies the integration doesn't crash
                decodeResult = decoder->DecodeFrame(packet, frame);
            }

            // Assert
            Assert::IsTrue(readResult); // Mock reader should succeed
            Assert::IsTrue(decoder->IsInitialized());
            // decodeResult may be false since mock data isn't real AV1 - this is expected
        }
    };
}