#pragma once

#include <mutex>
#include <condition_variable>

namespace XCEngine {
namespace Threading {

class ReadWriteLock {
public:
    ReadWriteLock() = default;
    ~ReadWriteLock() = default;

    void ReadLock() {
        std::unique_lock<std::mutex> lock(m_mutex);
        m_readCondition.wait(lock, [this] { return !m_writerActive && m_writersWaiting == 0; });
        ++m_readers;
    }

    void ReadUnlock() {
        std::unique_lock<std::mutex> lock(m_mutex);
        --m_readers;
        if (m_readers == 0) {
            m_writeCondition.notify_all();
        }
    }

    void WriteLock() {
        std::unique_lock<std::mutex> lock(m_mutex);
        ++m_writersWaiting;
        m_writeCondition.wait(lock, [this] { return m_readers == 0 && !m_writerActive; });
        --m_writersWaiting;
        m_writerActive = true;
    }

    void WriteUnlock() {
        std::unique_lock<std::mutex> lock(m_mutex);
        m_writerActive = false;
        m_readCondition.notify_all();
        m_writeCondition.notify_one();
    }

private:
    std::mutex m_mutex;
    std::condition_variable m_readCondition;
    std::condition_variable m_writeCondition;
    int32_t m_readers = 0;
    int32_t m_writersWaiting = 0;
    bool m_writerActive = false;
};

} // namespace Threading
} // namespace XCEngine