#pragma once
#include "../../Vav2Player/src/Logger/ILogManager.h"
#include "../../Vav2Player/src/Logger/LogManager.h"
#include <vector>
#include <string>
#include <algorithm>

namespace Vav2Player {

/// <summary>
/// Mock implementation of ILogManager for unit testing
/// Records all log calls and provides verification methods
/// </summary>
class MockLogManager : public ILogManager {
public:
    struct LogCall {
        LogLevel level;
        std::wstring message;
        std::wstring source;
        std::wstring methodName; // Which method was called (LogInfo, LogVideoLoad, etc.)
    };

    MockLogManager() : m_currentLogLevel(LogLevel::Info) {}

    // ILogManager implementation
    void AddLogMessage(LogLevel level, const std::wstring& message, const std::wstring& source = L"") override {
        m_logCalls.push_back({level, message, source, L"AddLogMessage"});

        auto logMessage = std::make_shared<LogMessage>(level, message, source);
        m_logMessages.push_back(logMessage);

        if (m_logAddedCallback) {
            m_logAddedCallback(*logMessage);
        }
    }

    void LogDebug(const std::wstring& message, const std::wstring& source = L"") override {
        m_logCalls.push_back({LogLevel::Debug, message, source, L"LogDebug"});
        AddLogMessage(LogLevel::Debug, message, source);
    }

    void LogInfo(const std::wstring& message, const std::wstring& source = L"") override {
        m_logCalls.push_back({LogLevel::Info, message, source, L"LogInfo"});
        AddLogMessage(LogLevel::Info, message, source);
    }

    void LogWarning(const std::wstring& message, const std::wstring& source = L"") override {
        m_logCalls.push_back({LogLevel::Warning, message, source, L"LogWarning"});
        AddLogMessage(LogLevel::Warning, message, source);
    }

    void LogError(const std::wstring& message, const std::wstring& source = L"") override {
        m_logCalls.push_back({LogLevel::Error, message, source, L"LogError"});
        AddLogMessage(LogLevel::Error, message, source);
    }

    void LogVideoLoad(const std::wstring& filename, bool success = true) override {
        std::wstring message = success ? L"Successfully loaded: " + filename : L"Failed to load: " + filename;
        LogLevel level = success ? LogLevel::Info : LogLevel::Error;
        m_logCalls.push_back({level, message, L"VideoPlayer", L"LogVideoLoad"});
        AddLogMessage(level, message, L"VideoPlayer");
    }

    void LogVideoPlay(const std::wstring& filename) override {
        std::wstring message = L"Playing: " + filename;
        m_logCalls.push_back({LogLevel::Info, message, L"VideoPlayer", L"LogVideoPlay"});
        AddLogMessage(LogLevel::Info, message, L"VideoPlayer");
    }

    void LogVideoPause(const std::wstring& filename) override {
        std::wstring message = L"Paused: " + filename;
        m_logCalls.push_back({LogLevel::Info, message, L"VideoPlayer", L"LogVideoPause"});
        AddLogMessage(LogLevel::Info, message, L"VideoPlayer");
    }

    void LogVideoStop(const std::wstring& filename) override {
        std::wstring message = L"Stopped: " + filename;
        m_logCalls.push_back({LogLevel::Info, message, L"VideoPlayer", L"LogVideoStop"});
        AddLogMessage(LogLevel::Info, message, L"VideoPlayer");
    }

    void LogVideoError(const std::wstring& error, const std::wstring& filename = L"") override {
        std::wstring message = filename.empty() ? L"Video error: " + error : L"Video error in " + filename + L": " + error;
        m_logCalls.push_back({LogLevel::Error, message, L"VideoPlayer", L"LogVideoError"});
        AddLogMessage(LogLevel::Error, message, L"VideoPlayer");
    }

    void LogFrameInfo(int currentFrame, int totalFrames, double fps) override {
        std::wstring message = L"Frame " + std::to_wstring(currentFrame) + L"/" + std::to_wstring(totalFrames);
        if (fps > 0.0) {
            message += L" @ " + std::to_wstring(static_cast<int>(fps)) + L" FPS";
        }
        m_logCalls.push_back({LogLevel::Debug, message, L"Decoder", L"LogFrameInfo"});
        AddLogMessage(LogLevel::Debug, message, L"Decoder");
    }

    void LogDecoderInfo(const std::wstring& decoderName, const std::wstring& info) override {
        std::wstring message = L"[" + decoderName + L"] " + info;
        m_logCalls.push_back({LogLevel::Info, message, L"Decoder", L"LogDecoderInfo"});
        AddLogMessage(LogLevel::Info, message, L"Decoder");
    }

    void SetLogLevel(LogLevel level) override {
        m_currentLogLevel = level;
    }

    LogLevel GetLogLevel() const override {
        return m_currentLogLevel;
    }

    const std::vector<std::shared_ptr<LogMessage>>& GetLogMessages() const override {
        return m_logMessages;
    }

    void ClearLogs() override {
        m_logCalls.clear();
        m_logMessages.clear();
    }

    void RegisterLogAddedCallback(LogAddedCallback callback) override {
        m_logAddedCallback = callback;
    }

    void AttachLogOutput(std::unique_ptr<ILogOutput> output) override {
        // Mock implementation - just record the name
        if (output) {
            m_attachedOutputNames.push_back(output->GetName());
        }
    }

    void DetachLogOutput(const std::wstring& outputName) override {
        m_attachedOutputNames.erase(
            std::remove(m_attachedOutputNames.begin(), m_attachedOutputNames.end(), outputName),
            m_attachedOutputNames.end());
    }

    std::vector<std::wstring> GetAttachedOutputNames() const override {
        return m_attachedOutputNames;
    }

    // Testing helper methods
    const std::vector<LogCall>& GetLogCalls() const { return m_logCalls; }

    size_t GetLogCallCount() const { return m_logCalls.size(); }

    size_t GetLogCallCount(LogLevel level) const {
        return std::count_if(m_logCalls.begin(), m_logCalls.end(),
            [level](const LogCall& call) { return call.level == level; });
    }

    size_t GetLogCallCount(const std::wstring& methodName) const {
        return std::count_if(m_logCalls.begin(), m_logCalls.end(),
            [&methodName](const LogCall& call) { return call.methodName == methodName; });
    }

    bool WasMethodCalled(const std::wstring& methodName) const {
        return GetLogCallCount(methodName) > 0;
    }

    bool WasMessageLogged(const std::wstring& message) const {
        return std::any_of(m_logCalls.begin(), m_logCalls.end(),
            [&message](const LogCall& call) { return call.message.find(message) != std::wstring::npos; });
    }

    LogCall GetLastLogCall() const {
        return m_logCalls.empty() ? LogCall{} : m_logCalls.back();
    }

    std::vector<LogCall> GetLogCallsFromSource(const std::wstring& source) const {
        std::vector<LogCall> result;
        std::copy_if(m_logCalls.begin(), m_logCalls.end(), std::back_inserter(result),
            [&source](const LogCall& call) { return call.source == source; });
        return result;
    }

private:
    std::vector<LogCall> m_logCalls;
    std::vector<std::shared_ptr<LogMessage>> m_logMessages;
    std::vector<std::wstring> m_attachedOutputNames;
    LogLevel m_currentLogLevel;
    LogAddedCallback m_logAddedCallback;
};

} // namespace Vav2Player