// Copyright 2014 The Chromium 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 "mojo/converters/input_events/input_events_type_converters.h"

#include <climits>

#if defined(USE_X11)
#include <X11/extensions/XInput2.h>
#include <X11/Xlib.h>
#endif

#include "mojo/converters/geometry/geometry_type_converters.h"
#include "mojo/converters/input_events/mojo_extended_key_event_data.h"
#include "mojo/services/input_events/public/interfaces/input_events.mojom.h"
#include "ui/events/keycodes/keyboard_codes.h"

namespace mojo {
namespace {

ui::EventType MojoMouseEventTypeToUIEvent(const EventPtr& event) {
  DCHECK(!event->pointer_data.is_null());
  DCHECK_EQ(POINTER_KIND_MOUSE, event->pointer_data->kind);
  switch (event->action) {
    case EVENT_TYPE_POINTER_DOWN:
      return ui::ET_MOUSE_PRESSED;

    case EVENT_TYPE_POINTER_UP:
      return ui::ET_MOUSE_RELEASED;

    case EVENT_TYPE_POINTER_MOVE:
      DCHECK(event->pointer_data);
      if (event->pointer_data->horizontal_wheel != 0 ||
          event->pointer_data->vertical_wheel != 0) {
        return ui::ET_MOUSEWHEEL;
      }
      if (event->flags &
          (EVENT_FLAGS_LEFT_MOUSE_BUTTON | EVENT_FLAGS_MIDDLE_MOUSE_BUTTON |
           EVENT_FLAGS_RIGHT_MOUSE_BUTTON)) {
        return ui::ET_MOUSE_DRAGGED;
      }
      return ui::ET_MOUSE_MOVED;

    default:
      NOTREACHED();
  }

  return ui::ET_MOUSE_RELEASED;
}

ui::EventType MojoTouchEventTypeToUIEvent(const EventPtr& event) {
  DCHECK(!event->pointer_data.is_null());
  DCHECK_EQ(POINTER_KIND_TOUCH, event->pointer_data->kind);
  switch (event->action) {
    case EVENT_TYPE_POINTER_DOWN:
      return ui::ET_TOUCH_PRESSED;

    case EVENT_TYPE_POINTER_UP:
      return ui::ET_TOUCH_RELEASED;

    case EVENT_TYPE_POINTER_MOVE:
      return ui::ET_TOUCH_MOVED;

    case EVENT_TYPE_POINTER_CANCEL:
      return ui::ET_TOUCH_CANCELLED;

    default:
      NOTREACHED();
  }

  return ui::ET_TOUCH_CANCELLED;
}

void SetPointerDataLocationFromEvent(const ui::LocatedEvent& located_event,
                                     PointerData* pointer_data) {
  pointer_data->x = located_event.location_f().x();
  pointer_data->y = located_event.location_f().y();
  pointer_data->screen_x = located_event.root_location_f().x();
  pointer_data->screen_y = located_event.root_location_f().y();
}

}  // namespace

COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_NONE) ==
               static_cast<int32>(ui::EF_NONE),
               event_flags_should_match);
COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_CAPS_LOCK_DOWN) ==
               static_cast<int32>(ui::EF_CAPS_LOCK_DOWN),
               event_flags_should_match);
COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_SHIFT_DOWN) ==
               static_cast<int32>(ui::EF_SHIFT_DOWN),
               event_flags_should_match);
COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_CONTROL_DOWN) ==
               static_cast<int32>(ui::EF_CONTROL_DOWN),
               event_flags_should_match);
COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_ALT_DOWN) ==
               static_cast<int32>(ui::EF_ALT_DOWN),
               event_flags_should_match);
COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_LEFT_MOUSE_BUTTON) ==
               static_cast<int32>(ui::EF_LEFT_MOUSE_BUTTON),
               event_flags_should_match);
COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_MIDDLE_MOUSE_BUTTON) ==
               static_cast<int32>(ui::EF_MIDDLE_MOUSE_BUTTON),
               event_flags_should_match);
COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_RIGHT_MOUSE_BUTTON) ==
               static_cast<int32>(ui::EF_RIGHT_MOUSE_BUTTON),
               event_flags_should_match);
COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_COMMAND_DOWN) ==
               static_cast<int32>(ui::EF_COMMAND_DOWN),
               event_flags_should_match);
COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_EXTENDED) ==
               static_cast<int32>(ui::EF_EXTENDED),
               event_flags_should_match);
COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_IS_SYNTHESIZED) ==
               static_cast<int32>(ui::EF_IS_SYNTHESIZED),
               event_flags_should_match);
COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_ALTGR_DOWN) ==
               static_cast<int32>(ui::EF_ALTGR_DOWN),
               event_flags_should_match);
COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_MOD3_DOWN) ==
               static_cast<int32>(ui::EF_MOD3_DOWN),
               event_flags_should_match);


// static
EventType TypeConverter<EventType, ui::EventType>::Convert(ui::EventType type) {
  switch (type) {
    case ui::ET_MOUSE_PRESSED:
    case ui::ET_TOUCH_PRESSED:
      return EVENT_TYPE_POINTER_DOWN;

    case ui::ET_MOUSE_DRAGGED:
    case ui::ET_MOUSE_MOVED:
    case ui::ET_MOUSE_ENTERED:
    case ui::ET_MOUSE_EXITED:
    case ui::ET_TOUCH_MOVED:
    case ui::ET_MOUSEWHEEL:
      return EVENT_TYPE_POINTER_MOVE;

    case ui::ET_MOUSE_RELEASED:
    case ui::ET_TOUCH_RELEASED:
      return EVENT_TYPE_POINTER_UP;

    case ui::ET_TOUCH_CANCELLED:
      return EVENT_TYPE_POINTER_CANCEL;

    case ui::ET_KEY_PRESSED:
      return EVENT_TYPE_KEY_PRESSED;

    case ui::ET_KEY_RELEASED:
      return EVENT_TYPE_KEY_RELEASED;

    default:
      break;
  }
  return EVENT_TYPE_UNKNOWN;
}

EventPtr TypeConverter<EventPtr, ui::Event>::Convert(const ui::Event& input) {
  const EventType type = ConvertTo<EventType>(input.type());
  if (type == EVENT_TYPE_UNKNOWN)
    return nullptr;

  EventPtr event = Event::New();
  event->action = type;
  event->flags = EventFlags(input.flags());
  event->time_stamp = input.time_stamp().ToInternalValue();

  PointerData pointer_data;
  if (input.IsMouseEvent()) {
    const ui::LocatedEvent* located_event =
        static_cast<const ui::LocatedEvent*>(&input);
    PointerDataPtr pointer_data(PointerData::New());
    // TODO(sky): come up with a better way to handle this.
    pointer_data->pointer_id = std::numeric_limits<int32>::max();
    pointer_data->kind = POINTER_KIND_MOUSE;
    SetPointerDataLocationFromEvent(*located_event, pointer_data.get());
    if (input.IsMouseWheelEvent()) {
      const ui::MouseWheelEvent* wheel_event =
          static_cast<const ui::MouseWheelEvent*>(&input);
      // This conversion assumes we're using the mojo meaning of these values:
      // [-1 1].
      pointer_data->horizontal_wheel =
          static_cast<float>(wheel_event->x_offset()) / 100.0f;
      pointer_data->vertical_wheel =
          static_cast<float>(wheel_event->y_offset()) / 100.0f;
    }
    event->pointer_data = pointer_data.Pass();
  } else if (input.IsTouchEvent()) {
    const ui::TouchEvent* touch_event =
        static_cast<const ui::TouchEvent*>(&input);
    PointerDataPtr pointer_data(PointerData::New());
    pointer_data->pointer_id = touch_event->touch_id();
    pointer_data->kind = POINTER_KIND_TOUCH;
    SetPointerDataLocationFromEvent(*touch_event, pointer_data.get());
    pointer_data->radius_major = touch_event->radius_x();
    pointer_data->radius_minor = touch_event->radius_y();
    pointer_data->pressure = touch_event->force();
    pointer_data->orientation = touch_event->rotation_angle();
    event->pointer_data = pointer_data.Pass();
  } else if (input.IsKeyEvent()) {
    const ui::KeyEvent* key_event = static_cast<const ui::KeyEvent*>(&input);
    KeyDataPtr key_data(KeyData::New());
    key_data->key_code = key_event->GetConflatedWindowsKeyCode();
    key_data->native_key_code = key_event->platform_keycode();
    key_data->is_char = key_event->is_char();
    key_data->character = key_event->GetCharacter();

    if (key_event->extended_key_event_data()) {
      const MojoExtendedKeyEventData* data =
          static_cast<const MojoExtendedKeyEventData*>(
              key_event->extended_key_event_data());
      key_data->windows_key_code = static_cast<mojo::KeyboardCode>(
          data->windows_key_code());
      key_data->text = data->text();
      key_data->unmodified_text = data->unmodified_text();
    } else {
      key_data->windows_key_code = static_cast<mojo::KeyboardCode>(
          key_event->GetLocatedWindowsKeyboardCode());
      key_data->text = key_event->GetText();
      key_data->unmodified_text = key_event->GetUnmodifiedText();
    }
    event->key_data = key_data.Pass();
  }
  return event.Pass();
}

// static
EventPtr TypeConverter<EventPtr, ui::KeyEvent>::Convert(
    const ui::KeyEvent& input) {
  return Event::From(static_cast<const ui::Event&>(input));
}

// static
scoped_ptr<ui::Event> TypeConverter<scoped_ptr<ui::Event>, EventPtr>::Convert(
    const EventPtr& input) {
  gfx::PointF location;
  gfx::PointF screen_location;
  if (!input->pointer_data.is_null()) {
    location.SetPoint(input->pointer_data->x, input->pointer_data->y);
    screen_location.SetPoint(input->pointer_data->screen_x,
                             input->pointer_data->screen_y);
  }

  switch (input->action) {
    case EVENT_TYPE_KEY_PRESSED:
    case EVENT_TYPE_KEY_RELEASED: {
      scoped_ptr<ui::KeyEvent> key_event;
      if (input->key_data->is_char) {
        key_event.reset(new ui::KeyEvent(
            static_cast<base::char16>(input->key_data->character),
            static_cast<ui::KeyboardCode>(
                input->key_data->key_code),
            input->flags));
      } else {
        key_event.reset(new ui::KeyEvent(
            input->action == EVENT_TYPE_KEY_PRESSED ? ui::ET_KEY_PRESSED
                                                    : ui::ET_KEY_RELEASED,

            static_cast<ui::KeyboardCode>(input->key_data->key_code),
            input->flags));
      }
      key_event->SetExtendedKeyEventData(scoped_ptr<ui::ExtendedKeyEventData>(
          new MojoExtendedKeyEventData(
              static_cast<int32_t>(input->key_data->windows_key_code),
              input->key_data->text,
              input->key_data->unmodified_text)));
      key_event->set_platform_keycode(input->key_data->native_key_code);
      return key_event.Pass();
    }
    case EVENT_TYPE_POINTER_DOWN:
    case EVENT_TYPE_POINTER_UP:
    case EVENT_TYPE_POINTER_MOVE:
    case EVENT_TYPE_POINTER_CANCEL: {
      if (input->pointer_data->kind == POINTER_KIND_MOUSE) {
        // TODO: last flags isn't right. Need to send changed_flags.
        scoped_ptr<ui::MouseEvent> event(new ui::MouseEvent(
            MojoMouseEventTypeToUIEvent(input), location, screen_location,
            ui::EventFlags(input->flags), ui::EventFlags(input->flags)));
        if (event->IsMouseWheelEvent()) {
          // This conversion assumes we're using the mojo meaning of these
          // values: [-1 1].
          scoped_ptr<ui::MouseEvent> wheel_event(new ui::MouseWheelEvent(
              *event,
              static_cast<int>(input->pointer_data->horizontal_wheel * 100),
              static_cast<int>(input->pointer_data->vertical_wheel * 100)));
          event = wheel_event.Pass();
        }
        return event.Pass();
      }
      scoped_ptr<ui::TouchEvent> touch_event(new ui::TouchEvent(
          MojoTouchEventTypeToUIEvent(input), location,
          ui::EventFlags(input->flags), input->pointer_data->pointer_id,
          base::TimeDelta::FromInternalValue(input->time_stamp),
          input->pointer_data->radius_major, input->pointer_data->radius_minor,
          input->pointer_data->orientation, input->pointer_data->pressure));
      touch_event->set_root_location(screen_location);
      return touch_event.Pass();
    }
    default:
      NOTIMPLEMENTED();
  }
  // TODO: need to support time_stamp.
  return nullptr;
}

}  // namespace mojo