/*
 * Copyright 2003-2009, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Jonas Sundström, jonas@kirilla.com
 */


#include "GenericThread.h"

#include <string.h>


GenericThread::GenericThread(const char* thread_name, int32 priority,
        BMessage* message)      
        :
        fThreadDataStore(message),
        fThreadId(spawn_thread(_ThreadFunction, thread_name, priority, this)),
        fExecuteUnitSem(create_sem(1, "fExecuteUnitSem")),
        fQuitRequested(false),
        fThreadIsPaused(false)
{
        if (fThreadDataStore == NULL)
                fThreadDataStore = new BMessage();
}


GenericThread::~GenericThread()
{
        kill_thread(fThreadId);
        
        delete_sem(fExecuteUnitSem);
}


status_t 
GenericThread::ThreadFunction()
{
        status_t status = B_OK;
        
        status = ThreadStartup();
                // Subclass and override this function
                
        if (status != B_OK) {
                ThreadStartupFailed(status);
                return status;
                // is this the right thing to do?
        }
        
        while (1) {
                if (HasQuitBeenRequested()) {
                        status = ThreadShutdown();
                                // Subclass and override this function
                                
                        if (status != B_OK) {
                                ThreadShutdownFailed(status);
                                return status;
                        }
                        
                        delete this;
                        return B_OK;
                }

                BeginUnit();

                status = ExecuteUnit();
                        // Subclass and override

                if (status != B_OK)
                        ExecuteUnitFailed(status);
                                // Subclass and override
                
                EndUnit();      
        }

        return B_OK;
}


status_t 
GenericThread::ThreadStartup()
{
        // This function is virtual.
        // Subclass and override this function.

        return B_OK;
}


status_t 
GenericThread::ExecuteUnit()
{
        // This function is virtual.

        // You would normally subclass and override this function
        // as it will provide you with Pause and Quit functionality
        // thanks to the unit management done by GenericThread::ThreadFunction()

        return B_OK;
}


status_t 
GenericThread::ThreadShutdown()
{
        // This function is virtual.
        // Subclass and override this function.

        return B_OK;
}


void 
GenericThread::ThreadStartupFailed(status_t status)
{
        // This function is virtual.
        // Subclass and override this function.
        
        Quit();
}


void 
GenericThread::ExecuteUnitFailed(status_t status)
{
        // This function is virtual.
        // Subclass and override this function.
        
        Quit();
}


void 
GenericThread::ThreadShutdownFailed(status_t status)
{
        // This function is virtual.
        // Subclass and override this function.
        
        // (is this good default behaviour?)
}


status_t 
GenericThread::Start()
{
        status_t status = B_OK;
        
        if (IsPaused()) {
                status = release_sem(fExecuteUnitSem);
                if (status != B_OK)
                        return status;

                fThreadIsPaused = false;
        }
        
        status = resume_thread(fThreadId);
        
        return status;
}


int32 
GenericThread::_ThreadFunction(void* simple_thread_ptr)
{
        status_t status = B_OK;

        status = ((GenericThread*) simple_thread_ptr)->ThreadFunction();

        return status;
}


BMessage*       
GenericThread::GetDataStore()
{
        return fThreadDataStore;
}


void
GenericThread::SetDataStore(BMessage* message)
{
        fThreadDataStore = message;
}


status_t        
GenericThread::Pause(bool doBlock, bigtime_t timeout)
{
        status_t status = B_OK;
        
        if (doBlock)
                status = acquire_sem(fExecuteUnitSem); 
                        // thread will wait on semaphore
        else
                status = acquire_sem_etc(fExecuteUnitSem, 1, B_RELATIVE_TIMEOUT,
                        timeout); 
                        // thread will timeout

        if (status == B_OK) {
                fThreadIsPaused = true;
                return B_OK;
        }
        
        return status;
}


void    
GenericThread::Quit()
{
        fQuitRequested = true;
}


bool 
GenericThread::HasQuitBeenRequested()
{
        return fQuitRequested;
}


bool    
GenericThread::IsPaused()
{
        return fThreadIsPaused;
}


status_t        
GenericThread::Suspend()
{
        return suspend_thread(fThreadId);
}


status_t        
GenericThread::Resume()
{
        release_sem(fExecuteUnitSem);
                // to counteract Pause()
        fThreadIsPaused = false;
        
        return resume_thread(fThreadId);
                // to counteract Suspend()
}


status_t        
GenericThread::Kill()
{
        return kill_thread(fThreadId);
}


void    
GenericThread::ExitWithReturnValue(status_t return_value)
{
        exit_thread(return_value);
}


status_t        
GenericThread::SetExitCallback(void (*callback)(void*), void* data)
{
        return on_exit_thread(callback, data);
}


status_t        
GenericThread::WaitForThread(status_t* exitValue)
{
        return wait_for_thread(fThreadId, exitValue);
}


status_t        
GenericThread::Rename(char* name)
{
        return rename_thread(fThreadId, name);
}


status_t        
GenericThread::SendData(int32 code, void* buffer, size_t buffer_size)
{
        return send_data(fThreadId, code, buffer, buffer_size);
}


int32   
GenericThread::ReceiveData(thread_id* sender, void* buffer, size_t buffer_size)
{
        return receive_data(sender, buffer, buffer_size);
}


bool    
GenericThread::HasData()
{
        return has_data(fThreadId);
}


status_t        
GenericThread::SetPriority(int32 newPriority)
{
        return set_thread_priority(fThreadId, newPriority);
}


void    
GenericThread::Snooze(bigtime_t microseconds)
{
        Suspend();
        snooze(microseconds);
        Resume();
}


void    
GenericThread::SnoozeUntil(bigtime_t microseconds, int timebase)
{
        Suspend();
        snooze_until(microseconds, timebase);
        Resume();
}


status_t        
GenericThread::GetInfo(thread_info* threadInfo)
{
        return get_thread_info(fThreadId, threadInfo);
}


thread_id       
GenericThread::GetThread()
{
        thread_info     threadInfo;
        GetInfo(&threadInfo);
        return threadInfo.thread;
}


team_id 
GenericThread::GetTeam()
{
        thread_info     threadInfo;
        GetInfo(&threadInfo);
        return threadInfo.team;
}


char*   
GenericThread::GetName()
{
        thread_info     threadInfo;
        GetInfo(&threadInfo);
        return strdup(threadInfo.name);
}


thread_state    
GenericThread::GetState()
{
        thread_info     threadInfo;
        GetInfo(&threadInfo);
        return threadInfo.state;
}


sem_id  
GenericThread::GetSemaphore()
{
        thread_info     threadInfo;
        GetInfo(&threadInfo);
        return threadInfo.sem;
}


int32   
GenericThread::GetPriority()
{
        thread_info     threadInfo;
        GetInfo(&threadInfo);
        return threadInfo.priority;
}


bigtime_t       
GenericThread::GetUserTime()
{
        thread_info     threadInfo;
        GetInfo(&threadInfo);
        return threadInfo.user_time;
}


bigtime_t       
GenericThread::GetKernelTime()
{
        thread_info     threadInfo;
        GetInfo(&threadInfo);
        return threadInfo.kernel_time;
}


void*   
GenericThread::GetStackBase()
{
        thread_info     threadInfo;
        GetInfo(&threadInfo);
        return threadInfo.stack_base;
}


void*   
GenericThread::GetStackEnd()
{
        thread_info     threadInfo;
        GetInfo(&threadInfo);
        return threadInfo.stack_end;
}


void    
GenericThread::BeginUnit()
{
        acquire_sem(fExecuteUnitSem);
                // thread can not be paused until it releases semaphore
}


void    
GenericThread::EndUnit()
{
        release_sem(fExecuteUnitSem);
                // thread can now be paused
}