#ifndef READ_WRITE_MUTEX_HPP
#define READ_WRITE_MUTEX_HPP

//  read_write_mutex.hpp
//
//  (C) Copyright 2005 Anthony Williams 
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)

#include <boost/thread/once.hpp>
#include <boost/detail/interlocked.hpp>
#include <windows.h>

#define BOOST_INTERLOCKED_READ(x) BOOST_INTERLOCKED_COMPARE_EXCHANGE(x,0,0)

namespace boost
{
#define BOOST_RW_MUTEX_INIT {BOOST_ONCE_INIT}

    namespace detail
    {
        class lightweight_mutex
        {
        public:
            long lock_flag;
            void* lock_sem;
            
            void initialize()
            {
                lock_flag=0;
                lock_sem=CreateSemaphore(NULL,0,1,NULL);
            }
            
            ~lightweight_mutex()
            {
                CloseHandle(lock_sem);
            }
            
            void lock()
            {
                while(BOOST_INTERLOCKED_COMPARE_EXCHANGE(&lock_flag,1,0))
                {
                    BOOST_WAIT_FOR_SINGLE_OBJECT(lock_sem,BOOST_INFINITE);
                }
            }

            void unlock()
            {
                BOOST_INTERLOCKED_EXCHANGE(&lock_flag,0);
                ReleaseSemaphore(lock_sem,1,NULL);
            }
        };
    }
    

    class read_write_mutex
    {
        static const long unlocked_state=0;
        static const long reading_state=1;
        static const long writing_state=2;
        static const long upgrading_state=3;
        static const long reading_with_upgradeable_state=4;
        static const long acquiring_reading_state=5;
        static const long releasing_reading_state=6;
        static const long releasing_reading_with_upgradeable_state=7;
    public:
        boost::once_flag flag;
        detail::lightweight_mutex active_pending;
        detail::lightweight_mutex state_change_gate;
        long mutex_state_flag;
        void* mutex_state_sem;
        long reader_count;
        long waiting_count;

    private:
        
        struct initializer
        {
            read_write_mutex* self;
            
            initializer(read_write_mutex* self_):
                self(self_)
            {}
            void operator()()
            {
                self->active_pending.initialize();
                self->state_change_gate.initialize();
                self->mutex_state_sem=CreateSemaphore(NULL,0,LONG_MAX,NULL);
                self->reader_count=0;
                self->mutex_state_flag=unlocked_state;
                self->waiting_count=0;
            }
        };
        
        void initialize()
        {
            boost::call_once(initializer(this),flag);
        }

        void release_mutex_state_sem()
        {
            state_change_gate.lock();
            long const count_to_unlock=BOOST_INTERLOCKED_READ(&waiting_count);
            if(count_to_unlock)
            {
                ReleaseSemaphore(mutex_state_sem,count_to_unlock,NULL);
            }
            else
            {
                state_change_gate.unlock();
            }
        }

        void acquire_mutex_state_sem()
        {
            long const waiter_count=BOOST_INTERLOCKED_INCREMENT(&waiting_count);
            state_change_gate.unlock();
            BOOST_WAIT_FOR_SINGLE_OBJECT(mutex_state_sem,BOOST_INFINITE);
            long const remaining_waiters=BOOST_INTERLOCKED_DECREMENT(&waiting_count);
            if(!remaining_waiters)
            {
                state_change_gate.unlock();
            }
        }

        template<unsigned array_size>
        long enter_new_state(long const (&old_states)[array_size],long new_state)
        {
            bool blocked=false;
            while(true)
            {
                if(blocked)
                {
                    state_change_gate.lock();
                }
                
                for(unsigned i=0;i<array_size;++i)
                {
                    if(BOOST_INTERLOCKED_COMPARE_EXCHANGE(&mutex_state_flag,new_state,old_states[i])==old_states[i])
                    {
                        if(blocked)
                        {
                            state_change_gate.unlock();
                        }
                        return old_states[i];
                    }
                }
                if(blocked)
                {
                    acquire_mutex_state_sem();
                }
                else
                {
                    blocked=true;
                }
            }
        }

        void enter_new_state(long old_state,long new_state)
        {
            long const old_states[]={
                old_state
            };
            enter_new_state(old_states,new_state);
        }

        void acquire_active_pending()
        {
            active_pending.lock();
        }

        void lock_acquired()
        {
            active_pending.unlock();
        }

    public:

        ~read_write_mutex()
        {
            BOOST_CLOSE_HANDLE(mutex_state_sem);
        }
        
        void acquire_read_lock()
        {
            initialize();
            acquire_active_pending();

            long const old_states[]={
                unlocked_state,reading_state,reading_with_upgradeable_state
            };
            
            long const previous_state=enter_new_state(old_states,acquiring_reading_state);
            BOOST_INTERLOCKED_INCREMENT(&reader_count);
            long const new_state=(previous_state==reading_with_upgradeable_state)?
                reading_with_upgradeable_state:reading_state;
            BOOST_INTERLOCKED_EXCHANGE(&mutex_state_flag,new_state);
            release_mutex_state_sem();
            lock_acquired();
        }

        void release_read_lock()
        {
            long const old_states[]={
                reading_state,reading_with_upgradeable_state
            };
            long const previous_state=enter_new_state(old_states,releasing_reading_state);
            bool const last_reader=!BOOST_INTERLOCKED_DECREMENT(&reader_count);
            long const new_state=(previous_state==reading_with_upgradeable_state)?
                reading_with_upgradeable_state:
                (last_reader?unlocked_state:reading_state);
            BOOST_INTERLOCKED_EXCHANGE(&mutex_state_flag,new_state);
            release_mutex_state_sem();
        }

        void acquire_write_lock()
        {
            initialize();
            acquire_active_pending();
            enter_new_state(unlocked_state,writing_state);
            lock_acquired();
        }
        
        void release_write_lock()
        {
            enter_new_state(writing_state,unlocked_state);
            release_mutex_state_sem();
        }

        void acquire_upgradeable_lock()
        {
            initialize();
            acquire_active_pending();
            long const old_states[]={
                unlocked_state,reading_state
            };
            enter_new_state(old_states,reading_with_upgradeable_state);
            release_mutex_state_sem();
            lock_acquired();
        }
        
        void release_upgradeable_lock()
        {
            enter_new_state(reading_with_upgradeable_state,releasing_reading_with_upgradeable_state);
            long const new_state=BOOST_INTERLOCKED_READ(&reader_count)?reading_state:unlocked_state;
            BOOST_INTERLOCKED_EXCHANGE(&mutex_state_flag,new_state);
            release_mutex_state_sem();
        }

        void upgrade_upgradeable_lock()
        {
            bool acquired=false;
            while(!acquired)
            {
                enter_new_state(reading_with_upgradeable_state,upgrading_state);
                acquired=!BOOST_INTERLOCKED_READ(&reader_count);
                long const new_state=acquired?writing_state:reading_with_upgradeable_state;
                BOOST_INTERLOCKED_EXCHANGE(&mutex_state_flag,new_state);
                if(!acquired)
                {
                    release_mutex_state_sem();
                }
            }
        }
    };

    class read_lock
    {
        read_write_mutex& mutex;
    public:
        read_lock(read_write_mutex& mutex_):
            mutex(mutex_)
        {
            mutex.acquire_read_lock();
        }
        ~read_lock()
        {
            mutex.release_read_lock();
        }
    };

    class upgradeable_lock
    {
        friend class write_lock;
        read_write_mutex& mutex;
        bool upgraded;
    public:
        upgradeable_lock(read_write_mutex& mutex_):
            mutex(mutex_),upgraded(false)
        {
            mutex.acquire_upgradeable_lock();
        }
        ~upgradeable_lock()
        {
            if(!upgraded)
            {
                mutex.release_upgradeable_lock();
            }
        }
    };
    
    class write_lock
    {
        read_write_mutex& mutex;
    public:
        write_lock(read_write_mutex& mutex_):
            mutex(mutex_)
        {
            mutex.acquire_write_lock();
        }
        write_lock(upgradeable_lock& upgradeable):
            mutex(upgradeable.mutex)
        {
            mutex.upgrade_upgradeable_lock();
            upgradeable.upgraded=true;
        }
        ~write_lock()
        {
            mutex.release_write_lock();
        }
    };
   
}

#endif