/** 
 * @file llthread.cpp
 *
 * $LicenseInfo:firstyear=2004&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010-2013, Linden Research, Inc.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 * 
 * This library 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 for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 * 
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#include "linden_common.h"
#include "llapr.h"

#include "apr_portable.h"

#include "llthread.h"
#include "llmutex.h"

#include "lltimer.h"
#include "lltrace.h"
#include "lltracethreadrecorder.h"
#include "llexception.h"

#if LL_LINUX
#include <sched.h>
#endif


#ifdef LL_WINDOWS
const DWORD MS_VC_EXCEPTION=0x406D1388;

#pragma pack(push,8)
typedef struct tagTHREADNAME_INFO
{
    DWORD dwType; // Must be 0x1000.
    LPCSTR szName; // Pointer to name (in user addr space).
    DWORD dwThreadID; // Thread ID (-1=caller thread).
    DWORD dwFlags; // Reserved for future use, must be zero.
} THREADNAME_INFO;
#pragma pack(pop)

void set_thread_name( DWORD dwThreadID, const char* threadName)
{
    THREADNAME_INFO info;
    info.dwType = 0x1000;
    info.szName = threadName;
    info.dwThreadID = dwThreadID;
    info.dwFlags = 0;

    __try
    {
        ::RaiseException( MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(DWORD), (ULONG_PTR*)&info );
    }
    __except(EXCEPTION_CONTINUE_EXECUTION)
    {
    }
}
#endif


//----------------------------------------------------------------------------
// Usage:
// void run_func(LLThread* thread)
// {
// }
// LLThread* thread = new LLThread();
// thread->run(run_func);
// ...
// thread->setQuitting();
// while(!timeout)
// {
//   if (thread->isStopped())
//   {
//     delete thread;
//     break;
//   }
// }
// 
//----------------------------------------------------------------------------
namespace
{

    LLThread::id_t main_thread()
    {
        // Using a function-static variable to identify the main thread
        // requires that control reach here from the main thread before it
        // reaches here from any other thread. We simply trust that whichever
        // thread gets here first is the main thread.
        static LLThread::id_t s_thread_id = LLThread::currentID();
        return s_thread_id;
    }

} // anonymous namespace

LL_COMMON_API bool on_main_thread()
{
    return (LLThread::currentID() == main_thread());
}

LL_COMMON_API void assert_main_thread()
{
    auto curr = LLThread::currentID();
    auto main = main_thread();
    if (curr != main)
    {
        LL_WARNS() << "Illegal execution from thread id " << curr
            << " outside main thread " << main << LL_ENDL;
    }
}

// this function has become moot
void LLThread::registerThreadID() {}

//
// Handed to the APR thread creation function
//
void LLThread::threadRun()
{
#ifdef LL_WINDOWS
    set_thread_name(-1, mName.c_str());
#endif

    // this is the first point at which we're actually running in the new thread
    mID = currentID();

    // for now, hard code all LLThreads to report to single master thread recorder, which is known to be running on main thread
    mRecorder = new LLTrace::ThreadRecorder(*LLTrace::get_master_thread_recorder());

    // Run the user supplied function
    do 
    {
        try
        {
            run();
        }
        catch (const LLContinueError &e)
        {
            LL_WARNS("THREAD") << "ContinueException on thread '" << mName <<
                "' reentering run(). Error what is: '" << e.what() << "'" << LL_ENDL;
            //output possible call stacks to log file.
            LLError::LLCallStacks::print();

            LOG_UNHANDLED_EXCEPTION("LLThread");
            continue;
        }
        break;

    } while (true);

    //LL_INFOS() << "LLThread::staticRun() Exiting: " << threadp->mName << LL_ENDL;


    delete mRecorder;
    mRecorder = NULL;

    // We're done with the run function, this thread is done executing now.
    //NB: we are using this flag to sync across threads...we really need memory barriers here
    // Todo: add LLMutex per thread instead of flag?
    // We are using "while (mStatus != STOPPED) {ms_sleep();}" everywhere.
    mStatus = STOPPED;
}

LLThread::LLThread(const std::string& name, apr_pool_t *poolp) :
    mPaused(FALSE),
    mName(name),
    mThreadp(NULL),
    mStatus(STOPPED),
    mRecorder(NULL)
{
    mRunCondition = new LLCondition();
    mDataLock = new LLMutex();
    mLocalAPRFilePoolp = NULL ;
}


LLThread::~LLThread()
{
    shutdown();

    if (isCrashed())
    {
        LL_WARNS("THREAD") << "Destroying crashed thread named '" << mName << "'" << LL_ENDL;
    }

    if(mLocalAPRFilePoolp)
    {
        delete mLocalAPRFilePoolp ;
        mLocalAPRFilePoolp = NULL ;
    }
}

void LLThread::shutdown()
{
    if (isCrashed())
    {
        LL_WARNS("THREAD") << "Shutting down crashed thread named '" << mName << "'" << LL_ENDL;
    }

    // Warning!  If you somehow call the thread destructor from itself,
    // the thread will die in an unclean fashion!
    if (mThreadp)
    {
        if (!isStopped())
        {
            // The thread isn't already stopped
            // First, set the flag that indicates that we're ready to die
            setQuitting();

            //LL_INFOS() << "LLThread::~LLThread() Killing thread " << mName << " Status: " << mStatus << LL_ENDL;
            // Now wait a bit for the thread to exit
            // It's unclear whether I should even bother doing this - this destructor
            // should never get called unless we're already stopped, really...
            S32 counter = 0;
            const S32 MAX_WAIT = 600;
            while (counter < MAX_WAIT)
            {
                if (isStopped())
                {
                    break;
                }
                // Sleep for a tenth of a second
                ms_sleep(100);
                yield();
                counter++;
            }
        }

        if (!isStopped())
        {
            // This thread just wouldn't stop, even though we gave it time
            //LL_WARNS() << "LLThread::~LLThread() exiting thread before clean exit!" << LL_ENDL;
            // Put a stake in its heart. (A very hostile method to force a thread to quit)
#if		LL_WINDOWS
            TerminateThread(mNativeHandle, 0);
#else
            pthread_cancel(mNativeHandle);
#endif

            delete mRecorder;
            mRecorder = NULL;
            mStatus = STOPPED;
            return;
        }
        mThreadp = NULL;
    }

    delete mRunCondition;
    mRunCondition = NULL;

    delete mDataLock;
    mDataLock = NULL;

    if (mRecorder)
    {
        // missed chance to properly shut down recorder (needs to be done in thread context)
        // probably due to abnormal thread termination
        // so just leak it and remove it from parent
        LLTrace::get_master_thread_recorder()->removeChildRecorder(mRecorder);
    }
}


void LLThread::start()
{
    llassert(isStopped());
    
    // Set thread state to running
    mStatus = RUNNING;

    try
    {
        mThreadp = new std::thread(std::bind(&LLThread::threadRun, this));
        mNativeHandle = mThreadp->native_handle();
    }
    catch (std::system_error& ex)
    {
        mStatus = STOPPED;
        LL_WARNS() << "failed to start thread " << mName << " " << ex.what() << LL_ENDL;
    }

}

//============================================================================
// Called from MAIN THREAD.

// Request that the thread pause/resume.
// The thread will pause when (and if) it calls checkPause()
void LLThread::pause()
{
    if (!mPaused)
    {
        // this will cause the thread to stop execution as soon as checkPause() is called
        mPaused = 1;        // Does not need to be atomic since this is only set/unset from the main thread
    }   
}

void LLThread::unpause()
{
    if (mPaused)
    {
        mPaused = 0;
    }

    wake(); // wake up the thread if necessary
}

// virtual predicate function -- returns true if the thread should wake up, false if it should sleep.
bool LLThread::runCondition(void)
{
    // by default, always run.  Handling of pause/unpause is done regardless of this function's result.
    return true;
}

//============================================================================
// Called from run() (CHILD THREAD).
// Stop thread execution if requested until unpaused.
void LLThread::checkPause()
{
    mDataLock->lock();

    // This is in a while loop because the pthread API allows for spurious wakeups.
    while(shouldSleep())
    {
        mDataLock->unlock();
        mRunCondition->wait(); // unlocks mRunCondition
        mDataLock->lock();
        // mRunCondition is locked when the thread wakes up
    }
    
    mDataLock->unlock();
}

//============================================================================

void LLThread::setQuitting()
{
    mDataLock->lock();
    if (mStatus == RUNNING)
    {
        mStatus = QUITTING;
    }
    mDataLock->unlock();
    wake();
}

// static
LLThread::id_t LLThread::currentID()
{
    return std::this_thread::get_id();
}

// static
void LLThread::yield()
{
    std::this_thread::yield();
}

void LLThread::wake()
{
    mDataLock->lock();
    if(!shouldSleep())
    {
        mRunCondition->signal();
    }
    mDataLock->unlock();
}

void LLThread::wakeLocked()
{
    if(!shouldSleep())
    {
        mRunCondition->signal();
    }
}

void LLThread::lockData()
{
    mDataLock->lock();
}

void LLThread::unlockData()
{
    mDataLock->unlock();
}

//============================================================================

//----------------------------------------------------------------------------

//static
LLMutex* LLThreadSafeRefCount::sMutex = 0;

//static
void LLThreadSafeRefCount::initThreadSafeRefCount()
{
    if (!sMutex)
    {
        sMutex = new LLMutex();
    }
}

//static
void LLThreadSafeRefCount::cleanupThreadSafeRefCount()
{
    delete sMutex;
    sMutex = NULL;
}
    

//----------------------------------------------------------------------------

LLThreadSafeRefCount::LLThreadSafeRefCount() :
    mRef(0)
{
}

LLThreadSafeRefCount::LLThreadSafeRefCount(const LLThreadSafeRefCount& src)
{
    mRef = 0;
}

LLThreadSafeRefCount::~LLThreadSafeRefCount()
{ 
    if (mRef != 0)
    {
		LL_ERRS() << "deleting referenced object mRef = " << mRef << LL_ENDL;
    }
}

//============================================================================

LLResponder::~LLResponder()
{
}

//============================================================================