/*
 * Copyright 2005-2008 Stephan Aßmus <superstippi@gmx.de>. All rights reserved.
 * Distributed under the terms of the MIT license.
 */
#include "MasterServerDevice.h"

#include <fstream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <Directory.h>
#include <Entry.h>
#include <InterfaceDefs.h>
#include <Message.h>
#include <NodeMonitor.h>
#include <OS.h>
#include <Path.h>
#include <Screen.h>
#include <View.h>
#include <File.h>

#include "PointingDevice.h"
#include "PointingDeviceFactory.h"

#define DEFAULT_CLICK_SPEED 250000

static const char* kWatchFolder                 = "input/wacom/usb";
static const char* kDeviceFolder                = "/dev/input/wacom/usb";
static const char* kDeviceName                  = "Wacom Tablet";

//static const char* kPS2MouseThreadName        = "PS/2 Mouse";

// instantiate_input_device
//
// this is where it all starts make sure this function is exported!
BInputServerDevice*
instantiate_input_device()
{
        return (new MasterServerDevice());
}

// constructor
MasterServerDevice::MasterServerDevice()
        : BInputServerDevice(),
          fDevices(1),
          fActive(false),
          fDblClickSpeed(DEFAULT_CLICK_SPEED),
          fPS2DisablerThread(B_ERROR),
          fDeviceLock("device list lock")
{
        get_mouse_speed(kDeviceName, &fSpeed);
        get_mouse_acceleration(kDeviceName, &fAcceleration);
        get_click_speed(kDeviceName, &fDblClickSpeed);
        _CalculateAccelerationTable();

        if (_LockDevices()) {
                // do an initial scan of the devfs folder, after that, we should receive
                // node monitor messages for hotplugging support
                _SearchDevices();
        
                fActive = true;
        
                for (int32 i = 0; PointingDevice* device = (PointingDevice*)fDevices.ItemAt(i); i++) {
                        device->Start();
                }
                _UnlockDevices();
        }

        StartMonitoringDevice(kWatchFolder);
}

// destructor
MasterServerDevice::~MasterServerDevice()
{
        // cleanup
        _StopAll();
        if (_LockDevices()) {
                while (PointingDevice* device = (PointingDevice*)fDevices.RemoveItem((int32)0))
                        delete device;
                _UnlockDevices();
        }
}

// InitCheck
status_t
MasterServerDevice::InitCheck()
{
        return BInputServerDevice::InitCheck();
}

// SystemShuttingDown
status_t
MasterServerDevice::SystemShuttingDown()
{
        // the devices should be stopped anyways,
        // but this is just defensive programming.
        // the pointing devices will have spawned polling threads,
        // we make sure that we block until every thread has bailed out.

        _StopAll();

        PRINT(("---------------------------------\n\n"));

        return (BInputServerDevice::SystemShuttingDown());
}

// Start
//
// start generating events
status_t
MasterServerDevice::Start(const char* device, void* cookie)
{
        // TODO: make this configurable
//      _StartPS2DisablerThread();

        return B_OK;
}

// Stop
status_t
MasterServerDevice::Stop(const char* device, void* cookie)
{
        // stop generating events
        fActive = false;

        _StopAll();

//      _StopPS2DisablerThread();

        return StopMonitoringDevice(kWatchFolder);
}

// Control
status_t
MasterServerDevice::Control(const char* device, void* cookie, uint32 code, BMessage* message)
{
        // respond to changes in the system
        switch (code) {
                case B_MOUSE_SPEED_CHANGED:
                        get_mouse_speed(device, &fSpeed);
                        _CalculateAccelerationTable();
                        break;
                case B_CLICK_SPEED_CHANGED:
                        get_click_speed(device, &fDblClickSpeed);
                        break;
                case B_MOUSE_ACCELERATION_CHANGED:
                        get_mouse_acceleration(device, &fAcceleration);
                        _CalculateAccelerationTable();
                        break;
                case B_NODE_MONITOR:
                        _HandleNodeMonitor(message);
                        break;
                default:
                        BInputServerDevice::Control(device, cookie, code, message);
                        break;
        }
        return B_OK;
}

// #pragma mark -

// _SearchDevices
void
MasterServerDevice::_SearchDevices()
{
        if (_LockDevices()) {
                // construct a PointingDevice for every devfs entry we find
                BDirectory dir(kDeviceFolder);
                if (dir.InitCheck() >= B_OK) {
                        // traverse the contents of the folder to see if the
                        // entry of that device still exists
                        entry_ref ref;
                        while (dir.GetNextRef(&ref) >= B_OK) {
                                PRINT(("examining devfs entry '%s'\n", ref.name));
                                // don't add the control device
                                if (strcmp(ref.name, "control") != 0) {
                                        BPath path(&ref);
                                        if (path.InitCheck() >= B_OK) {
                                                // add the device
                                                _AddDevice(path.Path());
                                        }
                                }
                        }
                } else
                        PRINT(("folder '%s' not found\n", kDeviceFolder));
        
                PRINT(("done examing devfs\n"));
                _UnlockDevices();
        }
}

// _StopAll
void
MasterServerDevice::_StopAll()
{
        if (_LockDevices()) {
                for (int32 i = 0; PointingDevice* device
                                = (PointingDevice*)fDevices.ItemAt(i); i++)
                        device->Stop();
                _UnlockDevices();
        }
}

// _AddDevice
void
MasterServerDevice::_AddDevice(const char* path)
{
        if (_LockDevices()) {
                // get the device from the factory
                PointingDevice* device = PointingDeviceFactory::DeviceFor(this, path);
                // add it to our list
                if (device && device->InitCheck() >= B_OK
                        && fDevices.AddItem((void*)device)) {
                        PRINT(("pointing device added (%s)\n", path));
                        // start device polling only if we're started
                        if (fActive)
                                device->Start();
                        input_device_ref device = { (char*)kDeviceName, B_POINTING_DEVICE, (void*)this };
                        input_device_ref* deviceList[2] = { &device, NULL };
                        RegisterDevices(deviceList);
                } else {
        
                        PRINT(("pointing device not added (%s)\n", path));
                        if (device) {
                                PRINT(("  vendor: %0*x, product: %0*x\n", 4, device->VendorID(),
                                        4, device->ProductID()));
                        }
        
                        delete device;
                }
                _UnlockDevices();
        }
}

// _HandleNodeMonitor
void
MasterServerDevice::_HandleNodeMonitor(BMessage* message)
{
        int32 opcode;
        if (message->FindInt32("opcode", &opcode) < B_OK)
                return;

        switch (opcode) {
                case B_ENTRY_CREATED:
                        // extract info to create an entry_ref structure
                        const char* name;
                        ino_t directory;
                        dev_t device;
                        if (message->FindString("name", &name) >= B_OK
                                && strcmp(name, "control") != 0
                                && message->FindInt64("directory", (int64*)&directory) >= B_OK
                                && message->FindInt32("device", (int32*)&device) >= B_OK) {
                                // make a path from that info
                                entry_ref ref(device, directory, name);
                                BPath path(&ref);
                                if (path.InitCheck() >= B_OK) {
                                        // add the device
                                        _AddDevice(path.Path());
                                }
                        }
                        break;
                case B_ENTRY_REMOVED: {
                        // I cannot figure out how to see if this is actually
                        // the directory that we're node monitoring, and even if it is,
                        // we would have to look at the directories contents to
                        // see which PointingDevice we might want to remove
                        BDirectory dir(kDeviceFolder);
                        if (dir.InitCheck() >= B_OK) {
                                // for each device in our list, see if the corresponding
                                // entry in the device folder still exists
                                for (int32 i = 0; PointingDevice* pointingDevice
                                                = (PointingDevice*)fDevices.ItemAt(i); i++) {
                                        // traverse the contents of the folder
                                        // if the entry for this device is there,
                                        // we can abort the search
                                        entry_ref ref;
                                        dir.Rewind();
                                        bool found = false;
                                        while (dir.GetNextRef(&ref) >= B_OK) {
                                                BPath path(&ref);
                                                if (strcmp(pointingDevice->DevicePath(),
                                                                path.Path()) == 0) {
                                                        found = true;
                                                        break;
                                                }
                                        }
                                        // remove the device if the devfs entry was not found
                                        if (!found) {

                                                PRINT(("removing device '%s'\n", pointingDevice->DevicePath()));

                                                if (_LockDevices()) {
                                                        if (fDevices.RemoveItem((void*)pointingDevice)) {
                                                                
                                                                delete pointingDevice;
                                                                i--;
                                                        }
                                                        _UnlockDevices();
                                                }
                                        }
                                }
                        }
                        break;
                }
        }
}

// _CalculateAccelerationTable
//
// calculates the acceleration table. This is recalculated anytime we find out that
// the current acceleration or speed has changed.
void
MasterServerDevice::_CalculateAccelerationTable()
{
        // This seems to work alright.
        for (int x = 1; x <= 128; x++){
                fAccelerationTable[x] = (x / (128 * (1 - (((float)fSpeed + 8192) / 262144))))
                        * (x / (128 * (1 - (((float)fSpeed + 8192) / 262144))))
                        + ((((float)fAcceleration + 4000) / 262144)
                        * (x / (128 * (1 - (((float)fSpeed + 8192) / 262144)))));
        }
        
        // sets the bottom of the table to be the inverse of the first half.
        // position 0 -> 128 positive movement, 255->129 negative movement
        for (int x = 255; x > 128; x--){
                fAccelerationTable[x] = -(fAccelerationTable[(255 - x)]);
        }
        
        // Location 0 will be 0.000, which is unacceptable, otherwise, single step moves are lost
        // To work around this, we'll make it 1/2 of the smallest increment.
        fAccelerationTable[0] = fAccelerationTable[1] / 2;
        fAccelerationTable[255] = -fAccelerationTable[0];
}

// _ps2_disabler
//
// find the PS/2 device thread and suspend its execution
// TODO: make this configurable
// In case you're wondering... this behaviour is useful for notebook
// users who are annoyed by accidentally hitting their touchpad while
// typing. "Turning it off entirely" by suspending the PS/2 thread is
// just a compfort thing, but should of course be made configurable...
//int32
//MasterServerDevice::_ps2_disabler(void* cookie)
//{
//      MasterServerDevice* master = (MasterServerDevice*)cookie;
//      
//      thread_id haltedThread = B_ERROR;
//
//      while (master->fActive) {
//              // search for at least one running device
//              bool suspendPS2 = false;
//              if (master->_LockDevices()) {
//                      for (int32 i = 0; PointingDevice* device = (PointingDevice*)master->fDevices.ItemAt(i); i++) {
//                              if (device->DisablePS2()) {
//                                      suspendPS2 = true;
//                                      break;
//                              }
//                      }
//                      master->_UnlockDevices();
//              }
//
//              if (suspendPS2){
//                      // find and suspend PS/2 thread (if not already done)
//                      if (haltedThread < B_OK) {
//                              haltedThread = find_thread(kPS2MouseThreadName);
//                              if (haltedThread >= B_OK) {
//                                      suspend_thread(haltedThread);
//                              }
//                      }
//              } else {
//                      // reenable PS/2 thread
//                      if (haltedThread >= B_OK) {
//                              resume_thread(haltedThread);
//                              haltedThread = B_ERROR;
//                      }
//              }
//
//              // sleep a little while
//              snooze(2000000);
//      }
//
//      // reenable PS/2 thread in any case before we die
//      if (haltedThread >= B_OK) {
//              resume_thread(haltedThread);
//      }
//
//      return B_OK;
//}
//
//// _StartPS2DisablerThread
//void
//MasterServerDevice::_StartPS2DisablerThread()
//{
//      if (fPS2DisablerThread < B_OK) {
//              fPS2DisablerThread = spawn_thread(_ps2_disabler, "PS/2 Mouse disabler", B_LOW_PRIORITY, this);
//              if (fPS2DisablerThread >= B_OK)
//                      resume_thread(fPS2DisablerThread);
//      }
//}
//
//// _StopPS2DisablerThread
//void
//MasterServerDevice::_StopPS2DisablerThread()
//{
//      if (fPS2DisablerThread >= B_OK) {
//              status_t err;
//              wait_for_thread(fPS2DisablerThread, &err);
//      }
//      fPS2DisablerThread = B_ERROR;
//}

// _LockDevices
bool
MasterServerDevice::_LockDevices()
{
        return fDeviceLock.Lock();
}

// _UnlockDevices
void
MasterServerDevice::_UnlockDevices()
{
        fDeviceLock.Unlock();
}