// PipedAppRunner.cpp

#include <errno.h>
#include <unistd.h>

#include <Autolock.h>
#include <String.h>

#include <TestShell.h>
#include <TestUtils.h>
#include <cppunit/TestAssert.h>

#include "PipedAppRunner.h"

// constructor
PipedAppRunner::PipedAppRunner()
                          : fOutputLock(),
                                fPipe(NULL),
                                fOutput(),
                                fReader(-1)
{
}

// destructor
PipedAppRunner::~PipedAppRunner()
{
        if (fReader >= 0) {
                _ClosePipe();
                int32 result;
                wait_for_thread(fReader, &result);
        }
}

// Run
status_t
PipedAppRunner::Run(const char *command, const char *args, bool findCommand)
{
        status_t error = (HasQuitted() ? B_OK : B_ERROR);
        // get the app path
        BString appPath;
        if (findCommand) {
                appPath = BTestShell::GlobalTestDir();
                appPath.CharacterEscape(" \t\n!\"'`$&()?*+{}[]<>|", '\\');
                appPath += "/";
                appPath += command;
                #ifdef TEST_R5
                        appPath += "_r5";
                #endif
                command = appPath.String();
        }
        // add args, i.e. compose the command line
        BString cmdLine(command);
        if (args) {
                cmdLine += " ";
                cmdLine += args;
        }
        // run the command
        if (error == B_OK) {
                fPipe = popen(cmdLine.String(), "r");
                if (!fPipe)
                        error = errno;
        }
        // spawn the reader thread
        if (error == B_OK) {
                fReader = spawn_thread(&_ReaderEntry, "PipedAppRunner reader",
                                                           B_NORMAL_PRIORITY, (void*)this);
                if (fReader >= 0)
                        error = resume_thread(fReader);
                else
                        error = fReader;
        }
        // cleanup on error
        if (error != B_OK) {
                if (fReader >= 0) {
                        kill_thread(fReader);
                        fReader = -1;
                }
                if (fPipe) {
                        pclose(fPipe);
                        fPipe = NULL;
                }
        }
        return error;
}

// HasQuitted
bool
PipedAppRunner::HasQuitted()
{
        BAutolock locker(fOutputLock);
        return !fPipe;
}

// WaitFor
void
PipedAppRunner::WaitFor()
{
        while (!HasQuitted())
                snooze(10000);
}

// GetOutput
status_t
PipedAppRunner::GetOutput(BString *buffer)
{
        status_t error = (buffer ? B_OK : B_BAD_VALUE);
        if (error == B_OK) {
                BAutolock locker(fOutputLock);
                size_t size = fOutput.BufferLength();
                const void *output = fOutput.Buffer();
                if (size > 0)
                        buffer->SetTo((const char*)output, size);
                else
                        *buffer = "";
        }
        return error;
}

// ReadOutput
ssize_t
PipedAppRunner::ReadOutput(void *buffer, size_t size)
{
        BAutolock locker(fOutputLock);
        return fOutput.Read(buffer, size);
}

// ReadOutputAt
ssize_t
PipedAppRunner::ReadOutputAt(off_t position, void *buffer, size_t size)
{
        BAutolock locker(fOutputLock);
        return fOutput.ReadAt(position, buffer, size);
}

// _ReaderEntry
int32
PipedAppRunner::_ReaderEntry(void *data)
{
        int32 result = 0;
        if (PipedAppRunner *me = (PipedAppRunner*)data)
                result = me->_ReaderLoop();
        return result;
}

// _ReaderLoop
int32
PipedAppRunner::_ReaderLoop()
{
        char buffer[10240];
        fOutputLock.Lock();
        FILE *pipe = fPipe;
        fOutputLock.Unlock();
        while (!feof(pipe)) {
                size_t bytes = fread(buffer, 1, sizeof(buffer), pipe);
                if (bytes > 0) {
                        BAutolock locker(fOutputLock);
                        off_t oldPosition = fOutput.Seek(0, SEEK_END);
                        fOutput.Write(buffer, bytes);
                        fOutput.Seek(oldPosition, SEEK_SET);
                }
        }
        _ClosePipe();
        return 0;
}

// _ClosePipe
void
PipedAppRunner::_ClosePipe()
{
        if (fOutputLock.Lock()) {
                if (fPipe) {
                        pclose(fPipe);
                        fPipe = NULL;
                }
                fOutputLock.Unlock();
        }
}