/*
 * Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "gesture.h"

#include <time.h>

#include <gestures/gestures.h>
#include <xorg/xf86_OSproc.h>

#include "cmt.h"
#include "properties.h"

// Helper for bit operations
#define LONG_BITS (sizeof(long) * 8)

// Implementation of inline bit operations
static inline bool TestBit(int bit, unsigned long* array)
{
    return !!(array[bit / LONG_BITS] & (1L << (bit % LONG_BITS)));
}

// This array maps input_event button types to gestures buttons
#define EVDEV_BUTTON_MAP_SIZE 7
static const int kEvdevButtonMap[EVDEV_BUTTON_MAP_SIZE][2] = {
    {BTN_LEFT, GESTURES_BUTTON_LEFT},
    {BTN_MIDDLE, GESTURES_BUTTON_MIDDLE},
    {BTN_RIGHT, GESTURES_BUTTON_RIGHT},
    {BTN_BACK, GESTURES_BUTTON_BACK},
    {BTN_SIDE, GESTURES_BUTTON_BACK},
    {BTN_FORWARD, GESTURES_BUTTON_FORWARD},
    {BTN_EXTRA, GESTURES_BUTTON_FORWARD}
};

// Conversion from kernel key codes to xorg key codes
#define MIN_KEYCODE 8

/*
 * Gestures timer functions
 */
static GesturesTimer* Gesture_TimerCreate(void*);
static void Gesture_TimerSet(void*,
                             GesturesTimer*,
                             stime_t,
                             GesturesTimerCallback,
                             void*);
static void Gesture_TimerCancel(void*, GesturesTimer*);
static void Gesture_TimerFree(void*, GesturesTimer*);

static CARD32 Gesture_TimerCallback(OsTimerPtr, CARD32, pointer);

struct GesturesTimer {
    OsTimerPtr timer;
    GesturesTimerCallback callback;
    void* callback_data;
    int is_monotonic:1;
};

static GesturesTimerProvider Gesture_GesturesTimerProvider = {
    .create_fn = Gesture_TimerCreate,
    .set_fn = Gesture_TimerSet,
    .cancel_fn = Gesture_TimerCancel,
    .free_fn = Gesture_TimerFree
};

/*
 * Callback for Gestures library.
 */
static void Gesture_Gesture_Ready(void* client_data,
                                  const struct Gesture* gesture);

static enum GestureInterpreterDeviceClass Gesture_Device_Class(EvdevClass cls);

int
Gesture_Init(GesturePtr rec, size_t max_fingers)
{
    rec->interpreter = NewGestureInterpreter();
    rec->slot_states = NULL;

    if (!rec->interpreter)
        return !Success;
    rec->fingers = malloc(max_fingers * sizeof(struct FingerState));
    if (!rec->fingers)
        goto Error_Alloc_Fingers;
    rec->mask = valuator_mask_new(MAX_VALUATORS);
    if (!rec->mask)
        goto Error_Alloc_Mask;
    return Success;

Error_Alloc_Mask:
    free(rec->fingers);
    rec->fingers = NULL;
Error_Alloc_Fingers:
    DeleteGestureInterpreter(rec->interpreter);
    rec->interpreter = NULL;
    return BadAlloc;
}

void
Gesture_Free(GesturePtr rec)
{
    // free gesture interpreter first, this will cancel all timers.
    DeleteGestureInterpreter(rec->interpreter);
    rec->interpreter = NULL;
    rec->dev = NULL;

    valuator_mask_free(&rec->mask);

    if (rec->fingers) {
        free(rec->fingers);
        rec->fingers = NULL;
    }
    if(rec->slot_states) {
        free(rec->slot_states);
        rec->slot_states = NULL;
    }
}

void
Gesture_Device_Init(GesturePtr rec, DeviceIntPtr dev)
{
    InputInfoPtr info = dev->public.devicePrivate;
    CmtDevicePtr cmt = info->private;
    CmtPropertiesPtr props = &cmt->props;
    EventStatePtr evstate = &cmt->evstate;
    struct HardwareProperties hwprops;
    EvdevPtr evdev = &cmt->evdev;
    int i;

    /* Store the device for which to generate gestures */
    rec->dev = dev;

    /* TODO: support different models */
    hwprops.left            = props->area_left;
    hwprops.top             = props->area_top;
    hwprops.right           = props->area_right;
    hwprops.bottom          = props->area_bottom;
    hwprops.res_x           = props->res_x;
    hwprops.res_y           = props->res_y;
    hwprops.screen_x_dpi    = 133;
    hwprops.screen_y_dpi    = 133;
    hwprops.orientation_minimum = props->orientation_minimum;
    hwprops.orientation_maximum = props->orientation_maximum;
    hwprops.max_finger_cnt  = evstate->slot_count;
    hwprops.max_touch_cnt   = Event_Get_Touch_Count_Max(evdev);
    hwprops.supports_t5r2   = Event_Get_T5R2(evdev);
    hwprops.support_semi_mt = Event_Get_Semi_MT(evdev);
    /* buttonpad means a physical button under the touch surface */
    hwprops.is_button_pad   = Event_Get_Button_Pad(evdev);
    hwprops.has_wheel       = TestBit(REL_WHEEL, evdev->info.rel_bitmask) ||
                              TestBit(REL_HWHEEL, evdev->info.rel_bitmask);

    GestureInterpreterSetPropProvider(rec->interpreter, &prop_provider,
                                      rec->dev);
    GestureInterpreterInitialize(
            rec->interpreter,
            Gesture_Device_Class(cmt->evdev.info.evdev_class));
    GestureInterpreterSetHardwareProperties(rec->interpreter, &hwprops);

    rec->slot_states = malloc(sizeof(int) * evstate->slot_count);
    if (!rec->slot_states) {
        ERR(info, "BadAlloc: rec->slot_states");
        return;
    }
    for (i = 0; i < evstate->slot_count; ++i)
        rec->slot_states[i] = SLOT_STATUS_FREE;
}

void
Gesture_Device_On(GesturePtr rec)
{
    GestureInterpreterSetTimerProvider(rec->interpreter,
                                       &Gesture_GesturesTimerProvider,
                                       rec->dev);
    GestureInterpreterSetCallback(rec->interpreter, &Gesture_Gesture_Ready,
                                  rec);
}

void
Gesture_Device_Off(GesturePtr rec)
{
    GestureInterpreterSetCallback(rec->interpreter, NULL, NULL);
}

void
Gesture_Device_Close(GesturePtr rec)
{
    GestureInterpreterSetPropProvider(rec->interpreter, NULL, NULL);
    GestureInterpreterSetTimerProvider(rec->interpreter, NULL, NULL);
}

void
Gesture_Process_Slots(void* vrec,
                      EventStatePtr evstate,
                      struct timeval* tv)
{
    GesturePtr rec = vrec;
    DeviceIntPtr dev = rec->dev;
    InputInfoPtr info = dev->public.devicePrivate;
    CmtDevicePtr cmt = info->private;
    EvdevPtr evdev = &cmt->evdev;
    ValuatorMask* mask = rec->mask;
    int i;
    MtSlotPtr slot;
    struct HardwareState hwstate = { 0 };
    int current_finger;
    bool has_gesture_fingers = false;
    unsigned long key_state_diff[NLONGS(KEY_CNT)];
    int code;
    int value;

    if (!rec->interpreter || ! rec->slot_states)
        return;

    /* handle changed keys */
    for (i = 0; i < NLONGS(KEY_CNT); ++i) {
        key_state_diff[i] = evdev->key_state_bitmask[i] ^
                            cmt->prev_key_state[i];
    }
    for (i = 0; i < KEY_CNT; ++i) {
        if (TestBit(i, key_state_diff)) {
            code = i + MIN_KEYCODE;
            value = TestBit(i, evdev->key_state_bitmask);
            xf86PostKeyboardEvent(dev, code, value);
        }
    }
    for (i = 0; i < NLONGS(KEY_CNT); ++i) {
        cmt->prev_key_state[i] = evdev->key_state_bitmask[i];
    }
    /* zero initialize all FingerStates to clear out previous state. */
    memset(rec->fingers, 0,
           Event_Get_Slot_Count(evdev) * sizeof(struct FingerState));

    /* clear out previous state from valuator */
    valuator_mask_zero(mask);

    if (cmt->props.raw_passthrough) {
        for (i = 0; i < evstate->slot_count; i++) {
            slot = &evstate->slots[i];

            /* send TouchEnd for lifted fingers */
            if (slot->tracking_id == -1) {
                if (rec->slot_states[i] == SLOT_STATUS_RAW) {
                    xf86PostTouchEvent(dev, i, XI_TouchEnd, 0, mask);
                }
                rec->slot_states[i] = SLOT_STATUS_FREE;
                continue;
            }

            /*
             * valuators 0 (CMT_AXIS_X) and 1 (CMT_AXIS_Y) are hardcoded into
             * X.org as finger position, so we need to set those too.
             */
            valuator_mask_set_double(mask, CMT_AXIS_MT_POSITION_X,
                                     slot->position_x);
            valuator_mask_set_double(mask, CMT_AXIS_MT_POSITION_Y,
                                     slot->position_y);
            valuator_mask_set_double(mask, CMT_AXIS_MT_PRESSURE,
                                     slot->pressure);
            valuator_mask_set_double(mask, CMT_AXIS_MT_TOUCH_MAJOR,
                                     slot->touch_major);
            valuator_mask_set_double(mask, CMT_AXIS_TOUCH_TIMESTAMP,
                                     StimeFromTimeval(tv));
            valuator_mask_set_double(mask, CMT_AXIS_X, slot->position_x);
            valuator_mask_set_double(mask, CMT_AXIS_Y, slot->position_y);

            if (rec->slot_states[i] == SLOT_STATUS_RAW) {
                xf86PostTouchEvent(dev, i, XI_TouchUpdate, 0, mask);
            } else {
                /* take over STATUS_GESTURE slots too */
                if (rec->slot_states[i] == SLOT_STATUS_GESTURE)
                    has_gesture_fingers = true;
                xf86PostTouchEvent(dev, i, XI_TouchBegin, 0, mask);

            }
            rec->slot_states[i] = SLOT_STATUS_RAW;
        }

        if (has_gesture_fingers) {
            /* push empty hardware state to clear interpreter state */
            hwstate.timestamp = StimeFromTimeval(tv);
            GestureInterpreterPushHardwareState(rec->interpreter, &hwstate);
        }
        return;
    }

    current_finger = 0;
    for (i = 0; i < evstate->slot_count; i++) {
        slot = &evstate->slots[i];
        if (slot->tracking_id == -1) {
            rec->slot_states[i] = SLOT_STATUS_FREE;
            continue;
        }

        if (rec->slot_states[i] == SLOT_STATUS_FREE) {
            rec->slot_states[i] = SLOT_STATUS_GESTURE;
        } else if (rec->slot_states[i] == SLOT_STATUS_RAW) {
            /* ignore any fingers that are still present from raw mode */
            continue;
        }

        rec->fingers[current_finger].touch_major = (float)slot->touch_major;
        rec->fingers[current_finger].touch_minor = (float)slot->touch_minor;
        rec->fingers[current_finger].width_major = (float)slot->width_major;
        rec->fingers[current_finger].width_minor = (float)slot->width_minor;
        rec->fingers[current_finger].pressure    = (float)slot->pressure;
        rec->fingers[current_finger].orientation = (float)slot->orientation;
        rec->fingers[current_finger].position_x  = (float)slot->position_x;
        rec->fingers[current_finger].position_y  = (float)slot->position_y;
        rec->fingers[current_finger].tracking_id = slot->tracking_id;
        current_finger++;
    }
    hwstate.timestamp = StimeFromTimeval(tv);

    for (i = 0; i < EVDEV_BUTTON_MAP_SIZE; ++i) {
        if (Event_Get_Button(evdev, kEvdevButtonMap[i][0]))
            hwstate.buttons_down |= kEvdevButtonMap[i][1];
    }

    hwstate.touch_cnt = Event_Get_Touch_Count(evdev);
    hwstate.finger_cnt = current_finger;
    hwstate.fingers = rec->fingers;
    hwstate.rel_x = evstate->rel_x;
    hwstate.rel_y = evstate->rel_y;
    hwstate.rel_wheel = evstate->rel_wheel;
    hwstate.rel_hwheel = evstate->rel_hwheel;
    GestureInterpreterPushHardwareState(rec->interpreter, &hwstate);
}

static void SetTimeValues(ValuatorMask* mask,
                          const struct Gesture* gesture,
                          DeviceIntPtr dev,
                          BOOL is_absolute)
{
    double start_time = gesture->start_time;
    double end_time = gesture->end_time;

    if (!is_absolute) {
        /*
         * We send the movement axes as relative values, which causes the
         * times to be sent as relative values too. This code computes the
         * right relative values.
         */
        start_time -= dev->last.valuators[CMT_AXIS_DBL_START_TIME];
        end_time -= dev->last.valuators[CMT_AXIS_DBL_END_TIME];
    }

    valuator_mask_set_double(mask, CMT_AXIS_DBL_START_TIME, start_time);
    valuator_mask_set_double(mask, CMT_AXIS_DBL_END_TIME, end_time);
}

static void SetOrdinalValues(ValuatorMask* mask,
                             DeviceIntPtr dev,
                             float x,
                             float y,
                             BOOL is_absolute) {
    if (!is_absolute) {
        /*
         * We send the movement axes as relative values, which causes the
         * times to be sent as relative values too. This code computes the
         * right relative values.
         */
        x -= dev->last.valuators[CMT_AXIS_ORDINAL_X];
        y -= dev->last.valuators[CMT_AXIS_ORDINAL_Y];
    }

    valuator_mask_set_double(mask, CMT_AXIS_ORDINAL_X, x);
    valuator_mask_set_double(mask, CMT_AXIS_ORDINAL_Y, y);
}

static void Gesture_Gesture_Ready(void* client_data,
                                  const struct Gesture* gesture)
{
    GesturePtr rec = client_data;
    DeviceIntPtr dev = rec->dev;
    ValuatorMask* mask = rec->mask;
    InputInfoPtr info = dev->public.devicePrivate;
    CmtDevicePtr cmt = info->private;

    if (cmt->props.raw_passthrough) {
        DBG(info, "Gesture Suppressed");
        return;
    }

    DBG(info, "Gesture Start: %f End: %f \n",
        gesture->start_time, gesture->end_time);

    valuator_mask_zero(mask);
    switch (gesture->type) {
        case kGestureTypeContactInitiated:
            /* TODO(adlr): handle contact initiated */
            break;
        case kGestureTypeMove: {
            const GestureMove* move = &gesture->details.move;
            DBG(info, "Gesture Move: (%f, %f) [%f, %f]\n",
                move->dx, move->dy, move->ordinal_dx, move->ordinal_dy);
            valuator_mask_set_double(mask, CMT_AXIS_X, move->dx);
            valuator_mask_set_double(mask, CMT_AXIS_Y, move->dy);
            SetTimeValues(mask, gesture, dev, FALSE);
            SetOrdinalValues(mask,
                             dev,
                             move->ordinal_dx,
                             move->ordinal_dy,
                             FALSE);
            xf86PostMotionEventM(dev, FALSE, mask);
            break;
        }
        case kGestureTypeScroll: {
            const GestureScroll* scroll = &gesture->details.scroll;
            DBG(info, "Gesture Scroll: (%f, %f) [%f, %f]\n",
                scroll->dx, scroll->dy, scroll->ordinal_dx, scroll->ordinal_dy);
            valuator_mask_set_double(mask, CMT_AXIS_SCROLL_X, scroll->dx);
            valuator_mask_set_double(mask, CMT_AXIS_SCROLL_Y, scroll->dy);
            valuator_mask_set_double(mask, CMT_AXIS_FINGER_COUNT, 2.0);
            SetTimeValues(mask, gesture, dev, TRUE);
            SetOrdinalValues(mask,
                             dev,
                             scroll->ordinal_dx,
                             scroll->ordinal_dy,
                             TRUE);
            xf86PostMotionEventM(dev, TRUE, mask);
            break;
        }
        case kGestureTypeButtonsChange: {
            const GestureButtonsChange* buttons = &gesture->details.buttons;
            DBG(info, "Gesture Button Change: down=0x%02x up=0x%02x\n",
                buttons->down, buttons->up);
            SetTimeValues(mask, gesture, dev, TRUE);
            if (buttons->down & GESTURES_BUTTON_LEFT)
                xf86PostButtonEventM(dev, TRUE, CMT_BTN_LEFT, 1, mask);
            if (buttons->down & GESTURES_BUTTON_MIDDLE)
                xf86PostButtonEventM(dev, TRUE, CMT_BTN_MIDDLE, 1, mask);
            if (buttons->down & GESTURES_BUTTON_RIGHT)
                xf86PostButtonEventM(dev, TRUE, CMT_BTN_RIGHT, 1, mask);
            if (buttons->down & GESTURES_BUTTON_BACK)
                xf86PostButtonEventM(dev, TRUE, CMT_BTN_BACK, 1, mask);
            if (buttons->down & GESTURES_BUTTON_FORWARD)
                xf86PostButtonEventM(dev, TRUE, CMT_BTN_FORWARD, 1, mask);
            if (buttons->up & GESTURES_BUTTON_LEFT)
                xf86PostButtonEventM(dev, TRUE, CMT_BTN_LEFT, 0, mask);
            if (buttons->up & GESTURES_BUTTON_MIDDLE)
                xf86PostButtonEventM(dev, TRUE, CMT_BTN_MIDDLE, 0, mask);
            if (buttons->up & GESTURES_BUTTON_RIGHT)
                xf86PostButtonEventM(dev, TRUE, CMT_BTN_RIGHT, 0, mask);
            if (buttons->up & GESTURES_BUTTON_BACK)
                xf86PostButtonEventM(dev, TRUE, CMT_BTN_BACK, 0, mask);
            if (buttons->up & GESTURES_BUTTON_FORWARD)
                xf86PostButtonEventM(dev, TRUE, CMT_BTN_FORWARD, 0, mask);
            break;
        }
        case kGestureTypeFling: {
            const GestureFling* fling = &gesture->details.fling;
            DBG(info, "Gesture Fling: (%f, %f) [%f, %f] fling_state=%d\n",
                fling->vx, fling->vy, fling->ordinal_vx, fling->ordinal_vy,
                fling->fling_state);
            valuator_mask_set_double(mask, CMT_AXIS_DBL_FLING_VX, fling->vx);
            valuator_mask_set_double(mask, CMT_AXIS_DBL_FLING_VY, fling->vy);
            valuator_mask_set(mask, CMT_AXIS_FLING_STATE, fling->fling_state);
            SetTimeValues(mask, gesture, dev, TRUE);
            SetOrdinalValues(mask,
                             dev,
                             fling->ordinal_vx,
                             fling->ordinal_vy,
                             TRUE);
            xf86PostMotionEventM(dev, TRUE, mask);
            break;
        }
        case kGestureTypeSwipe: {
            const GestureSwipe* swipe = &gesture->details.swipe;
            DBG(info, "Gesture Swipe: (%f, %f) [%f, %f]\n",
                swipe->dx, swipe->dy, swipe->ordinal_dx, swipe->ordinal_dy);
            valuator_mask_set_double(mask, CMT_AXIS_SCROLL_X, swipe->dx);
            valuator_mask_set_double(mask, CMT_AXIS_SCROLL_Y, swipe->dy);
            valuator_mask_set_double(mask, CMT_AXIS_FINGER_COUNT, 3.0);
            SetTimeValues(mask, gesture, dev, TRUE);
            SetOrdinalValues(mask,
                             dev,
                             swipe->ordinal_dx,
                             swipe->ordinal_dy,
                             TRUE);
            xf86PostMotionEventM(dev, TRUE, mask);
            break;
        }
        case kGestureTypeSwipeLift:
            DBG(info, "Gesture Swipe Lift\n");
            // Turn a swipe lift into a fling start.
            SetTimeValues(mask, gesture, dev, TRUE);
            valuator_mask_set_double(mask, CMT_AXIS_DBL_FLING_VX, 0);
            valuator_mask_set_double(mask, CMT_AXIS_DBL_FLING_VY, 0);
            valuator_mask_set(mask, CMT_AXIS_FLING_STATE, 0);
            xf86PostMotionEventM(dev, TRUE, mask);
            break;
        case kGestureTypePinch: {
            const GesturePinch* pinch = &gesture->details.pinch;
            DBG(info, "Gesture Pinch: dz=%f [%f]\n",
                pinch->dz, pinch->ordinal_dz);
            break;
        }
        case kGestureTypeMetrics: {
            const GestureMetrics* metrics = &gesture->details.metrics;
            DBG(info, "Gesture Metrics: [%f, %f] type=%d\n",
                metrics->data[0], metrics->data[1], metrics->type);
            valuator_mask_set_double(mask, CMT_AXIS_METRICS_DATA1,
                metrics->data[0]);
            valuator_mask_set_double(mask, CMT_AXIS_METRICS_DATA2,
                metrics->data[1]);
            valuator_mask_set(mask, CMT_AXIS_METRICS_TYPE, metrics->type);
            SetTimeValues(mask, gesture, dev, TRUE);
            xf86PostMotionEventM(dev, TRUE, mask);
            break;
        }
        default:
            ERR(info, "Unrecognized gesture type (%u)\n", gesture->type);
            break;
    }
}

static GesturesTimer*
Gesture_TimerCreate(void* provider_data)
{
    DeviceIntPtr dev = provider_data;
    InputInfoPtr info = dev->public.devicePrivate;
    CmtDevicePtr cmt = info->private;
    GesturesTimer* timer = (GesturesTimer*)calloc(1, sizeof(GesturesTimer));
    if (!timer)
        return NULL;
    timer->timer = TimerSet(NULL, 0, 0, NULL, 0);
    if (!timer->timer) {
        free(timer);
        return NULL;
    }
    timer->is_monotonic = cmt->evdev.info.is_monotonic;
    return timer;
}

static void
Gesture_TimerSet(void* provider_data,
                 GesturesTimer* timer,
                 stime_t delay,
                 GesturesTimerCallback callback,
                 void* callback_data)
{
    CARD32 ms = delay * 1000.0;

    if (!timer)
        return;
    timer->callback = callback;
    timer->callback_data = callback_data;
    if (ms == 0)
        ms = 1;
    TimerSet(timer->timer, 0, ms, Gesture_TimerCallback, timer);
}

static void
Gesture_TimerCancel(void* provider_data, GesturesTimer* timer)
{
    TimerCancel(timer->timer);
}

static void
Gesture_TimerFree(void* provider_data, GesturesTimer* timer)
{
    TimerFree(timer->timer);
    timer->timer = NULL;
    free(timer);
}

static CARD32
Gesture_TimerCallback(OsTimerPtr timer,
                      CARD32 millis,
                      pointer callback_data)
{
    GesturesTimer* tm = callback_data;
    stime_t now;
    stime_t rc;
    CARD32 next_timeout = 0;

    if (tm->is_monotonic) {
      struct timespec ts;
      clock_gettime(CLOCK_MONOTONIC, &ts);
      now = StimeFromTimespec(&ts);
    } else {
      struct timeval tv;
      gettimeofday(&tv, NULL);
      now = StimeFromTimeval(&tv);
    }

    rc = tm->callback(now, tm->callback_data);
    if (rc >= 0.0) {
        next_timeout = rc * 1000.0;
        if (next_timeout == 0)
            next_timeout = 1;
    }

    return next_timeout;
}

static enum GestureInterpreterDeviceClass
Gesture_Device_Class(EvdevClass cls) {
  switch (cls) {
    case EvdevClassMouse:
      return GESTURES_DEVCLASS_MOUSE;
    case EvdevClassMultitouchMouse:
      return GESTURES_DEVCLASS_MULTITOUCH_MOUSE;
    case EvdevClassTouchpad:
      return GESTURES_DEVCLASS_TOUCHPAD;
    case EvdevClassTouchscreen:
      return GESTURES_DEVCLASS_TOUCHSCREEN;
    default:
      return GESTURES_DEVCLASS_UNKNOWN;
  }
}

_X_EXPORT void gestures_log(int verb, const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);
  if (verb > 0)
    xf86VDrvMsgVerb(-1, X_INFO, 7, fmt, args);
  else
    xf86VDrvMsgVerb(-1, X_ERROR, 0, fmt, args);
  va_end(args);
}