// 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 <iostream>

#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> struct thread_exception : public IThreadException {
			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) {	
			// again because of lack of boost::New support in shared_ptr
			throw HThreadException (boost::New<thread_exception<Exception>, IThreadException> (exception));
			// ideally throw boost::New<thread_exception<Exception> > (exception);
		}
		
		#define thread_exceptions boost::tuple // obviously not namespaced, used for sanity, i suppose
		// this could be done the right way
		
		typedef thread_exceptions<> no_exceptions;
	}

	template <typename Exceptions> class advanced_thread_base {
		public:
			typedef Exceptions Exceptions;
			
			void join () {
				assertNoException ();
				//thread.join ();
			}
			
			void assertNoException () {
				if (threads::HThreadException () != exception) {
					exception->doThrow ();
				}
			}
			
		protected:
			advanced_thread_base (boost::function<void> const& threadFunctor)
				{//: thread (threadFunctor) {
				assertNoException ();
			}
			
			void setException (threads::HThreadException const& exception) {
				this->exception = exception;
			}
			
		private:
			//boost::thread thread;
			threads::HThreadException exception;
	};
		
		// in codewarrior i can only do any specialization if a simple type is also involved, such as int
		
	template <typename ReturnType, typename Exceptions = threads::no_exceptions, int HACK = 0> class advanced_thread : public advanced_thread_base<Exceptions> {
		typedef advanced_thread_base<Exceptions> Super;
		public:
			typedef boost::function<ReturnType> Functor;
			
			advanced_thread (Functor const& f)
				: Super (bind (&advanced_thread::doThread, this)), functor (f) {
				doThread (); // for testing only
				assertNoException (); // for testing only
			}
			
			ReturnType getReturnValue () {
				assertNoException ();
				return returnValue;
			}
						
		private:
			void doThread () {
				try {
					returnValue = ExceptionAdapter<boost::tuples::length<Exceptions>::value>::callFunctor (functor);
				}
				catch (threads::HThreadException& exception) {
					setException (exception);
				}
				catch (...) {
					// get support for boost::New in shrared_ptr
					setException (boost::New<threads::thread_exception<std::bad_exception>, threads::IThreadException> ());
					// ideally setException (boost::New<threads::thread_exception<std::bad_exception> > ());
				}
			}
			
			template <int length, int HACK = 0> struct ExceptionAdapter {
				static ReturnType callFunctor (Functor const& f) {
					try {
						return ExceptionAdapter<length - 1>::callFunctor (f);
					} catch (tuples::element<length-1, Exceptions>::type exception) {
						threads::thread_throw (exception);
					}
				}
			};
			
			template <int HACK> struct ExceptionAdapter<0, HACK> {
				static ReturnType callFunctor (Functor const& f) {
					return f ();
				}
			};

			Functor functor;
			ReturnType returnValue;
	};

	template <typename Exceptions, int HACK> class advanced_thread<void, Exceptions, HACK> : public advanced_thread_base<Exceptions> {
		typedef advanced_thread_base<Exceptions> Super;
		public:
			typedef boost::function<void> Functor;
			
			advanced_thread (Functor const& f)
				: Super (bind (&advanced_thread::doThread, this)), functor (f) {
				doThread (); // for testing only
				assertNoException (); // for testing only
			}
			
		private:
			void doThread () {
				try {
					ExceptionAdapter<boost::tuples::length<Exceptions>::value>::callFunctor (functor);
				}
				catch (threads::HThreadException& exception) {
					setException (exception);
				}
				catch (...) {
					setException (boost::New<threads::thread_exception<std::bad_exception>, threads::IThreadException> ());
					// ideally setException (boost::New<threads::thread_exception<std::bad_exception> > ());
				}
			}
			
			template <int length, int HACK = 0> struct ExceptionAdapter {
				static void callFunctor (Functor const& f) {
					try {
						ExceptionAdapter<length - 1>::callFunctor (f);
					}
					catch (tuples::element<length - 1, Exceptions>::type exception) {
						threads::thread_throw (exception);
					}
				}
			};
			
			template <int HACK> struct ExceptionAdapter<0, HACK> {
				static void callFunctor (Functor const& f) {
					f ();
				}
			};
			
			Functor functor;
	};
}


#endif