/*
* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
*
*/

#include <errno.h>

#include "cpixsynctools.h"

namespace Cpt
{



    //
    //
    //  SyncException
    //
    //
    const char * SyncExc::what() const throw()
    {
        return what_.c_str();
    }
    


    SyncExc::SyncExc(const char * format,
                     ...)
    {
        char
            msg[96];

        va_list
            args;
        va_start(args,
                 format);

        vsnprintf(msg,
                  sizeof(msg),
                  format,
                  args);

        va_end(args);

        what_ = msg;
    }



    namespace Impl
    {
        //
        //
        //  SyncRegion_
        //
        //
        void SyncRegion_::lockMutex(pthread_mutex_t * mutex)
        {
            int
                result;

            do {
                result = pthread_mutex_lock(mutex);
            } while (result == ETIMEDOUT);

            if (result != 0)
                {
                    mutex = NULL;

                    throw SyncExc("Could not lock mutex (error: %d)",
                                  result);
                }
        }


        
        void SyncRegion_::lockMutex(pthread_mutex_t * mutex,
                                    Recursive       * recursive)
        {
            if (recursive == NULL)
                {
                    lockMutex(mutex);
                }
            else
                {
                    pthread_t
                        curThread = pthread_self();

                    if (pthread_equal(recursive->lockOwner_, curThread))
                        {
                            ++(recursive->lockCount_);
                        }
                    else
                        {
                            lockMutex(mutex);
                            recursive->lockOwner_ = curThread;
                            recursive->lockCount_ = 1;
                        }
                }
        }
        


        void SyncRegion_::unlockMutex(pthread_mutex_t * mutex)
        {
            if (mutex != NULL)
                {
                    int 
                        result = pthread_mutex_unlock(mutex);
                    if (result != 0)
                        {
                            throw SyncExc("Could not unlock mutex (error: %d)",
                                          result);
                        }
                    mutex = NULL;
                }
        }


        void SyncRegion_::unlockMutex(pthread_mutex_t * mutex,
                                      Recursive       * recursive)
        {
            if (recursive == NULL)
                {
                    unlockMutex(mutex);
                }
            else
                {
                    --(recursive->lockCount_);
                    
                    if (recursive->lockCount_ == 0)
                        {
                            recursive->lockOwner_ = 0;
                            unlockMutex(mutex);
                        }
                }
        }


        void SyncRegion_::initMutex(pthread_mutex_t * mutex)
        {
            int
                result = pthread_mutex_init(mutex,
                                            NULL);
            if (result != 0)
                {
                    throw SyncExc("Could not create mutex (error: %d)",
                                  result);
                }
        }


        void SyncRegion_::destroyMutex(pthread_mutex_t * mutex_)
        {
            if (mutex_ != NULL)
                {
                    int
                        result = 0;

                    do
                        {
                            result = pthread_mutex_destroy(mutex_);
                            switch (result)
                                {
                                case EAGAIN:
                                    // if the mutex is held by another
                                    // thread - we try locking (to
                                    // avoid busy polling) and then
                                    // unlock it immediately
                                    lockMutex(mutex_);
                                    unlockMutex(mutex_);
                                    break;
                                case 0:       // OK
                                    break;
                                case EBUSY:
                                    throw SyncExc("Failed to destroy mutex - still locked by this thread (error: %d, EBUSY)",
                                                  result);
                                   
                                case EINVAL:  // invalid mutex
                                    throw SyncExc("Failed to destroy mutex - invalid (error: %d, EINVAL)",
                                                  result);
                                   
                                default:
                                    throw SyncExc("Failed to destroy mutex (error: %d, unknown reason)",
                                                  result);
                                }
                        } while (result != 0);
                }
        }


        SyncRegion_::SyncRegion_(pthread_mutex_t * mutex)
            : mutex_(mutex),
              recursive_(NULL)
        {
            lockMutex(mutex_);
        }


        SyncRegion_::SyncRegion_(pthread_mutex_t * mutex,
                                 Recursive       * recursive)
            : mutex_(mutex),
              recursive_(recursive)
        {
            lockMutex(mutex_,
                      recursive_);
        }


        SyncRegion_::~SyncRegion_()
        {
            bool
                failed = true;

            try
                {
                    unlockMutex(mutex_,
                                recursive_);
                    failed = false;
                }
            catch (SyncExc & e)
                {
                    printf("PANIC Cpt::Impl::SyncRegion_::~SyncRegion_ : %s\n",
                           e.what());
                    fflush(stdout);
                }

            if (failed)
                {
                    exit(-1);
                }
        }
    }



    
    //
    //
    //  Mutex
    //
    //
    Mutex::Mutex()
        : recursive_(NULL)
    {
        init(false);
    }


    Mutex::Mutex(bool recursive)
        : recursive_(NULL)
    {
        init(recursive);
    }


    Mutex::~Mutex()
    {

        if (recursive_ != NULL)
            {
                delete recursive_;
            }

        bool
            failed = true;

        try
            {
                Impl::SyncRegion_::destroyMutex(&mutex_);
                failed = false;
            }
        catch (SyncExc & e)
            {
                printf("PANIC Cpt::Mutex::~Mutex : %s\n",
                       e.what());
                fflush(stdout);
            }

        if (failed)
            {
                exit(-1);
            }
    }


    // TODO it is unclear if the OpenC layer has bug wrt recursive
    // mutexes - may be better to reimplement them manually here
    void Mutex::init(bool recursive)
    {
        if (recursive)
            {
                recursive_ = new Impl::Recursive;
            }

        Impl::SyncRegion_::initMutex(&mutex_);
    }


    //
    //
    //  SyncEntity
    //
    //
    void SyncEntity::wait()
    {
        int
            result;

        do {
            result = pthread_cond_wait(&cond_, 
                                       &mutex_);
        } while (result == ETIMEDOUT);

        if (result != 0)
            {
                throw SyncExc("Could not wait on cond (error: %d)",
                              result);
            }
    }


    void SyncEntity::signal()
    {
        int
            result = pthread_cond_signal(&cond_);
        if (result != 0)
            {
                throw SyncExc("Could not signal on cond (error: %d)",
                              result);
            }
    }


    void SyncEntity::broadcast()
    {
        int
            result = pthread_cond_broadcast(&cond_);
        if (result != 0)
            {
                throw SyncExc("Could not broadcast on cond (error: %d)",
                              result);
            }
    }


    SyncEntity::SyncEntity()
    {
        int
            result = pthread_cond_init(&cond_,
                                       NULL);
        if (result != 0)
            {
                throw SyncExc("Could not create cond (error: %d)",
                              result);
            }
    }


    SyncEntity::~SyncEntity()
    {
        int
            result = 0;

        { // SYNC
            Impl::SyncRegion_
                syncedRegion(&mutex_);
            
            // we need to wake up all threads waiting on our cond
            // variable cond_
            broadcast();
            
            // all threads waiting on cond_ have been
            // waken and they can't possibly re-enter
            // waiting because they would need the lock on
            // mutex_ which we are holding
            result = pthread_cond_destroy(&cond_);

            if (result != 0)
                {
                    printf("PANIC Cpt::SyncEntity::~SyncEntity (cond): %d\n",
                           result);
                    fflush(stdout);
                    exit(-1);
                }
        } // SYNC
    }


    //
    //
    //  SyncRegion
    //
    //
    SyncRegion::SyncRegion(Mutex & mutex)
        : SyncRegion_(&mutex.mutex_,
                      mutex.recursive_)
    {
        ;
    }


    SyncRegion::SyncRegion(SyncEntity & entity)
        : SyncRegion_(&entity.mutex_)
    {
        ;
    }


    SyncRegion::~SyncRegion()
    {
        ;
    }



    //
    //
    //  MultiSyncRegion
    //
    //
    void MultiSyncRegion::lock(Mutex & mutex)
    {
        throwIfFull();

        new (next_) SyncRegion(mutex);

        ++next_;
    }


    void MultiSyncRegion::lock(SyncEntity & syncEntity)
    {
        throwIfFull();

        new (next_) SyncRegion(syncEntity);

        ++next_;
    }


    MultiSyncRegion::MultiSyncRegion(size_t maxSize)
        : maxSize_(maxSize),
          syncers_(NULL),
          next_(NULL)
          
    {
        void
            * p = malloc(maxSize_ * sizeof(SyncRegion));

        if (p == NULL)
            {
                throw std::bad_alloc();
            }

        syncers_ = reinterpret_cast<SyncRegion*>(p);
        next_ = syncers_;
    }


    MultiSyncRegion::~MultiSyncRegion()
    {
        while (next_ > syncers_)
            {
                --next_;

                next_->~SyncRegion();
            }
        free(syncers_);
    }


    void MultiSyncRegion::throwIfFull()
    {
        if ((next_ - syncers_) == maxSize_)
            {
                throw SyncExc("MultiSyncRegion instance is full (max size: %d)",
                              maxSize_);
            }
    }

}