// Copyright (c) 2013 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 "power_manager/powerd/policy/input_event_handler.h"

#include <stdint.h>

#include <string>
#include <vector>

#include <base/format_macros.h>
#include <base/strings/stringprintf.h>
#include <chromeos/dbus/service_constants.h>
#include <dbus/message.h>
#include <gtest/gtest.h>

#include "power_manager/common/action_recorder.h"
#include "power_manager/common/clock.h"
#include "power_manager/common/fake_prefs.h"
#include "power_manager/common/power_constants.h"
#include "power_manager/powerd/system/dbus_wrapper_stub.h"
#include "power_manager/powerd/system/display/display_info.h"
#include "power_manager/powerd/system/display/display_watcher_stub.h"
#include "power_manager/powerd/system/input_watcher_stub.h"
#include "power_manager/proto_bindings/input_event.pb.h"
#include "power_manager/proto_bindings/switch_states.pb.h"

namespace power_manager {
namespace policy {
namespace {

const char kNoActions[] = "";
const char kLidClosed[] = "lid_closed";
const char kLidOpened[] = "lid_opened";
const char kPowerButtonDown[] = "power_down";
const char kPowerButtonUp[] = "power_up";
const char kPowerButtonRepeat[] = "power_repeat";
const char kShutDown[] = "shut_down";
const char kMissingPowerButtonAcknowledgment[] = "missing_power_button_ack";
const char kHoverOn[] = "hover_on";
const char kHoverOff[] = "hover_off";
const char kTabletOn[] = "tablet_on";
const char kTabletOff[] = "tablet_off";
const char kTabletUnsupported[] = "tablet_unsupported";

const char* GetTabletModeAction(TabletMode mode) {
  switch (mode) {
    case TabletMode::ON:
      return kTabletOn;
    case TabletMode::OFF:
      return kTabletOff;
    case TabletMode::UNSUPPORTED:
      return kTabletUnsupported;
  }
  NOTREACHED() << "Invalid tablet mode " << static_cast<int>(mode);
  return "tablet_invalid";
}

const char* GetPowerButtonAction(ButtonState state) {
  switch (state) {
    case ButtonState::DOWN:
      return kPowerButtonDown;
    case ButtonState::UP:
      return kPowerButtonUp;
    case ButtonState::REPEAT:
      return kPowerButtonRepeat;
  }
  NOTREACHED() << "Invalid power button state " << static_cast<int>(state);
  return "power_invalid";
}

std::string GetAcknowledgmentDelayAction(base::TimeDelta delay) {
  return base::StringPrintf("power_button_ack_delay(%" PRId64 ")",
                            delay.InMilliseconds());
}

class TestInputEventHandlerDelegate : public InputEventHandler::Delegate,
                                      public ActionRecorder {
 public:
  TestInputEventHandlerDelegate() {}
  TestInputEventHandlerDelegate(const TestInputEventHandlerDelegate&) = delete;
  TestInputEventHandlerDelegate& operator=(
      const TestInputEventHandlerDelegate&) = delete;

  ~TestInputEventHandlerDelegate() override {}

  // InputEventHandler::Delegate implementation:
  void HandleLidClosed() override { AppendAction(kLidClosed); }
  void HandleLidOpened() override { AppendAction(kLidOpened); }
  void HandlePowerButtonEvent(ButtonState state) override {
    AppendAction(GetPowerButtonAction(state));
  }
  void HandleHoverStateChange(bool hovering) override {
    AppendAction(hovering ? kHoverOn : kHoverOff);
  }
  void HandleTabletModeChange(TabletMode mode) override {
    EXPECT_NE(TabletMode::UNSUPPORTED, mode);
    AppendAction(GetTabletModeAction(mode));
  }
  void ShutDownForPowerButtonWithNoDisplay() override {
    AppendAction(kShutDown);
  }
  void HandleMissingPowerButtonAcknowledgment() override {
    AppendAction(kMissingPowerButtonAcknowledgment);
  }
  void ReportPowerButtonAcknowledgmentDelay(base::TimeDelta delay) override {
    AppendAction(GetAcknowledgmentDelayAction(delay));
  }
};

}  // namespace

class InputEventHandlerTest : public ::testing::Test {
 public:
  InputEventHandlerTest() {
    handler_.clock_for_testing()->set_current_time_for_testing(
        base::TimeTicks::FromInternalValue(1000));
  }
  ~InputEventHandlerTest() override {}

 protected:
  // Initializes |handler_|.
  void Init() {
    handler_.Init(&input_watcher_, &delegate_, &display_watcher_,
                  &dbus_wrapper_, &prefs_);
  }

  // Tests that one InputEvent D-Bus signal has been sent and returns the
  // signal's |type| field.
  int GetInputEventSignalType() {
    InputEvent proto;
    EXPECT_EQ(1, dbus_wrapper_.num_sent_signals());
    EXPECT_TRUE(
        dbus_wrapper_.GetSentSignal(0, kInputEventSignal, &proto, nullptr));
    return proto.type();
  }

  // Tests that one InputEvent D-Bus signal has been sent and returns the
  // signal's |timestamp| field.
  int64_t GetInputEventSignalTimestamp() {
    InputEvent proto;
    EXPECT_EQ(1, dbus_wrapper_.num_sent_signals());
    EXPECT_TRUE(
        dbus_wrapper_.GetSentSignal(0, kInputEventSignal, &proto, nullptr));
    return proto.timestamp();
  }

  // Returns the current (fake) time.
  base::TimeTicks Now() {
    return handler_.clock_for_testing()->GetCurrentTime();
  }

  // Advances the current time by |interval|.
  void AdvanceTime(const base::TimeDelta& interval) {
    handler_.clock_for_testing()->set_current_time_for_testing(Now() +
                                                               interval);
  }

  // Makes an IgnoreNextPowerButtonPress D-Bus method call.
  void CallIgnoreNextPowerButtonPress(const base::TimeDelta& timeout) {
    dbus::MethodCall method_call(kPowerManagerInterface,
                                 kIgnoreNextPowerButtonPressMethod);
    dbus::MessageWriter(&method_call).AppendInt64(timeout.ToInternalValue());
    ASSERT_TRUE(dbus_wrapper_.CallExportedMethodSync(&method_call));
  }

  // Makes an HandlePowerButtonAcknowledgment D-Bus method call.
  void CallHandlePowerButtonAcknowledgment(const base::TimeTicks& timestamp) {
    dbus::MethodCall method_call(kPowerManagerInterface,
                                 kHandlePowerButtonAcknowledgmentMethod);
    dbus::MessageWriter(&method_call).AppendInt64(timestamp.ToInternalValue());
    ASSERT_TRUE(dbus_wrapper_.CallExportedMethodSync(&method_call));
  }

  FakePrefs prefs_;
  system::InputWatcherStub input_watcher_;
  system::DisplayWatcherStub display_watcher_;
  system::DBusWrapperStub dbus_wrapper_;
  TestInputEventHandlerDelegate delegate_;
  InputEventHandler handler_;
};

TEST_F(InputEventHandlerTest, LidEvents) {
  EXPECT_EQ(kNoActions, delegate_.GetActions());

  // Initialization shouldn't generate a synthetic event.
  prefs_.SetInt64(kUseLidPref, 1);
  Init();
  EXPECT_EQ(kNoActions, delegate_.GetActions());
  EXPECT_EQ(0, dbus_wrapper_.num_sent_signals());
  dbus_wrapper_.ClearSentSignals();

  AdvanceTime(base::TimeDelta::FromSeconds(1));
  input_watcher_.set_lid_state(LidState::CLOSED);
  input_watcher_.NotifyObserversAboutLidState();
  EXPECT_EQ(kLidClosed, delegate_.GetActions());
  EXPECT_EQ(InputEvent_Type_LID_CLOSED, GetInputEventSignalType());
  EXPECT_EQ(Now().ToInternalValue(), GetInputEventSignalTimestamp());
  dbus_wrapper_.ClearSentSignals();

  AdvanceTime(base::TimeDelta::FromSeconds(5));
  input_watcher_.set_lid_state(LidState::OPEN);
  input_watcher_.NotifyObserversAboutLidState();
  EXPECT_EQ(kLidOpened, delegate_.GetActions());
  EXPECT_EQ(InputEvent_Type_LID_OPEN, GetInputEventSignalType());
  EXPECT_EQ(Now().ToInternalValue(), GetInputEventSignalTimestamp());
  dbus_wrapper_.ClearSentSignals();
}

TEST_F(InputEventHandlerTest, TabletModeEvents) {
  Init();
  EXPECT_EQ(0, dbus_wrapper_.num_sent_signals());
  dbus_wrapper_.ClearSentSignals();

  AdvanceTime(base::TimeDelta::FromSeconds(1));
  input_watcher_.set_tablet_mode(TabletMode::ON);
  input_watcher_.NotifyObserversAboutTabletMode();
  EXPECT_EQ(kTabletOn, delegate_.GetActions());
  EXPECT_EQ(InputEvent_Type_TABLET_MODE_ON, GetInputEventSignalType());
  EXPECT_EQ(Now().ToInternalValue(), GetInputEventSignalTimestamp());
  dbus_wrapper_.ClearSentSignals();

  AdvanceTime(base::TimeDelta::FromSeconds(1));
  input_watcher_.set_tablet_mode(TabletMode::OFF);
  input_watcher_.NotifyObserversAboutTabletMode();
  EXPECT_EQ(kTabletOff, delegate_.GetActions());
  EXPECT_EQ(InputEvent_Type_TABLET_MODE_OFF, GetInputEventSignalType());
  EXPECT_EQ(Now().ToInternalValue(), GetInputEventSignalTimestamp());
  dbus_wrapper_.ClearSentSignals();
}

TEST_F(InputEventHandlerTest, PowerButtonEvents) {
  prefs_.SetInt64(kExternalDisplayOnlyPref, 1);
  std::vector<system::DisplayInfo> displays(1, system::DisplayInfo());
  display_watcher_.set_displays(displays);
  Init();

  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::DOWN);
  EXPECT_EQ(kPowerButtonDown, delegate_.GetActions());
  EXPECT_EQ(InputEvent_Type_POWER_BUTTON_DOWN, GetInputEventSignalType());
  EXPECT_EQ(Now().ToInternalValue(), GetInputEventSignalTimestamp());
  dbus_wrapper_.ClearSentSignals();

  AdvanceTime(base::TimeDelta::FromMilliseconds(100));
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::UP);
  EXPECT_EQ(kPowerButtonUp, delegate_.GetActions());
  EXPECT_EQ(InputEvent_Type_POWER_BUTTON_UP, GetInputEventSignalType());
  EXPECT_EQ(Now().ToInternalValue(), GetInputEventSignalTimestamp());
  dbus_wrapper_.ClearSentSignals();

  // With no displays connected, the system should shut down immediately.
  displays.clear();
  display_watcher_.set_displays(displays);
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::DOWN);
  EXPECT_EQ(kShutDown, delegate_.GetActions());
  EXPECT_EQ(0, dbus_wrapper_.num_sent_signals());
}

TEST_F(InputEventHandlerTest, IgnorePowerButtonPresses) {
  Init();
  dbus_wrapper_.ClearSentSignals();

  const base::TimeDelta kShortDelay = base::TimeDelta::FromMilliseconds(100);
  const base::TimeDelta kIgnoreTimeout = base::TimeDelta::FromSeconds(3);

  // Ignore the power button events.
  CallIgnoreNextPowerButtonPress(kIgnoreTimeout);
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::DOWN);
  EXPECT_TRUE(delegate_.GetActions().empty());
  EXPECT_EQ(0, dbus_wrapper_.num_sent_signals());

  // Release the power button.
  AdvanceTime(kShortDelay);
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::UP);
  EXPECT_TRUE(delegate_.GetActions().empty());
  EXPECT_EQ(0, dbus_wrapper_.num_sent_signals());

  // Next press is going through.
  AdvanceTime(kShortDelay);
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::DOWN);
  EXPECT_EQ(kPowerButtonDown, delegate_.GetActions());
  EXPECT_EQ(InputEvent_Type_POWER_BUTTON_DOWN, GetInputEventSignalType());
  dbus_wrapper_.ClearSentSignals();
  AdvanceTime(kShortDelay);
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::UP);
  EXPECT_EQ(kPowerButtonUp, delegate_.GetActions());
  EXPECT_EQ(InputEvent_Type_POWER_BUTTON_UP, GetInputEventSignalType());
  dbus_wrapper_.ClearSentSignals();

  // Ignore again the power button events.
  CallIgnoreNextPowerButtonPress(kIgnoreTimeout);
  // Expire the timeout.
  AdvanceTime(kIgnoreTimeout + base::TimeDelta::FromMilliseconds(500));
  // The next press is going through.
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::DOWN);
  EXPECT_EQ(kPowerButtonDown, delegate_.GetActions());
  AdvanceTime(kShortDelay);
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::UP);
  EXPECT_EQ(kPowerButtonUp, delegate_.GetActions());

  // Ignore again the power button events.
  CallIgnoreNextPowerButtonPress(kIgnoreTimeout);
  // Cancel the timeout.
  CallIgnoreNextPowerButtonPress(base::TimeDelta());
  // The next press is going through.
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::DOWN);
  EXPECT_EQ(kPowerButtonDown, delegate_.GetActions());
  AdvanceTime(kShortDelay);
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::UP);
  EXPECT_EQ(kPowerButtonUp, delegate_.GetActions());

  // Race condition between the user and the U2F code, the down event happens
  // before the ignore event.
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::DOWN);
  EXPECT_EQ(kPowerButtonDown, delegate_.GetActions());
  AdvanceTime(kShortDelay);
  // Then the daemon receives the request to ignore the physical presence on
  // the power button.
  CallIgnoreNextPowerButtonPress(kIgnoreTimeout);
  // The user release the button but the release needs to go through else we
  // have a press without a release (which becomes a long press).
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::UP);
  EXPECT_EQ(kPowerButtonUp, delegate_.GetActions());
}

TEST_F(InputEventHandlerTest, AcknowledgePowerButtonPresses) {
  Init();

  const base::TimeDelta kShortDelay = base::TimeDelta::FromMilliseconds(100);
  const base::TimeDelta kTimeout =
      InputEventHandler::kPowerButtonAcknowledgmentTimeout;

  // Press the power button, acknowledge the event nearly immediately, and check
  // that no further actions are performed and that the timeout is stopped.
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::DOWN);
  EXPECT_EQ(kPowerButtonDown, delegate_.GetActions());
  AdvanceTime(kShortDelay);
  CallHandlePowerButtonAcknowledgment(
      base::TimeTicks::FromInternalValue(GetInputEventSignalTimestamp()));
  EXPECT_EQ(GetAcknowledgmentDelayAction(kShortDelay), delegate_.GetActions());
  ASSERT_FALSE(handler_.TriggerPowerButtonAcknowledgmentTimeoutForTesting());
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::UP);
  EXPECT_EQ(kPowerButtonUp, delegate_.GetActions());

  // Check that releasing the power button before it's been acknowledged also
  // stops the timeout.
  AdvanceTime(base::TimeDelta::FromSeconds(1));
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::DOWN);
  EXPECT_EQ(kPowerButtonDown, delegate_.GetActions());
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::UP);
  EXPECT_EQ(kPowerButtonUp, delegate_.GetActions());
  ASSERT_FALSE(handler_.TriggerPowerButtonAcknowledgmentTimeoutForTesting());
  dbus_wrapper_.ClearSentSignals();

  // Let the timeout fire and check that the delegate is notified.
  AdvanceTime(base::TimeDelta::FromSeconds(1));
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::DOWN);
  EXPECT_EQ(kPowerButtonDown, delegate_.GetActions());
  ASSERT_TRUE(handler_.TriggerPowerButtonAcknowledgmentTimeoutForTesting());
  EXPECT_EQ(JoinActions(GetAcknowledgmentDelayAction(kTimeout).c_str(),
                        kMissingPowerButtonAcknowledgment, nullptr),
            delegate_.GetActions());
  ASSERT_FALSE(handler_.TriggerPowerButtonAcknowledgmentTimeoutForTesting());
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::UP);
  EXPECT_EQ(kPowerButtonUp, delegate_.GetActions());

  // Send an acknowledgment with a stale timestamp and check that it doesn't
  // stop the timeout.
  AdvanceTime(base::TimeDelta::FromSeconds(1));
  dbus_wrapper_.ClearSentSignals();
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::DOWN);
  EXPECT_EQ(kPowerButtonDown, delegate_.GetActions());
  CallHandlePowerButtonAcknowledgment(
      base::TimeTicks::FromInternalValue(GetInputEventSignalTimestamp() - 100));
  EXPECT_EQ(kNoActions, delegate_.GetActions());
  ASSERT_TRUE(handler_.TriggerPowerButtonAcknowledgmentTimeoutForTesting());
  EXPECT_EQ(JoinActions(GetAcknowledgmentDelayAction(kTimeout).c_str(),
                        kMissingPowerButtonAcknowledgment, nullptr),
            delegate_.GetActions());
  ASSERT_FALSE(handler_.TriggerPowerButtonAcknowledgmentTimeoutForTesting());
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::UP);
  EXPECT_EQ(kPowerButtonUp, delegate_.GetActions());
}

TEST_F(InputEventHandlerTest, GetSwitchStates) {
  Init();
  input_watcher_.set_tablet_mode(TabletMode::ON);
  input_watcher_.set_lid_state(LidState::OPEN);
  dbus::MethodCall method_call(kPowerManagerInterface, kGetSwitchStatesMethod);
  std::unique_ptr<dbus::Response> response =
      dbus_wrapper_.CallExportedMethodSync(&method_call);
  ASSERT_TRUE(response.get());
  SwitchStates proto;
  ASSERT_TRUE(
      dbus::MessageReader(response.get()).PopArrayOfBytesAsProto(&proto));
  EXPECT_EQ(SwitchStates_TabletMode_ON, proto.tablet_mode());
  EXPECT_EQ(SwitchStates_LidState_OPEN, proto.lid_state());

  input_watcher_.set_tablet_mode(TabletMode::OFF);
  input_watcher_.set_lid_state(LidState::CLOSED);
  response = dbus_wrapper_.CallExportedMethodSync(&method_call);
  ASSERT_TRUE(response.get());
  ASSERT_TRUE(
      dbus::MessageReader(response.get()).PopArrayOfBytesAsProto(&proto));
  EXPECT_EQ(SwitchStates_TabletMode_OFF, proto.tablet_mode());
  EXPECT_EQ(SwitchStates_LidState_CLOSED, proto.lid_state());

  input_watcher_.set_tablet_mode(TabletMode::UNSUPPORTED);
  input_watcher_.set_lid_state(LidState::NOT_PRESENT);
  response = dbus_wrapper_.CallExportedMethodSync(&method_call);
  ASSERT_TRUE(response.get());
  ASSERT_TRUE(
      dbus::MessageReader(response.get()).PopArrayOfBytesAsProto(&proto));
  EXPECT_EQ(SwitchStates_TabletMode_UNSUPPORTED, proto.tablet_mode());
  EXPECT_EQ(SwitchStates_LidState_NOT_PRESENT, proto.lid_state());
}

TEST_F(InputEventHandlerTest, FactoryMode) {
  prefs_.SetInt64(kFactoryModePref, 1);
  Init();

  // Power button events shouldn't be reported to the delegate or announced to
  // Chrome over D-Bus when in factory mode.
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::DOWN);
  input_watcher_.NotifyObserversAboutPowerButtonEvent(ButtonState::UP);
  EXPECT_EQ(kNoActions, delegate_.GetActions());
  EXPECT_EQ(0, dbus_wrapper_.num_sent_signals());

  // Tablet mode and lid events should still be reported, though.
  input_watcher_.set_tablet_mode(TabletMode::ON);
  input_watcher_.NotifyObserversAboutTabletMode();
  EXPECT_EQ(kTabletOn, delegate_.GetActions());
  EXPECT_EQ(InputEvent_Type_TABLET_MODE_ON, GetInputEventSignalType());
  dbus_wrapper_.ClearSentSignals();

  input_watcher_.set_lid_state(LidState::CLOSED);
  input_watcher_.NotifyObserversAboutLidState();
  EXPECT_EQ(kLidClosed, delegate_.GetActions());
  EXPECT_EQ(InputEvent_Type_LID_CLOSED, GetInputEventSignalType());
  dbus_wrapper_.ClearSentSignals();
}

TEST_F(InputEventHandlerTest, OnHoverStateChangeTest) {
  Init();
  input_watcher_.NotifyObserversAboutHoverState(true);
  EXPECT_EQ(kHoverOn, delegate_.GetActions());
  input_watcher_.NotifyObserversAboutHoverState(false);
  EXPECT_EQ(kHoverOff, delegate_.GetActions());
}

}  // namespace policy
}  // namespace power_manager