/*************************************************************************
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 * 
 * Copyright 2000, 2010 Oracle and/or its affiliates.
 *
 * OpenOffice.org - a multi-platform office productivity suite
 *
 * This file is part of OpenOffice.org.
 *
 * OpenOffice.org is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * OpenOffice.org is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details
 * (a copy is included in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with OpenOffice.org.  If not, see
 * <http://www.openoffice.org/license.html>
 * for a copy of the LGPLv3 License.
 *
 ************************************************************************/
#include <hash_map>

#include <osl/conditn.h>

#include <rtl/byteseq.hxx>

#include <boost/shared_ptr.hpp>

#include "jobqueue.hxx"


using namespace ::rtl;
namespace cppu_threadpool {
	class ORequestThread;

	struct EqualThreadId
	{
		sal_Int32 operator () ( const ::rtl::ByteSequence &a , const ::rtl::ByteSequence &b ) const
			{
				return a == b;
			}
	};

	struct HashThreadId
	{
		sal_Int32 operator () ( const ::rtl::ByteSequence &a  )  const 
			{
				if( a.getLength() >= 4 )
				{
					return *(sal_Int32 *)a.getConstArray();
				}
				return 0;
			}
	};

	typedef	::std::hash_map
	<
	    ByteSequence, // ThreadID 
		::std::pair < JobQueue * , JobQueue * >,
		HashThreadId,
		EqualThreadId
	> ThreadIdHashMap;

	typedef	::std::list	< sal_Int64 > DisposedCallerList;

	
	struct WaitingThread
	{
		oslCondition condition;
		ORequestThread *thread;
	};
	
	typedef	::std::list	< struct ::cppu_threadpool::WaitingThread * > WaitingThreadList;

	class DisposedCallerAdmin;
	typedef boost::shared_ptr<DisposedCallerAdmin> DisposedCallerAdminHolder;
	
	class DisposedCallerAdmin
	{
	public:
		~DisposedCallerAdmin();
		
		static DisposedCallerAdminHolder getInstance();

		void dispose( sal_Int64 nDisposeId );
		void stopDisposing( sal_Int64 nDisposeId );
		sal_Bool isDisposed( sal_Int64 nDisposeId );

	private:
		::osl::Mutex m_mutex;
		DisposedCallerList m_lst;
	};

	class ThreadPool;
	typedef boost::shared_ptr<ThreadPool> ThreadPoolHolder;

	class ThreadPool
	{
	public:
		ThreadPool();
		~ThreadPool();
		static ThreadPoolHolder getInstance();
		
		void dispose( sal_Int64 nDisposeId );
		void stopDisposing( sal_Int64 nDisposeId );
		
		void addJob( const ByteSequence &aThreadId,
					 sal_Bool bAsynchron,
					 void *pThreadSpecificData,
					 RequestFun * doRequest );

		void prepare( const ByteSequence &aThreadId );
		void * enter( const ByteSequence &aThreadId, sal_Int64 nDisposeId );

		/********
		 * @return true, if queue could be succesfully revoked.
		 ********/
		sal_Bool revokeQueue( const ByteSequence & aThreadId , sal_Bool bAsynchron );
		
		void waitInPool( ORequestThread *pThread );
	private:
		void createThread( JobQueue *pQueue, const ByteSequence &aThreadId,	sal_Bool bAsynchron);

		
		ThreadIdHashMap m_mapQueue;
		::osl::Mutex m_mutex;
		
		::osl::Mutex m_mutexWaitingThreadList;
		WaitingThreadList m_lstThreads;

		DisposedCallerAdminHolder m_DisposedCallerAdmin;
	};

} // end namespace cppu_threadpool