/*
 * Copyright (c) 2001-2008, Haiku, Inc.
 * Distributed under the terms of the MIT license.
 *
 * Authors:
 *              Marc Flerackers (mflerackers@androme.be)
 */

//!     Functions and class to manage input devices.

#include <stdlib.h>
#include <string.h>
#include <new>

#include <Input.h>
#include <List.h>
#include <Message.h>

#include <input_globals.h>
#include <InputServerTypes.h>


static BMessenger *sInputServer = NULL;


BInputDevice *
find_input_device(const char *name)
{
        BMessage command(IS_FIND_DEVICES);
        BMessage reply;

        command.AddString("device", name);

        status_t err = _control_input_server_(&command, &reply);

        if (err != B_OK)
                return NULL;

        BInputDevice *dev = new (std::nothrow) BInputDevice;
        if (dev == NULL)
                return NULL;

        const char *device;
        int32 type;

        reply.FindString("device", &device);
        reply.FindInt32("type", &type);

        dev->_SetNameAndType(device, (input_device_type)type);

        return dev;
}


status_t
get_input_devices(BList *list)
{
        list->MakeEmpty();

        BMessage command(IS_FIND_DEVICES);
        BMessage reply;

        status_t err = _control_input_server_(&command, &reply);

        if (err != B_OK)
                return err;

        const char *name;
        int32 type;
        int32 i = 0;

        while (reply.FindString("device", i, &name) == B_OK) {
                reply.FindInt32("type", i++, &type);

                BInputDevice *dev = new (std::nothrow) BInputDevice;
                if (dev != NULL) {
                        dev->_SetNameAndType(name, (input_device_type)type);
                        list->AddItem(dev);
                }
        }

        return err;
}


status_t
watch_input_devices(BMessenger target, bool start)
{
        BMessage command(IS_WATCH_DEVICES);
        BMessage reply;

        command.AddMessenger("target", target);
        command.AddBool("start", start);

        return _control_input_server_(&command, &reply);
}


BInputDevice::~BInputDevice()
{
        free(fName);
}


const char *
BInputDevice::Name() const
{
        return fName;
}


input_device_type
BInputDevice::Type() const
{
        return fType;
}


bool
BInputDevice::IsRunning() const
{
        if (!fName)
                return false;

        BMessage command(IS_IS_DEVICE_RUNNING);
        BMessage reply;

        command.AddString("device", fName);

        return _control_input_server_(&command, &reply) == B_OK;
}


status_t
BInputDevice::Start()
{
        if (!fName)
                return B_ERROR;

        BMessage command(IS_START_DEVICE);
        BMessage reply;

        command.AddString("device", fName);

        return _control_input_server_(&command, &reply);
}


status_t
BInputDevice::Stop()
{
        if (!fName)
                return B_ERROR;

        BMessage command(IS_STOP_DEVICE);
        BMessage reply;

        command.AddString("device", fName);

        return _control_input_server_(&command, &reply);
}


status_t
BInputDevice::Control(uint32 code, BMessage *message)
{
        if (!fName)
                return B_ERROR;

        BMessage command(IS_CONTROL_DEVICES);
        BMessage reply;

        command.AddString("device", fName);
        command.AddInt32("code", code);
        command.AddMessage("message", message);

        message->MakeEmpty();

        status_t err = _control_input_server_(&command, &reply);

        if (err == B_OK)
                reply.FindMessage("message", message);

        return err;
}


status_t
BInputDevice::Start(input_device_type type)
{
        BMessage command(IS_START_DEVICE);
        BMessage reply;

        command.AddInt32("type", type);

        return _control_input_server_(&command, &reply);
}


status_t
BInputDevice::Stop(input_device_type type)
{
        BMessage command(IS_STOP_DEVICE);
        BMessage reply;

        command.AddInt32("type", type);

        return _control_input_server_(&command, &reply);
}


status_t
BInputDevice::Control(input_device_type type, uint32 code, BMessage *message)
{
        BMessage command(IS_CONTROL_DEVICES);
        BMessage reply;

        command.AddInt32("type", type);
        command.AddInt32("code", code);
        command.AddMessage("message", message);

        message->MakeEmpty();

        status_t err = _control_input_server_(&command, &reply);

        if (err == B_OK)
                reply.FindMessage("message", message);

        return err;
}


BInputDevice::BInputDevice()
        :
        fName(NULL),
        fType(B_UNDEFINED_DEVICE)
{
}


void
BInputDevice::_SetNameAndType(const char *name, input_device_type type)
{
        if (fName) {
                free(fName);
                fName = NULL;
        }

        if (name)
                fName = strdup(name);

        fType = type;
}


status_t
_control_input_server_(BMessage *command, BMessage *reply)
{
        if (!sInputServer) {
                sInputServer = new (std::nothrow) BMessenger;
                if (!sInputServer)
                        return B_NO_MEMORY;
        }

        if (!sInputServer->IsValid())
                *sInputServer = BMessenger("application/x-vnd.Be-input_server", -1, NULL);

        status_t err = sInputServer->SendMessage(command, reply, 5000000LL, 5000000LL);

        if (err != B_OK)
                return err;

        if (reply->FindInt32("status", &err) != B_OK)
                return B_ERROR;

        return err;
}