// Copyright (C) 2002 Eric Woodruff (eric.woodruff@falsetto.com)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.


#ifndef ADVANCED_THREAD_HPP__
#define ADVANCED_THREAD_HPP__

#include <boost/tuple/tuple.hpp>

#include <boost/function.hpp>

#include <boost/thread/thread.hpp>

#include <boost/bind.hpp>

#include <boost/new.hpp>

#include <boost/shared_ptr.hpp>


namespace boost {
	
	namespace threads {
			struct IThreadException {
				virtual void doThrow () = 0;
				virtual ~IThreadException () {}
			};
			
			template <typename Exception> class thread_exception : public IThreadException {
				public:
					thread_exception (Exception exception) : exception (exception) {}
					thread_exception () {}
					void doThrow () { throw exception; }
				private:
					Exception exception;
			};
			
			typedef shared_ptr<IThreadException> HThreadException;
			
			template <typename Exception> void thread_throw (Exception exception) {	
				throw HThreadException (boost::New<thread_exception<Exception>, IThreadException> (exception));
				// ideally throw boost::New<thread_exception<Exception> > (exception);
				
				// off topic note to self: boost::New is preferred as a class so it can easily be made a friend
				// to force the shared_ptr paradigm by making the constructor private
			}
			
			
			template <typename ReturnType, typename Exceptions> class ExceptionAdapter {
				public:
					static ReturnType convertExceptions (boost::function0<ReturnType> const& f) {	
						return Catcher<tuples::length<Exceptions>::value>::callFunctor (f);
					}
				
				private:
					template <int length, int HACK = 0> struct Catcher {
						static ReturnType callFunctor (boost::function0<ReturnType> const& f) {
							try {
								return Catcher<length - 1>::callFunctor (f);
							}
							catch (tuples::element<length - 1, Exceptions>::type exception) {
								thread_throw (exception);
							}
						}
					};
					
					template <int HACK> struct Catcher<0, HACK> {
						static ReturnType callFunctor (boost::function0<ReturnType> const& f) {
							return f ();
						}
					};
			};
			
			
			// only needed on void return problems
			template <typename Exceptions> class ExceptionAdapter<void, Exceptions> {
				public:
					static void convertExceptions (boost::function0<void> const& f) {
						Catcher<tuples::length<Exceptions>::value>::callFunctor (f);
					}
				
				private:
					template <int length, int HACK = 0> struct Catcher {
						static void callFunctor (boost::function0<void> const& f) {
							try {
								Catcher<length - 1>::callFunctor (f);
							}
							catch (tuples::element<length - 1, Exceptions>::type exception) {
								thread_throw (exception);
							}
						}
					};
					
					template <int HACK> struct Catcher<0, HACK> {
						static void callFunctor (boost::function0<void> const& f) {
							f ();
						}
					};
			};
		
		// whenever there is an exception, it can be received on multiple joins from different threads
		template <typename E1 = tuples::null_type, typename E2 = tuples::null_type, typename E3 = tuples::null_type,
				typename E4 = tuples::null_type, typename E5 = tuples::null_type, typename E6 = tuples::null_type,
				typename E7 = tuples::null_type, typename E8 = tuples::null_type, typename E9 = tuples::null_type,
				typename E10 = tuples::null_type>
			class throws_exceptions {
				typedef boost::tuple<E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> Exceptions;
				
				public:
					// make a flag to terminate instead of bad_exception?
					// currently an empty exception list will throw bad_exception instead of terminating
					// i guess that follows the "throws_exceptions" mantra
					void assert_no_exception () {
						if (HThreadException () != exception) {
							exception->doThrow ();
						}
					}
					
				protected:
					template <typename ReturnType>
					ReturnType runThread (boost::function0<ReturnType> const& f) {
						try {
							return ExceptionAdapter<ReturnType, Exceptions>::convertExceptions (f);
						}
						catch (HThreadException const& exception) {
							setException (exception);
						}
						catch (...) {
							setException (boost::New<thread_exception<std::bad_exception>, IThreadException> ());
						}
					}
					
					// really only needed on void return problems
					void runThread (boost::function0<void> const& f) {
						try {
							ExceptionAdapter<void, Exceptions>::convertExceptions (f);
						}
						catch (HThreadException const& exception) {
							setException (exception);
						}
						catch (...) {
							setException (boost::New<thread_exception<std::bad_exception>, IThreadException> ());
						}
					}
					
				private:
					void setException (HThreadException const& exception) {
						this->exception = exception;
					}

					HThreadException exception;
			};
			
			
			class terminates_on_exception {
				public:
					void assert_no_exception () {
					}
					
				protected:
					template <typename ReturnType>
					ReturnType runThread (boost::function0<ReturnType> const& f) {
						try {
							return f ();
						}
						catch (...) {
							std::terminate ();
						}
					}
					
					// again, for void return problems
					void runThread (boost::function0<void> const& f) {
						try {
							f ();
						}
						catch (...) {
							std::terminate ();
						}
					}
			};
	}


	// the "int HACK" is to appease CodeWarrior
			
	template <typename ReturnType, typename ExceptionPolicy = threads::terminates_on_exception, int HACK = 0>
	class advanced_thread : public ExceptionPolicy {
		public:
			typedef boost::function0<ReturnType> Functor;
			
			advanced_thread (Functor const& f)
				: /*thread (bind (&advanced_thread::threadProcess, this)),*/ functor (f) {
				runThread (); // for simple testing only
				ExceptionPolicy::assert_no_exception ();
			}
			
			ReturnType join () {
				//thread.join ();
				ExceptionPolicy::assert_no_exception ();
				return returnValue;
			}
						
		private:
			void runThread () {
				returnValue = ExceptionPolicy::runThread (functor);
			}
			
			Functor functor;
			ReturnType returnValue;
			// thread
	};
	
	template <typename ExceptionPolicy, int HACK> class advanced_thread<void, threads::terminates_on_exception, HACK> : public ExceptionPolicy {
		public:
			typedef boost::function0<void> Functor;
			
			advanced_thread (Functor const& f)
				: functor (f) {
				runThread (); // for simple testing only
				ExceptionPolicy::assert_no_exception ();
			}
			
			void join () {
				//thread.join ();
				ExceptionPolicy::assert_no_exception ();
			}
			
		private:
			void runThread () {
				ExceptionPolicy::runThread (functor);
			}

			Functor functor;
			// thread
	};
}


#endif