#ifndef _beos_threaded_test_caller_h_
#define _beos_threaded_test_caller_h_

//#include <memory>
#include <cppunit/TestCase.h>
#include <cppunit/TestResult.h>
#include <cppunit/Test.h>
#include <ThreadedTestCase.h>
#include <cppunit/TestCaller.h>
#include <TestShell.h>
#include <ThreadManager.h>
#include <map>
#include <vector>
#include <stdio.h>

class TestResult;

template <class TestClass, class ExpectedException = CppUnit::NoExceptionExpected>
class CPPUNIT_API BThreadedTestCaller : public CppUnit::TestCase {
public:
        /*! \brief Pointer to a test function in the given class.
                Each ThreadMethod added with addThread() is run in its own thread.
        */
        typedef void (TestClass::*ThreadMethod)();

        BThreadedTestCaller(std::string name);
        BThreadedTestCaller(std::string name, TestClass &object);
        BThreadedTestCaller(std::string name, TestClass *object);
        virtual ~BThreadedTestCaller();

    virtual CppUnit::TestResult *run();
    virtual void run(CppUnit::TestResult *result);

        //! Adds a thread to the test. \c threadName must be unique to this BThreadedTestCaller.
    void addThread(std::string threadName, ThreadMethod method);

protected:
        virtual void setUp();
        virtual void tearDown();
        virtual std::string toString() const;

        typedef std::map<std::string, BThreadManager<TestClass, ExpectedException> *> ThreadManagerMap;

        bool fOwnObject;
        TestClass *fObject;
        ThreadManagerMap fThreads;

        sem_id fThreadSem;

};


template <class TestClass, class ExpectedException>
BThreadedTestCaller<TestClass, ExpectedException>::BThreadedTestCaller(std::string name)
        : TestCase(name)
        , fOwnObject(true)
        , fObject(new TestClass())
        , fThreadSem(-1)
{
}

template <class TestClass, class ExpectedException>
BThreadedTestCaller<TestClass, ExpectedException>::BThreadedTestCaller(std::string name, TestClass &object)
        : TestCase(name)
        , fOwnObject(false)
        , fObject(&object)
        , fThreadSem(-1)
{
}

template <class TestClass, class ExpectedException>
BThreadedTestCaller<TestClass, ExpectedException>::BThreadedTestCaller(std::string name, TestClass *object)
        : TestCase(name)
        , fOwnObject(true)
        , fObject(object)
        , fThreadSem(-1)
{
}

template <class TestClass, class ExpectedException>
BThreadedTestCaller<TestClass, ExpectedException>::~BThreadedTestCaller() {
        if (fOwnObject)
                delete fObject;
        for (typename ThreadManagerMap::iterator it = fThreads.begin(); it != fThreads.end (); ++it) {
                delete it->second;
        }
}


template <class TestClass, class ExpectedException>
void
BThreadedTestCaller<TestClass, ExpectedException>::addThread(std::string threadName, ThreadMethod method) {
        if (fThreads.find(threadName) == fThreads.end()) {
                // Unused name, go ahead and add
                fThreads[threadName] = new BThreadManager<TestClass, ExpectedException>(threadName, fObject, method, fThreadSem);
        } else {
                // Duplicate name, throw an exception
                throw CppUnit::Exception("BThreadedTestCaller::addThread() - Attempt to add thread under duplicated name ('"
                        + threadName + "')");
        }
}

template <class TestClass, class ExpectedException>
CppUnit::TestResult *
BThreadedTestCaller<TestClass, ExpectedException>::run() {
        CppUnit::TestResult *result = new CppUnit::TestResult;
        run(result);
        return result;
}

template <class TestClass, class ExpectedException>
void
BThreadedTestCaller<TestClass, ExpectedException>::run(CppUnit::TestResult *result) {
        result->startTest(this);

        if (fThreads.size() <= 0)
                throw CppUnit::Exception("BThreadedTestCaller::run() -- No threads added to BThreadedTestCaller()");

        try {
                setUp();

                // This try/catch block should never actually have to catch
                // anything (unless some bonehead passes in a NULL pointer to
                // the constructor). Each BThreadManager object catches and
                // handles exceptions for its respective thread, so as not
                // to disrupt the others.
                try {
                        // Create our thread semaphore. This semaphore is used to
                        // determine when all the threads have finished executing,
                        // while still allowing *this* thread to handle printing
                        // out NextSubTest() info (since other threads don't appear
                        // to be able to output text while the main thread is
                        // blocked; their output appears later...).
                        //
                        // Each thread will acquire the semaphore once when launched,
                        // thus the initial thread count is equal the number of threads.
                        fThreadSem = create_sem(fThreads.size(), "ThreadSem");
                        if (fThreadSem < B_OK)
                                throw CppUnit::Exception("BThreadedTestCaller::run() -- Error creating fThreadSem");

                        // Launch all the threads.
                        for (typename ThreadManagerMap::iterator i = fThreads.begin();
                                   i != fThreads.end ();
                         ++i)
                {
                        status_t err = i->second->LaunchThread(result);
                                if (err != B_OK)
                                        result->addError(this, new CppUnit::Exception("Error launching thread '" + i->second->getName() + "'"));
//                              printf("Launch(%s)\n", i->second->getName().c_str());
                        }

                        // Now we loop. Before you faint, there is a reason for this:
                        // Calls to NextSubTest() from other threads don't actually
                        // print anything while the main thread is blocked waiting
                        // for another thread. Thus, we have NextSubTest() add the
                        // information to be printed into a queue. The main thread
                        // (this code right here), blocks on a semaphore that it
                        // can only acquire after all the test threads have terminated.
                        // If it times out, it checks the NextSubTest() queue, prints
                        // any pending updates, and tries to acquire the semaphore
                        // again. When it finally manages to acquire it, all the
                        // test threads have terminated, and it's safe to clean up.

                        status_t err;
                        do {
                                // Try to acquire the semaphore
                                err = acquire_sem_etc(fThreadSem, fThreads.size(), B_RELATIVE_TIMEOUT,  500000);

                                // Empty the UpdateList
                                std::vector<std::string> &list = fObject->AcquireUpdateList();
                                for (std::vector<std::string>::iterator i = list.begin();
                                           i != list.end();
                                             i++)
                                {
                                        // Only print to standard out if the current global shell
                                        // lets us (or if no global shell is designated).
                                        if (BTestShell::GlobalBeVerbose()) {
                                                printf("%s", (*i).c_str());
                                                fflush(stdout);
                                        }
                                }
                                list.clear();
                                fObject->ReleaseUpdateList();

                        } while (err != B_OK);

                        // If we get this far, we actually managed to acquire the semaphore,
                        // so we should release it now.
                        release_sem_etc(fThreadSem, fThreads.size(), 0);

                        // Print out a newline for asthetics :-)
                        printf("\n");

/*


                        // Wait for them all to finish, then clean up
                        for (ThreadManagerMap::iterator i = fThreads.begin();
                                  i != fThreads.end ();
                        ++i)
                        {
//                              printf("Wait(%s)...", i->second->getName().c_str());
                                fflush(stdout);
                                i->second->WaitForThread();
//                              printf("done\n");
                                delete i->second;
                        }
*/

                        fThreads.clear();

                } catch ( CppUnit::Exception &e ) {
                        // Add on the a note that this exception was caught by the
                        // thread caller (which is a bad thing), then note the exception
                CppUnit::Exception *threadException = new CppUnit::Exception(
                        std::string(e.what()) + " (NOTE: caught by BThreadedTestCaller)",
                        e.sourceLine()
                );
                        result->addFailure( fObject, threadException );
                }
                catch ( std::exception &e ) {
                        // Add on the thread name, then note the exception
                CppUnit::Exception *threadException = new CppUnit::Exception(
                        std::string(e.what()) + " (NOTE: caught by BThreadedTestCaller)"
                );
                        result->addError( fObject, threadException );
                }
                catch (...) {
                        // Add on the thread name, then note the exception
                        CppUnit::Exception *threadException = new CppUnit::Exception(
                                "caught unknown exception (NOTE: caught by BThreadedTestCaller)"
                        );
                        result->addError( fObject, threadException );
                }

                snooze(50000);

                try {
                    tearDown();
                } catch (...) {
                        result->addError(this, new CppUnit::Exception("tearDown() failed"));
                }
        } catch (...) {
                result->addError(this, new CppUnit::Exception("setUp() failed"));
        }       // setUp() try/catch block

        result->endTest(this);
}

template <class TestClass, class ExpectedException>
void
BThreadedTestCaller<TestClass, ExpectedException>::setUp() {
        // Verify we have a valid object that's not currently in use first.
        if (!fObject)
                throw CppUnit::Exception("BThreadedTestCaller::runTest() -- NULL fObject pointer");
        if (!fObject->RegisterForUse())
                throw CppUnit::Exception("BThreadedTestCaller::runTest() -- Attempt to reuse ThreadedTestCase object already in use");

        fObject->setUp();
}

template <class TestClass, class ExpectedException>
void
BThreadedTestCaller<TestClass, ExpectedException>::tearDown() {
        fObject->tearDown();
}

template <class TestClass, class ExpectedException>
std::string
BThreadedTestCaller<TestClass, ExpectedException>::toString() const {
        return std::string("BThreadedTestCaller for ") + getName();
}

#endif // _beos_threaded_test_caller_h_