/*
 * Copyright 2009-2011, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include <ctype.h>
#include <string.h>

#include <Drivers.h>
#include <KernelExport.h>

#include <AutoDeleter.h>

#include <kernel.h>
#include <thread.h>

#include "TestContext.h"
#include "TestManager.h"
#include "TestOutput.h"

#include "lock/LockTestSuite.h"


int32 api_version = B_CUR_DRIVER_API_VERSION;

static const char* sDeviceNames[] = {
        "kernel_unit_tests",
        NULL
};

static const char* const kUsage =
        "Usage:\n"
        "  help\n"
        "    Print usage info.\n"
        "\n"
        "  list\n"
        "    Print available tests.\n"
        "\n"
        "  run [ <options> ] [ <tests> ]\n"
        "    Run tests. The tests to be run can be given as arguments. When no "
                "tests\n"
        "        are specified, all tests are run.\n"
        "\n"
        "    Options:\n"
        "         -p    - panic(), when a test check fails.\n"
        "         -q    - Don't run any further tests after the first test failure.\n";

static TestManager* sTestManager = NULL;


// #pragma mark -


static bool
parse_command_line(char* buffer, char**& _argv, int& _argc)
{
        // Process the argument string. We split at whitespace, heeding quotes and
        // escaped characters. The processed arguments are written to the given
        // buffer, separated by single null chars.
        char* start = buffer;
        char* out = buffer;
        bool pendingArgument = false;
        int argc = 0;
        while (*start != '\0') {
                // ignore whitespace
                if (isspace(*start)) {
                        if (pendingArgument) {
                                *out = '\0';
                                out++;
                                argc++;
                                pendingArgument = false;
                        }
                        start++;
                        continue;
                }

                pendingArgument = true;

                if (*start == '"' || *start == '\'') {
                        // quoted text -- continue until closing quote
                        char quote = *start;
                        start++;
                        while (*start != '\0' && *start != quote) {
                                if (*start == '\\' && quote == '"') {
                                        start++;
                                        if (*start == '\0')
                                                break;
                                }
                                *out = *start;
                                start++;
                                out++;
                        }

                        if (*start != '\0')
                                start++;
                } else {
                        // unquoted text
                        if (*start == '\\') {
                                // escaped char
                                start++;
                                if (start == '\0')
                                        break;
                        }

                        *out = *start;
                        start++;
                        out++;
                }
        }

        if (pendingArgument) {
                *out = '\0';
                argc++;
        }

        // allocate argument vector
        char** argv = new(std::nothrow) char*[argc + 1];
        if (argv == NULL)
                return false;

        // fill vector
        start = buffer;
        for (int i = 0; i < argc; i++) {
                argv[i] = start;
                start += strlen(start) + 1;
        }
        argv[argc] = NULL;

        _argv = argv;
        _argc = argc;
        return true;
}


// #pragma mark - device hooks


static status_t
device_open(const char* name, uint32 openMode, void** _cookie)
{
        *_cookie = NULL;
        return B_OK;
}


static status_t
device_close(void* cookie)
{
        return B_OK;
}


static status_t
device_free(void* cookie)
{
        return B_OK;
}


static status_t
device_control(void* cookie, uint32 op, void* arg, size_t length)
{
        return B_BAD_VALUE;
}


static status_t
device_read(void* cookie, off_t position, void* data, size_t* numBytes)
{
        *numBytes = 0;
        return B_OK;
}


static status_t
device_write(void* cookie, off_t position, const void* data, size_t* numBytes)
{
        if (position != 0)
                return B_BAD_VALUE;

        // copy data to stack buffer
        char* buffer = (char*)malloc(*numBytes + 1);
        if (buffer == NULL)
                return B_NO_MEMORY;
        MemoryDeleter bufferDeleter(buffer);

        Thread* thread = thread_get_current_thread();
        if ((thread->flags & THREAD_FLAGS_SYSCALL) != 0) {
                if (!IS_USER_ADDRESS(data)
                        || user_memcpy(buffer, data, *numBytes) != B_OK) {
                        return B_BAD_ADDRESS;
                }
        } else
                memcpy(buffer, data, *numBytes);

        buffer[*numBytes] = '\0';

        // create an output
        TestOutput* output = new(std::nothrow) DebugTestOutput;
        if (output == NULL)
                return B_NO_MEMORY;
        ObjectDeleter<TestOutput> outputDeleter(output);

        // parse arguments
        char** argv;
        int argc;
        if (!parse_command_line(buffer, argv, argc))
                return B_NO_MEMORY;
        ArrayDeleter<char*> argvDeleter(argv);

        if (argc == 0)
                return B_BAD_VALUE;

        // execute command
        if (strcmp(argv[0], "help") == 0) {
                // print usage -- print individual lines to avoid dprintf() buffer
                // overflows
                const char* usage = kUsage;
                while (*usage != '\0') {
                        const char* lineEnd = strchr(usage, '\n');
                        if (lineEnd != NULL)
                                lineEnd++;
                        else
                                lineEnd = usage + strlen(usage);

                        output->Print("%.*s", (int)(lineEnd - usage), usage);
                        usage = lineEnd;
                }
        } else if (strcmp(argv[0], "list") == 0) {
                sTestManager->ListTests(*output);
        } else if (strcmp(argv[0], "run") == 0) {
                // parse options
                TestOptions options;
                int argi = 1;
                while (argi < argc) {
                        const char* arg = argv[argi];
                        if (*arg == '-') {
                                for (arg++; *arg != '\0'; arg++) {
                                        switch (*arg) {
                                                case 'p':
                                                        options.panicOnFailure = true;
                                                        break;
                                                case 'q':
                                                        options.quitAfterFailure = true;
                                                        break;
                                                default:
                                                        output->Print("Invalid option: \"-%c\"\n", *arg);
                                                        return B_BAD_VALUE;
                                        }
                                }

                                argi++;
                        } else
                                break;
                }

                GlobalTestContext globalContext(*output, options);
                sTestManager->RunTests(globalContext, argv + argi, argc - argi);
        } else {
                output->Print("Invalid command \"%s\"!\n", argv[0]);
                return B_BAD_VALUE;
        }

        return B_OK;
}


// #pragma mark - driver interface


static device_hooks sDeviceHooks = {
        device_open,
        device_close,
        device_free,
        device_control,
        device_read,
        device_write
};


status_t
init_hardware(void)
{
        return B_OK;
}


status_t
init_driver(void)
{
        sTestManager = new(std::nothrow) TestManager;
        if (sTestManager == NULL)
                return B_NO_MEMORY;

        // register test suites
        sTestManager->AddTest(create_lock_test_suite());

        return B_OK;
}


void
uninit_driver(void)
{
        delete sTestManager;
}


const char**
publish_devices(void)
{
        return sDeviceNames;
}


device_hooks*
find_device(const char* name)
{
        return strcmp(name, sDeviceNames[0]) == 0 ? &sDeviceHooks : NULL;
}