/*
 * Copyright (C) 2001
 * William E. Kempf
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  William E. Kempf makes no representations
 * about the suitability of this software for any purpose.  
 * It is provided "as is" without express or implied warranty.
 *
 * Revision History (excluding minor changes for specific compilers)
 *    8 Feb 01  Initial version.
 *    1 Jun 01  Added boost::thread initial implementation.
 *    3 Jul 01  Redesigned boost::thread to be noncopyable.
 */
 
#include <boost/thread/thread.hpp>
#include <boost/thread/semaphore.hpp>
#include <cassert>

#if defined(BOOST_HAS_WINTHREADS)
#   include <windows.h>
#   include <process.h>
#endif

#include "timeconv.inl"

#if defined(BOOST_HAS_PTHREADS)
namespace boost
{
    // This class is used to signal thread objects when the thread dies.
    class thread::thread_list
    {
    public:
        thread_list() { }
        ~thread_list()
        {
            mutex::lock lock(m_mutex);
            for (std::list<thread*>::iterator it = m_list.begin(); it != m_list.end(); ++it)
            {
                mutex::lock lock((*it)->m_mutex);
                (*it)->m_list = 0;
                (*it)->m_cond.notify_all();
            }
        }

        void add(thread* thrd)
        {
            mutex::lock lock(m_mutex);
            m_list.push_back(thrd);
        }

        void remove(thread* thrd)
        {
            mutex::lock lock(m_mutex);
            std::list<thread*>::iterator it = std::find(m_list.begin(), m_list.end(), thrd);
            if (it != m_list.end())
                m_list.erase(it);
        }

    private:
        std::list<thread*> m_list;
        mutex m_mutex;
    };
}
#endif

namespace
{
#if defined(BOOST_HAS_PTHREADS)
    pthread_key_t key;
    pthread_once_t once = PTHREAD_ONCE_INIT;

    void destroy_list(void* p)
    {
        boost::thread::thread_list* list = static_cast<boost::thread::thread_list*>(p);
        delete list;
    }

    void init_key()
    {
        int res = pthread_key_create(&key, &destroy_list);
        assert(res == 0);
    }

    pthread_key_t get_key()
    {
        int res = pthread_once(&once, &init_key);
        assert(res == 0);
        return key;
    }

    boost::thread::thread_list* get_list()
    {
        pthread_key_t key = get_key();
        boost::thread::thread_list* list = static_cast<boost::thread::thread_list*>(pthread_getspecific(key));
        if (!list)
        {
            list = new boost::thread::thread_list;
            pthread_setspecific(key, list);
        }
        return list;
    }
#endif

    class thread_param
    {
    public:
        thread_param(const boost::function0<void>& threadfunc) : m_threadfunc(threadfunc), m_started(false) { }
        void wait()
        {
            boost::mutex::lock lock(m_mutex);
            while (!m_started)
                m_cond.wait(lock);
        }
        void started()
        {
            boost::mutex::lock lock(m_mutex);
            m_started = true;
            m_cond.notify_one();
        }

        boost::mutex m_mutex;
        boost::condition m_cond;
        const boost::function0<void>& m_threadfunc;
        bool m_started;
#if defined(BOOST_HAS_PTHREADS)
        boost::thread::thread_list* m_list;
#endif
    };

#if defined(BOOST_HAS_WINTHREADS)
    unsigned __stdcall thread_proxy(void* param)
#elif defined(BOOST_HAS_PTHREADS)
    void* thread_proxy(void* param)
#endif
    {
        thread_param* p = static_cast<thread_param*>(param);
        boost::function0<void> threadfunc = p->m_threadfunc;
#if defined(BOOST_HAS_PTHREADS)
        p->m_list = get_list(); // create the list
#endif
        p->started();
        threadfunc();
        return 0;
    }
}

namespace boost
{
    lock_error::lock_error() : std::runtime_error("thread lock error")
	{
	}

    thread::thread()
    {
#if defined(BOOST_HAS_WINTHREADS)
        HANDLE cur = GetCurrentThread();
        HANDLE real;
        DuplicateHandle(GetCurrentProcess(), cur, GetCurrentProcess(), &real, 0, FALSE, DUPLICATE_SAME_ACCESS);
        m_thread = reinterpret_cast<unsigned long>(real);
        m_id = GetCurrentThreadId();
#elif defined(BOOST_HAS_PTHREADS)
        m_thread = pthread_self();
        m_list = get_list();
        m_list->add(this);
#endif
    }
    
    thread::thread(const boost::function0<void>& threadfunc)
    {
        thread_param param(threadfunc);
#if defined(BOOST_HAS_WINTHREADS)
        m_thread = _beginthreadex(0, 0, &thread_proxy, &param, 0, &m_id);
        assert(m_thread);
#elif defined(BOOST_HAS_PTHREADS)
        int res = pthread_create(&m_thread, 0, &thread_proxy, &param);
        assert(res == 0);
#endif
        param.wait();
#if defined(BOOST_HAS_PTHREADS)
        m_list = param.m_list;
        assert(m_list);
        m_list->add(this);
#endif
    }

    thread::~thread()
    {
        int res = 0;
#if defined(BOOST_HAS_WINTHREADS)
        res = CloseHandle(reinterpret_cast<HANDLE>(m_thread));
        assert(res);
#elif defined(BOOST_HAS_PTHREADS)
        {
            mutex::lock lock(m_mutex);
            if (m_list)
                m_list->remove(this);
        }

        res = pthread_detach(m_thread);
        assert(res == 0);
#endif
    }

    bool thread::operator==(const thread& other)
    {
#if defined(BOOST_HAS_WINTHREADS)
        return other.m_id == m_id;
#elif defined(BOOST_HAS_PTHREADS)
        return pthread_equal(m_thread, other.m_thread) != 0;
#endif
    }

    bool thread::operator!=(const thread& other)
    {
        return operator!=(other);
    }

    void thread::join()
    {
        int res;
#if defined(BOOST_HAS_WINTHREADS)
        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_thread), INFINITE);
        assert(res == WAIT_OBJECT_0);
#elif defined(BOOST_HAS_PTHREADS)
        mutex::lock lock(m_mutex);
        while (m_list)
            m_cond.wait(lock);
#endif
    }

    bool thread::try_join()
    {
#if defined(BOOST_HAS_WINTHREADS)
        return WaitForSingleObject(reinterpret_cast<HANDLE>(m_thread), 0) == WAIT_OBJECT_0;
#elif defined(BOOST_HAS_PTHREADS)
        mutex::lock lock(m_mutex);
        bool ret = (m_list == 0);
        return ret;
#endif
    }

    bool thread::timed_join(const xtime& xt)
    {
#if defined(BOOST_HAS_WINTHREADS)
        unsigned milliseconds;
        to_duration(xt, milliseconds);
        return WaitForSingleObject(reinterpret_cast<HANDLE>(m_thread), 0) == WAIT_OBJECT_0;
#elif defined(BOOST_HAS_PTHREADS)
        mutex::lock lock(m_mutex);
        while (m_list)
        {
            if (!m_cond.timed_wait(lock, xt))
                break;
        }
        bool ret = (m_list == 0);
        return ret;
#endif
    }

    void thread::sleep(const xtime& xt)
    {
#if defined(BOOST_HAS_WINTHREADS)
        unsigned milliseconds;
        to_duration(xt, milliseconds);
        Sleep(milliseconds);
#elif defined(BOOST_HAS_PTHREADS)
#   if defined(BOOST_HAS_PTHREAD_DELAY_NP)
        timespec ts;
        to_timespec(xt, ts);
        int res = pthread_delay_np(&ts);
        assert(res == 0);
#   elif defined(BOOST_HAS_NANOSLEEP)
        timespec ts;
        to_timespec(xt, ts);
        nanosleep(&ts, 0);
#   else
        boost::semaphore sema;
        sema.down(xt);
#   endif
#endif
    }

    void thread::yield()
    {
#if defined(BOOST_HAS_WINTHREADS)
        Sleep(0);
#elif defined(BOOST_HAS_PTHREADS)
#   if defined(BOOST_HAS_SCHED_YIELD)
        int res = sched_yield();
        assert(res == 0);
#   elif defined(BOOST_HAS_PTHREAD_YIELD)
        int res = pthread_yield();
        assert(res == 0);
#   else
        xtime xt;
        xtime_get(&xt, boost::TIME_UTC);
        sleep(xt);
#   endif
#endif
    }

    thread_group::thread_group()
    {
    }

    thread_group::~thread_group()
    {
        // We shouldn't have to lock here, since referencing this object from another thread
        // while we're deleting it in the current thread is going to lead to undefined behavior
        // any way.
        for (std::list<thread*>::iterator it = m_threads.begin(); it != m_threads.end(); ++it)
            delete (*it);
    }

    thread* thread_group::create_thread(const function0<void>& threadfunc)
    {
        // No lock required here since the only "shared data" that's modified here occurs
        // inside add_thread which does lock.
        std::auto_ptr<thread> thrd(new thread(threadfunc));
        add_thread(thrd.get());
        return thrd.release();
    }

    void thread_group::add_thread(thread* thrd)
    {
        mutex::lock lock(m_mutex);

        // For now we'll simply ignore requests to add a thread object multiple times.
        // Should we consider this an error and either throw or return an error value?
        std::list<thread*>::iterator it = std::find(m_threads.begin(), m_threads.end(), thrd);
        assert(it == m_threads.end());
        if (it == m_threads.end())
            m_threads.push_back(thrd);
    }

    void thread_group::remove_thread(thread* thrd)
    {
        mutex::lock lock(m_mutex);

        // For now we'll simply ignore requests to remove a thread object that's not in the group.
        // Should we consider this an error and either throw or return an error value?
        std::list<thread*>::iterator it = std::find(m_threads.begin(), m_threads.end(), thrd);
        assert(it != m_threads.end());
        if (it != m_threads.end())
            m_threads.erase(it);
    }

    void thread_group::join_all()
    {
        mutex::lock lock(m_mutex);
        for (std::list<thread*>::iterator it = m_threads.begin(); it != m_threads.end(); ++it)
            (*it)->join();
    }
}