// Copyright 2015 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 "remoting/host/touch_injector_win.h"

#include <stddef.h>
#include <stdint.h>

#include <map>
#include <utility>

#include "base/containers/contains.h"
#include "remoting/proto/event.pb.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

using ::testing::_;
using ::testing::AtLeast;
using ::testing::InSequence;
using ::testing::ExpectationSet;
using ::testing::Return;

namespace remoting {

using protocol::TouchEvent;
using protocol::TouchEventPoint;

namespace {

// Maps touch pointer ID to expected flags [start, move, end, cancel] listed
// below.
typedef std::map<uint32_t, uint32_t> IdFlagMap;

const uint32_t kStartFlag =
    POINTER_FLAG_INRANGE | POINTER_FLAG_INCONTACT | POINTER_FLAG_DOWN;

const uint32_t kMoveFlag =
    POINTER_FLAG_INRANGE | POINTER_FLAG_INCONTACT | POINTER_FLAG_UPDATE;

const uint32_t kEndFlag = POINTER_FLAG_UP;

const uint32_t kCancelFlag = POINTER_FLAG_UP | POINTER_FLAG_CANCELED;

MATCHER_P(EqualsSinglePointerTouchInfo, expected, "") {
  return arg->touchMask == expected.touchMask &&
         arg->rcContact.left == expected.rcContact.left &&
         arg->rcContact.top == expected.rcContact.top &&
         arg->rcContact.right == expected.rcContact.right &&
         arg->rcContact.bottom == expected.rcContact.bottom &&
         arg->orientation == expected.orientation &&
         arg->pressure == expected.pressure &&
         arg->pointerInfo.pointerType == expected.pointerInfo.pointerType &&
         arg->pointerInfo.pointerId == expected.pointerInfo.pointerId &&
         arg->pointerInfo.ptPixelLocation.x ==
             expected.pointerInfo.ptPixelLocation.x &&
         arg->pointerInfo.ptPixelLocation.y ==
             expected.pointerInfo.ptPixelLocation.y;
}

// Make sure that every touch point has the right flag (pointerFlags).
MATCHER_P(EqualsPointerTouchInfoFlag, id_to_flag_map, "") {
  for (size_t i = 0; i < id_to_flag_map.size(); ++i) {
    const POINTER_TOUCH_INFO* touch_info = arg + i;
    const uint32_t id = touch_info->pointerInfo.pointerId;
    if (!base::Contains(id_to_flag_map, id))
      return false;

    if (id_to_flag_map.find(id)->second != touch_info->pointerInfo.pointerFlags)
      return false;
  }
  return true;
}

class TouchInjectorWinDelegateMock : public TouchInjectorWinDelegate {
 public:
  TouchInjectorWinDelegateMock()
      : TouchInjectorWinDelegate(nullptr, nullptr, nullptr) {}
  ~TouchInjectorWinDelegateMock() override {}

  MOCK_METHOD2(InitializeTouchInjection, BOOL(UINT32 max_count, DWORD dw_mode));
  MOCK_METHOD2(InjectTouchInput,
               DWORD(UINT32 count, const POINTER_TOUCH_INFO* contacts));
};

}  // namespace

// A test to make sure that the touch event is converted correctly to
// POINTER_TOUCH_INFO.
TEST(TouchInjectorWinTest, CheckConversionWithPressure) {
  std::unique_ptr<TouchInjectorWinDelegateMock> delegate_mock(
      new ::testing::StrictMock<TouchInjectorWinDelegateMock>());

  TouchEvent event;
  event.set_event_type(TouchEvent::TOUCH_POINT_START);
  TouchEventPoint* point = event.add_touch_points();
  point->set_id(1234u);
  point->set_x(321.0f);
  point->set_y(123.0f);
  point->set_radius_x(10.0f);
  point->set_radius_y(20.0f);
  point->set_pressure(0.5f);
  point->set_angle(45.0f);

  POINTER_TOUCH_INFO expected_touch_info;
  expected_touch_info.touchMask =
      TOUCH_MASK_CONTACTAREA | TOUCH_MASK_ORIENTATION | TOUCH_MASK_PRESSURE;
  expected_touch_info.rcContact.left = 311;
  expected_touch_info.rcContact.top = 103;
  expected_touch_info.rcContact.right = 331;
  expected_touch_info.rcContact.bottom = 143;
  expected_touch_info.orientation = 0;
  expected_touch_info.pressure = 512;
  expected_touch_info.orientation = 45;

  expected_touch_info.pointerInfo.pointerType = PT_TOUCH;
  expected_touch_info.pointerInfo.pointerId = 1234u;
  expected_touch_info.pointerInfo.ptPixelLocation.x = 321;
  expected_touch_info.pointerInfo.ptPixelLocation.y = 123;

  InSequence s;
  EXPECT_CALL(*delegate_mock, InitializeTouchInjection(_, _))
      .WillOnce(Return(1));
  EXPECT_CALL(
      *delegate_mock,
      InjectTouchInput(1, EqualsSinglePointerTouchInfo(expected_touch_info)))
      .WillOnce(Return(1));

  // Check pressure clamping as well.
  expected_touch_info.pressure = 1024;  // Max
  EXPECT_CALL(
      *delegate_mock,
      InjectTouchInput(1, EqualsSinglePointerTouchInfo(expected_touch_info)))
      .WillOnce(Return(1));

  expected_touch_info.pressure = 0;  // Min
  EXPECT_CALL(
      *delegate_mock,
      InjectTouchInput(1, EqualsSinglePointerTouchInfo(expected_touch_info)))
      .WillOnce(Return(1));

  TouchInjectorWin injector;
  injector.SetInjectorDelegateForTest(std::move(delegate_mock));
  EXPECT_TRUE(injector.Init());
  injector.InjectTouchEvent(event);

  // Change to MOVE so that there still only one point.
  event.set_event_type(TouchEvent::TOUCH_POINT_MOVE);
  point->set_pressure(2.0f);
  injector.InjectTouchEvent(event);

  point->set_pressure(-3.0f);
  injector.InjectTouchEvent(event);
}

// Some devices don't detect pressure. This test is a conversion check for
// such devices.
TEST(TouchInjectorWinTest, CheckConversionNoPressure) {
  std::unique_ptr<TouchInjectorWinDelegateMock> delegate_mock(
      new ::testing::StrictMock<TouchInjectorWinDelegateMock>());

  TouchEvent event;
  event.set_event_type(TouchEvent::TOUCH_POINT_START);
  TouchEventPoint* point = event.add_touch_points();
  point->set_id(1234u);
  point->set_x(321.0f);
  point->set_y(123.0f);
  point->set_radius_x(10.0f);
  point->set_radius_y(20.0f);
  point->set_angle(45.0f);

  POINTER_TOUCH_INFO expected_touch_info;
  expected_touch_info.touchMask =
      TOUCH_MASK_CONTACTAREA | TOUCH_MASK_ORIENTATION;
  expected_touch_info.rcContact.left = 311;
  expected_touch_info.rcContact.top = 103;
  expected_touch_info.rcContact.right = 331;
  expected_touch_info.rcContact.bottom = 143;
  expected_touch_info.orientation = 0;
  expected_touch_info.pressure = 0;
  expected_touch_info.orientation = 45;

  expected_touch_info.pointerInfo.pointerType = PT_TOUCH;
  expected_touch_info.pointerInfo.pointerId = 1234u;
  expected_touch_info.pointerInfo.ptPixelLocation.x = 321;
  expected_touch_info.pointerInfo.ptPixelLocation.y = 123;

  InSequence s;
  EXPECT_CALL(*delegate_mock, InitializeTouchInjection(_, _))
      .WillOnce(Return(1));
  EXPECT_CALL(
      *delegate_mock,
      InjectTouchInput(1, EqualsSinglePointerTouchInfo(expected_touch_info)))
      .WillOnce(Return(1));

  TouchInjectorWin injector;
  injector.SetInjectorDelegateForTest(std::move(delegate_mock));
  EXPECT_TRUE(injector.Init());
  injector.InjectTouchEvent(event);
}

// If initialization fails, it should not call any touch injection functions.
TEST(TouchInjectorWinTest, InitFailed) {
  std::unique_ptr<TouchInjectorWinDelegateMock> delegate_mock(
      new ::testing::StrictMock<TouchInjectorWinDelegateMock>());

  TouchEvent event;
  event.set_event_type(TouchEvent::TOUCH_POINT_START);

  InSequence s;
  EXPECT_CALL(*delegate_mock, InitializeTouchInjection(_, _))
      .WillOnce(Return(0));
  EXPECT_CALL(*delegate_mock, InjectTouchInput(_, _)).Times(0);

  TouchInjectorWin injector;
  injector.SetInjectorDelegateForTest(std::move(delegate_mock));
  EXPECT_FALSE(injector.Init());
  injector.InjectTouchEvent(event);
}

// Deinitialize and initialize should clean the state.
TEST(TouchInjectorWinTest, Reinitialize) {
  std::unique_ptr<TouchInjectorWinDelegateMock>
      delegate_mock_before_deinitialize(
          new ::testing::StrictMock<TouchInjectorWinDelegateMock>());
  std::unique_ptr<TouchInjectorWinDelegateMock>
      delegate_mock_after_deinitialize(
          new ::testing::StrictMock<TouchInjectorWinDelegateMock>());

  TouchEvent first_event;
  first_event.set_event_type(TouchEvent::TOUCH_POINT_START);
  TouchEventPoint* point0 = first_event.add_touch_points();
  point0->set_id(0u);

  TouchEvent second_event;
  second_event.set_event_type(TouchEvent::TOUCH_POINT_START);
  TouchEventPoint* point1 = second_event.add_touch_points();
  point1->set_id(1u);

  InSequence s;
  EXPECT_CALL(*delegate_mock_before_deinitialize,
              InitializeTouchInjection(_, _)).WillOnce(Return(1));

  IdFlagMap id_to_flags;
  id_to_flags[0u] = kStartFlag;
  EXPECT_CALL(
      *delegate_mock_before_deinitialize,
      InjectTouchInput(1, EqualsPointerTouchInfoFlag(id_to_flags)))
      .WillOnce(Return(1));

  EXPECT_CALL(*delegate_mock_after_deinitialize,
              InitializeTouchInjection(_, _)).WillOnce(Return(1));

  // After deinitializing and then initializing, previous touch points should be
  // gone.
  id_to_flags.clear();
  id_to_flags[1u] = kStartFlag;
  EXPECT_CALL(
      *delegate_mock_after_deinitialize,
      InjectTouchInput(1, EqualsPointerTouchInfoFlag(id_to_flags)))
      .WillOnce(Return(1));

  TouchInjectorWin injector;
  injector.SetInjectorDelegateForTest(
      std::move(delegate_mock_before_deinitialize));

  EXPECT_TRUE(injector.Init());
  injector.InjectTouchEvent(first_event);
  injector.Deinitialize();

  injector.SetInjectorDelegateForTest(
      std::move(delegate_mock_after_deinitialize));
  EXPECT_TRUE(injector.Init());
  injector.InjectTouchEvent(second_event);
}

// Make sure that the flag is set to kStartFlag.
TEST(TouchInjectorWinTest, StartTouchPoint) {
  std::unique_ptr<TouchInjectorWinDelegateMock> delegate_mock(
      new ::testing::StrictMock<TouchInjectorWinDelegateMock>());

  TouchEvent event;
  event.set_event_type(TouchEvent::TOUCH_POINT_START);
  TouchEventPoint* point = event.add_touch_points();
  point->set_id(0u);

  InSequence s;
  EXPECT_CALL(*delegate_mock, InitializeTouchInjection(_, _))
      .WillOnce(Return(1));

  IdFlagMap id_to_flags;
  id_to_flags[0u] = kStartFlag;
  EXPECT_CALL(
      *delegate_mock,
      InjectTouchInput(1, EqualsPointerTouchInfoFlag(id_to_flags)))
      .WillOnce(Return(1));

  TouchInjectorWin injector;
  injector.SetInjectorDelegateForTest(std::move(delegate_mock));
  EXPECT_TRUE(injector.Init());
  injector.InjectTouchEvent(event);
}

// Start a point and then move, make sure the flag is set to kMoveFlag.
TEST(TouchInjectorWinTest, MoveTouchPoint) {
  std::unique_ptr<TouchInjectorWinDelegateMock> delegate_mock(
      new ::testing::StrictMock<TouchInjectorWinDelegateMock>());

  TouchEvent event;
  event.set_event_type(TouchEvent::TOUCH_POINT_START);
  TouchEventPoint* point = event.add_touch_points();
  point->set_id(0u);


  InSequence s;
  EXPECT_CALL(*delegate_mock, InitializeTouchInjection(_, _))
      .WillOnce(Return(1));

  IdFlagMap id_to_flags;
  id_to_flags[0u] = kStartFlag;
  EXPECT_CALL(
      *delegate_mock,
      InjectTouchInput(1, EqualsPointerTouchInfoFlag(id_to_flags)))
      .WillOnce(Return(1));

  id_to_flags[0u] = kMoveFlag;
  EXPECT_CALL(
      *delegate_mock,
      InjectTouchInput(1, EqualsPointerTouchInfoFlag(id_to_flags)))
      .WillOnce(Return(1));

  TouchInjectorWin injector;
  injector.SetInjectorDelegateForTest(std::move(delegate_mock));
  EXPECT_TRUE(injector.Init());
  injector.InjectTouchEvent(event);
  event.set_event_type(TouchEvent::TOUCH_POINT_MOVE);
  injector.InjectTouchEvent(event);
}

// Start a point and then move, make sure the flag is set to kEndFlag.
TEST(TouchInjectorWinTest, EndTouchPoint) {
  std::unique_ptr<TouchInjectorWinDelegateMock> delegate_mock(
      new ::testing::StrictMock<TouchInjectorWinDelegateMock>());

  TouchEvent event;
  event.set_event_type(TouchEvent::TOUCH_POINT_START);
  TouchEventPoint* point = event.add_touch_points();
  point->set_id(0u);

  InSequence s;
  EXPECT_CALL(*delegate_mock, InitializeTouchInjection(_, _))
      .WillOnce(Return(1));

  IdFlagMap id_to_flags;
  id_to_flags[0u] = kStartFlag;
  EXPECT_CALL(
      *delegate_mock,
      InjectTouchInput(1, EqualsPointerTouchInfoFlag(id_to_flags)))
      .WillOnce(Return(1));

  id_to_flags[0u] = kEndFlag;
  EXPECT_CALL(
      *delegate_mock,
      InjectTouchInput(1, EqualsPointerTouchInfoFlag(id_to_flags)))
      .WillOnce(Return(1));

  TouchInjectorWin injector;
  injector.SetInjectorDelegateForTest(std::move(delegate_mock));
  EXPECT_TRUE(injector.Init());
  injector.InjectTouchEvent(event);
  event.set_event_type(TouchEvent::TOUCH_POINT_END);
  injector.InjectTouchEvent(event);
}

// Start a point and then move, make sure the flag is set to kCancelFlag.
TEST(TouchInjectorWinTest, CancelTouchPoint) {
  std::unique_ptr<TouchInjectorWinDelegateMock> delegate_mock(
      new ::testing::StrictMock<TouchInjectorWinDelegateMock>());

  TouchEvent event;
  event.set_event_type(TouchEvent::TOUCH_POINT_START);
  TouchEventPoint* point = event.add_touch_points();
  point->set_id(0u);

  InSequence s;
  EXPECT_CALL(*delegate_mock, InitializeTouchInjection(_, _))
      .WillOnce(Return(1));

  IdFlagMap id_to_flags;
  id_to_flags[0u] = kStartFlag;
  EXPECT_CALL(
      *delegate_mock,
      InjectTouchInput(1, EqualsPointerTouchInfoFlag(id_to_flags)))
      .WillOnce(Return(1));

  id_to_flags[0u] = kCancelFlag;
  EXPECT_CALL(
      *delegate_mock,
      InjectTouchInput(1, EqualsPointerTouchInfoFlag(id_to_flags)))
      .WillOnce(Return(1));

  TouchInjectorWin injector;
  injector.SetInjectorDelegateForTest(std::move(delegate_mock));
  EXPECT_TRUE(injector.Init());
  injector.InjectTouchEvent(event);
  event.set_event_type(TouchEvent::TOUCH_POINT_CANCEL);
  injector.InjectTouchEvent(event);
}

// Note that points that haven't changed should be injected as MOVE.
// This tests:
// 1. Start first touch point.
// 2. Start second touch point.
// 3. Move both touch points.
// 4. Start third touch point.
// 5. End second touch point.
// 6. Cancel remaining (first and third) touch points.
TEST(TouchInjectorWinTest, MultiTouch) {
  std::unique_ptr<TouchInjectorWinDelegateMock> delegate_mock(
      new ::testing::StrictMock<TouchInjectorWinDelegateMock>());

  InSequence s;
  EXPECT_CALL(*delegate_mock, InitializeTouchInjection(_, _))
      .WillOnce(Return(1));

  IdFlagMap id_to_flags;
  id_to_flags[0u] = kStartFlag;
  EXPECT_CALL(
      *delegate_mock,
      InjectTouchInput(1, EqualsPointerTouchInfoFlag(id_to_flags)))
      .WillOnce(Return(1));

  id_to_flags[0u] = kMoveFlag;
  id_to_flags[1u] = kStartFlag;
  EXPECT_CALL(
      *delegate_mock,
      InjectTouchInput(2, EqualsPointerTouchInfoFlag(id_to_flags)))
      .WillOnce(Return(1));

  id_to_flags[0u] = kMoveFlag;
  id_to_flags[1u] = kMoveFlag;
  EXPECT_CALL(
      *delegate_mock,
      InjectTouchInput(2, EqualsPointerTouchInfoFlag(id_to_flags)))
      .WillOnce(Return(1));

  id_to_flags[0u] = kMoveFlag;
  id_to_flags[1u] = kMoveFlag;
  id_to_flags[2u] = kStartFlag;
  EXPECT_CALL(
      *delegate_mock,
      InjectTouchInput(3, EqualsPointerTouchInfoFlag(id_to_flags)))
      .WillOnce(Return(1));

  id_to_flags[0u] = kMoveFlag;
  id_to_flags[1u] = kEndFlag;
  id_to_flags[2u] = kMoveFlag;
  EXPECT_CALL(
      *delegate_mock,
      InjectTouchInput(3, EqualsPointerTouchInfoFlag(id_to_flags)))
      .WillOnce(Return(1));

  id_to_flags.erase(1u);
  id_to_flags[0u] = kCancelFlag;
  id_to_flags[2u] = kCancelFlag;
  EXPECT_CALL(
      *delegate_mock,
      InjectTouchInput(2, EqualsPointerTouchInfoFlag(id_to_flags)))
      .WillOnce(Return(1));

  TouchInjectorWin injector;
  injector.SetInjectorDelegateForTest(std::move(delegate_mock));
  EXPECT_TRUE(injector.Init());

  // Start first touch point.
  TouchEvent first_touch_start;
  first_touch_start.set_event_type(TouchEvent::TOUCH_POINT_START);
  TouchEventPoint* point0 = first_touch_start.add_touch_points();
  point0->set_id(0u);
  injector.InjectTouchEvent(first_touch_start);

  // Add second touch point.
  TouchEvent second_touch_start;
  second_touch_start.set_event_type(TouchEvent::TOUCH_POINT_START);
  TouchEventPoint* point1 = second_touch_start.add_touch_points();
  point1->set_id(1u);
  injector.InjectTouchEvent(second_touch_start);

  // Move both touch points.
  TouchEvent move_both;
  move_both.set_event_type(TouchEvent::TOUCH_POINT_MOVE);
  point0 = second_touch_start.add_touch_points();
  point1 = second_touch_start.add_touch_points();
  point0->set_id(0u);
  point1->set_id(1u);
  injector.InjectTouchEvent(move_both);

  // Add another.
  TouchEvent third_touch_start;
  third_touch_start.set_event_type(TouchEvent::TOUCH_POINT_START);
  TouchEventPoint* point2 = third_touch_start.add_touch_points();
  point2->set_id(2u);
  injector.InjectTouchEvent(third_touch_start);

  // Release second touch point.
  TouchEvent release_second;
  release_second.set_event_type(TouchEvent::TOUCH_POINT_END);
  point1 = release_second.add_touch_points();
  point1->set_id(1u);
  injector.InjectTouchEvent(release_second);

  // Cancel the remaining two points.
  TouchEvent cancel_rest;
  cancel_rest.set_event_type(TouchEvent::TOUCH_POINT_CANCEL);
  point0 = cancel_rest.add_touch_points();
  point0->set_id(0u);
  point2 = cancel_rest.add_touch_points();
  point2->set_id(2u);
  injector.InjectTouchEvent(cancel_rest);
}

}  // namespace remoting