// Copyright 2019 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 "biod/power_manager_client.h"

#include <base/bind.h>
#include <base/check.h>
#include <base/logging.h>
#include <base/memory/ptr_util.h>
#include <chromeos/dbus/service_constants.h>
#include <google/protobuf/message_lite.h>

#include "power_manager/proto_bindings/input_event.pb.h"

namespace {

// Deserializes |serialized_protobuf| to |protobuf_out| and returns true on
// success.
bool DeserializeProtocolBuffer(const std::vector<uint8_t>& serialized_protobuf,
                               google::protobuf::MessageLite* protobuf_out) {
  CHECK(protobuf_out);
  if (serialized_protobuf.empty())
    return false;
  return protobuf_out->ParseFromArray(&serialized_protobuf.front(),
                                      serialized_protobuf.size());
}

}  // namespace

namespace biod {

std::unique_ptr<PowerManagerClientInterface> PowerManagerClient::Create(
    const scoped_refptr<dbus::Bus>& bus) {
  return base::WrapUnique(new PowerManagerClient(bus));
}

PowerManagerClient::PowerManagerClient(const scoped_refptr<dbus::Bus>& bus) {
  proxy_ = std::make_unique<org::chromium::PowerManagerProxy>(bus);
  // Register Input Event signal Handler.
  proxy_->RegisterInputEventSignalHandler(
      base::BindRepeating(&PowerManagerClient::InputEvent,
                          weak_factory_.GetWeakPtr()),
      base::BindOnce(&PowerManagerClient::OnSignalConnected,
                     weak_factory_.GetWeakPtr()));
}

void PowerManagerClient::AddObserver(PowerEventObserver* observer) {
  DCHECK(observer);
  observers_.AddObserver(observer);
}

bool PowerManagerClient::HasObserver(PowerEventObserver* observer) {
  DCHECK(observer);
  return observers_.HasObserver(observer);
}

void PowerManagerClient::RemoveObserver(PowerEventObserver* observer) {
  DCHECK(observer);
  observers_.RemoveObserver(observer);
}

void PowerManagerClient::InputEvent(
    const std::vector<uint8_t>& serialized_proto) {
  power_manager::InputEvent proto;
  if (!DeserializeProtocolBuffer(serialized_proto, &proto)) {
    LOG(ERROR) << "Failed to parse InputEvent signal.";
    return;
  }
  base::TimeTicks timestamp =
      base::TimeTicks::FromInternalValue(proto.timestamp());
  if (proto.type() == power_manager::InputEvent_Type_POWER_BUTTON_DOWN ||
      proto.type() == power_manager::InputEvent_Type_POWER_BUTTON_UP) {
    const bool down =
        (proto.type() == power_manager::InputEvent_Type_POWER_BUTTON_DOWN);
    for (auto& observer : observers_)
      observer.PowerButtonEventReceived(down, timestamp);
  }
}

void PowerManagerClient::OnSignalConnected(const std::string& interface_name,
                                           const std::string& signal_name,
                                           bool success) {
  LOG(INFO) << __func__ << " interface: " << interface_name
            << " signal: " << signal_name << "success: " << success;
  if (!success) {
    LOG(ERROR) << "Failed to connect signal " << signal_name << " to interface "
               << interface_name;
  }
}

}  // namespace biod