#include "pch.h"
#include "../../Vav2Player/src/Logger/ILogManager.h"
#include "../../Vav2Player/src/Logger/LogManager.h"
#include "MockLogManager.h"

using namespace Microsoft::VisualStudio::CppUnitTestFramework;
using namespace Vav2Player;

namespace Vav2PlayerUnitTests
{
    TEST_CLASS(LogManagerTest)
    {
    public:
        TEST_METHOD_INITIALIZE(SetUp)
        {
            // Reset LogManagerProvider to default state before each test
            LogManagerProvider::ResetToDefault();
        }

        TEST_METHOD_CLEANUP(TearDown)
        {
            // Clean up after each test
            LogManagerProvider::ResetToDefault();
        }

        TEST_METHOD(LogManagerProvider_DefaultInstance_ShouldReturnSingleton)
        {
            // Act
            ILogManager& instance1 = LogManagerProvider::GetInstance();
            ILogManager& instance2 = LogManagerProvider::GetInstance();

            // Assert
            Assert::IsFalse(LogManagerProvider::IsCustomInstanceSet());
            Assert::IsTrue(&instance1 == &instance2); // Same instance
        }

        TEST_METHOD(LogManagerProvider_CustomInstance_ShouldReturnMockInstance)
        {
            // Arrange
            auto mockLogManager = std::make_shared<MockLogManager>();

            // Act
            LogManagerProvider::SetInstance(mockLogManager);
            ILogManager& instance = LogManagerProvider::GetInstance();

            // Assert
            Assert::IsTrue(LogManagerProvider::IsCustomInstanceSet());
            Assert::IsTrue(static_cast<ILogManager*>(mockLogManager.get()) == &instance);
        }

        TEST_METHOD(MockLogManager_LogInfo_ShouldRecordCall)
        {
            // Arrange
            auto mockLogManager = std::make_shared<MockLogManager>();
            LogManagerProvider::SetInstance(mockLogManager);

            // Act
            LogManagerProvider::GetInstance().LogInfo(L"Test message", L"TestSource");

            // Assert
            Assert::AreEqual(static_cast<size_t>(1), mockLogManager->GetLogCallCount());
            Assert::IsTrue(mockLogManager->WasMethodCalled(L"LogInfo"));
            Assert::IsTrue(mockLogManager->WasMessageLogged(L"Test message"));

            auto lastCall = mockLogManager->GetLastLogCall();
            Assert::AreEqual(static_cast<int>(LogLevel::Info), static_cast<int>(lastCall.level));
            Assert::AreEqual(L"Test message", lastCall.message.c_str());
            Assert::AreEqual(L"TestSource", lastCall.source.c_str());
        }

        TEST_METHOD(MockLogManager_LogVideoLoad_ShouldRecordVideoCall)
        {
            // Arrange
            auto mockLogManager = std::make_shared<MockLogManager>();
            LogManagerProvider::SetInstance(mockLogManager);

            // Act
            LogManagerProvider::GetInstance().LogVideoLoad(L"test_video.mp4", true);

            // Assert
            Assert::AreEqual(static_cast<size_t>(1), mockLogManager->GetLogCallCount());
            Assert::IsTrue(mockLogManager->WasMethodCalled(L"LogVideoLoad"));
            Assert::IsTrue(mockLogManager->WasMessageLogged(L"Successfully loaded"));

            auto videoPlayerCalls = mockLogManager->GetLogCallsFromSource(L"VideoPlayer");
            Assert::AreEqual(static_cast<size_t>(1), videoPlayerCalls.size());
        }

        TEST_METHOD(MockLogManager_MultipleLogCalls_ShouldRecordAll)
        {
            // Arrange
            auto mockLogManager = std::make_shared<MockLogManager>();
            LogManagerProvider::SetInstance(mockLogManager);
            ILogManager& logManager = LogManagerProvider::GetInstance();

            // Act
            logManager.LogDebug(L"Debug message", L"Source1");
            logManager.LogInfo(L"Info message", L"Source2");
            logManager.LogWarning(L"Warning message", L"Source3");
            logManager.LogError(L"Error message", L"Source4");

            // Assert
            Assert::AreEqual(static_cast<size_t>(4), mockLogManager->GetLogCallCount());
            Assert::AreEqual(static_cast<size_t>(1), mockLogManager->GetLogCallCount(LogLevel::Debug));
            Assert::AreEqual(static_cast<size_t>(1), mockLogManager->GetLogCallCount(LogLevel::Info));
            Assert::AreEqual(static_cast<size_t>(1), mockLogManager->GetLogCallCount(LogLevel::Warning));
            Assert::AreEqual(static_cast<size_t>(1), mockLogManager->GetLogCallCount(LogLevel::Error));
        }

        TEST_METHOD(MockLogManager_ResetToDefault_ShouldUseSingleton)
        {
            // Arrange
            auto mockLogManager = std::make_shared<MockLogManager>();
            LogManagerProvider::SetInstance(mockLogManager);
            Assert::IsTrue(LogManagerProvider::IsCustomInstanceSet());

            // Act
            LogManagerProvider::ResetToDefault();

            // Assert
            Assert::IsFalse(LogManagerProvider::IsCustomInstanceSet());

            // Should now use singleton
            ILogManager& instance = LogManagerProvider::GetInstance();
            Assert::IsTrue(static_cast<ILogManager*>(mockLogManager.get()) != &instance);
        }
    };

    /// <summary>
    /// Example of how to test components that use logging
    /// </summary>
    TEST_CLASS(ComponentWithLoggingTest)
    {
    private:
        // Example component that uses logging
        class TestComponent
        {
        public:
            void DoSomething()
            {
                LogManagerProvider::GetInstance().LogInfo(L"DoSomething called", L"TestComponent");

                // Simulate some work
                bool success = ProcessData();

                if (success)
                {
                    LogManagerProvider::GetInstance().LogVideoLoad(L"test.mp4", true);
                }
                else
                {
                    LogManagerProvider::GetInstance().LogError(L"Processing failed", L"TestComponent");
                }
            }

        private:
            bool ProcessData() { return true; } // Always succeed for test
        };

    public:
        TEST_METHOD_INITIALIZE(SetUp)
        {
            LogManagerProvider::ResetToDefault();
        }

        TEST_METHOD_CLEANUP(TearDown)
        {
            LogManagerProvider::ResetToDefault();
        }

        TEST_METHOD(TestComponent_DoSomething_ShouldLogCorrectly)
        {
            // Arrange
            auto mockLogManager = std::make_shared<MockLogManager>();
            LogManagerProvider::SetInstance(mockLogManager);

            TestComponent component;

            // Act
            component.DoSomething();

            // Assert
            Assert::AreEqual(static_cast<size_t>(2), mockLogManager->GetLogCallCount()); // LogInfo + LogVideoLoad
            Assert::IsTrue(mockLogManager->WasMethodCalled(L"LogInfo"));
            Assert::IsTrue(mockLogManager->WasMethodCalled(L"LogVideoLoad"));
            Assert::IsTrue(mockLogManager->WasMessageLogged(L"DoSomething called"));
            Assert::IsTrue(mockLogManager->WasMessageLogged(L"Successfully loaded"));
        }
    };
}