// 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 "chromeos/dbus/metronome_client.h"

#include "base/bind.h"
#include "base/rand_util.h"
#include "base/command_line.h"
#include "base/logging.h"
#include "base/memory/weak_ptr.h"
#include "base/observer_list.h"
#include "base/time/time.h"
#include "base/timer/timer.h"
#include "chromeos/chromeos_switches.h"
#include "dbus/bus.h"
#include "dbus/message.h"
#include "dbus/object_path.h"
#include "dbus/object_proxy.h"

// TODO(benchan): Move these DBus constants to system_api.
namespace metronome {

const char kMetronomeInterface[] = "org.chromium.Metronome";
const char kMetronomeServiceName[] = "org.chromium.Metronome";
const char kMetronomeServicePath[] = "/org/chromium/Metronome";
const char kTimestampUpdatedSignal[] = "TimestampUpdated";

}  // namespace metronome

namespace chromeos {

namespace {

////////////////////////////////////////////////////////////////////////////////

// The MetronomeClient implementation.
class MetronomeClientImpl : public MetronomeClient {
 public:
  MetronomeClientImpl()
      : proxy_(nullptr), signal_connected_(false), weak_ptr_factory_(this) {}

  ~MetronomeClientImpl() override {}

  // MetronomeClient:
  void AddObserver(Observer* observer) override;
  void RemoveObserver(Observer* observer) override;

 protected:
  // DBusClient:
  void Init(dbus::Bus* bus) override;

 private:
  // Handles TimestampUpdated signal and notifies |observers_|.
  void OnTimestampUpdated(dbus::Signal* signal);

  // Handles the result of signal connection setup.
  void OnSignalConnected(const std::string& interface,
                         const std::string& signal,
                         bool succeeded);

  dbus::ObjectProxy* proxy_;

  // True when |proxy_| has been connected.
  bool signal_connected_;

  // List of observers interested in event notifications from us.
  ObserverList<Observer> observers_;

  // Note: This should remain the last member so it'll be destroyed and
  // invalidate its weak pointers before any other members are destroyed.
  base::WeakPtrFactory<MetronomeClientImpl> weak_ptr_factory_;

  DISALLOW_COPY_AND_ASSIGN(MetronomeClientImpl);
};

void MetronomeClientImpl::AddObserver(Observer* observer) {
  DCHECK(observer);
  if (!signal_connected_) {
    signal_connected_ = true;
    proxy_->ConnectToSignal(metronome::kMetronomeInterface,
                            metronome::kTimestampUpdatedSignal,
                            base::Bind(&MetronomeClientImpl::OnTimestampUpdated,
                                       weak_ptr_factory_.GetWeakPtr()),
                            base::Bind(&MetronomeClientImpl::OnSignalConnected,
                                       weak_ptr_factory_.GetWeakPtr()));
  }
  observers_.AddObserver(observer);
}

void MetronomeClientImpl::RemoveObserver(Observer* observer) {
  DCHECK(observer);
  observers_.RemoveObserver(observer);
}

void MetronomeClientImpl::Init(dbus::Bus* bus) {
  proxy_ =
      bus->GetObjectProxy(metronome::kMetronomeServiceName,
                          dbus::ObjectPath(metronome::kMetronomeServicePath));
}

void MetronomeClientImpl::OnTimestampUpdated(dbus::Signal* signal) {
  dbus::MessageReader reader(signal);
  uint64 beacon_timestamp = 0;
  uint64 local_timestamp = 0;
  if (!reader.PopUint64(&beacon_timestamp) ||
      !reader.PopUint64(&local_timestamp)) {
    LOG(ERROR) << "Invalid signal: " << signal->ToString();
    return;
  }
  FOR_EACH_OBSERVER(Observer, observers_,
                    OnTimestampUpdated(beacon_timestamp, local_timestamp));
}

void MetronomeClientImpl::OnSignalConnected(const std::string& interface,
                                            const std::string& signal,
                                            bool succeeded) {
  LOG_IF(ERROR, !succeeded) << "Connect to " << interface << " " << signal
                            << " failed.";
}

////////////////////////////////////////////////////////////////////////////////

// A fake implementation of MetronomeClient. It does not provide true
// synchronization and only exists to exercise the interfaces.
class MetronomeClientFakeImpl : public MetronomeClient {
 public:
  MetronomeClientFakeImpl()
      : random_offset_(base::RandInt(-1000000, 1000000)) {}

  ~MetronomeClientFakeImpl() override { beacon_timer_.Stop(); }

  // MetronomeClient:
  void AddObserver(Observer* observer) override {
    DCHECK(observer);
    observers_.AddObserver(observer);
  }

  void RemoveObserver(Observer* observer) override {
    DCHECK(observer);
    observers_.RemoveObserver(observer);
  }

  // DBusClient:
  void Init(dbus::Bus* bus) override {
    beacon_timer_.Start(FROM_HERE,
                        base::TimeDelta::FromMilliseconds(1000),
                        this,
                        &MetronomeClientFakeImpl::UpdateBeacon);
  }

 private:
  void UpdateBeacon() {
    base::Time now_time = base::Time::Now();
    base::TimeTicks now_ticks = base::TimeTicks::Now();
    uint64 fake_beacon_timestamp = now_time.ToInternalValue() +
                                   base::RandInt(-1000, 1000);
    uint64 fake_local_timestamp = now_ticks.ToInternalValue() + random_offset_ +
                                  base::RandInt(-1000, 1000);
    FOR_EACH_OBSERVER(
        Observer, observers_,
        OnTimestampUpdated(fake_beacon_timestamp, fake_local_timestamp));
  }

  int64 random_offset_;
  base::RepeatingTimer<MetronomeClientFakeImpl> beacon_timer_;

  // List of observers interested in event notifications from us.
  ObserverList<Observer> observers_;

  DISALLOW_COPY_AND_ASSIGN(MetronomeClientFakeImpl);
};

////////////////////////////////////////////////////////////////////////////////

// A stub implementation of MetronomeClient. It allows unit tests to complete.
class MetronomeClientStubImpl : public MetronomeClient {
 public:
  MetronomeClientStubImpl() {}
  ~MetronomeClientStubImpl() override {}

  // MetronomeClient:
  void AddObserver(Observer* observer) override {}
  void RemoveObserver(Observer* observer) override {}

  // DBusClient:
  void Init(dbus::Bus* bus) override {}

 private:
  DISALLOW_COPY_AND_ASSIGN(MetronomeClientStubImpl);
};

}  // namespace

////////////////////////////////////////////////////////////////////////////////

MetronomeClient::MetronomeClient() {
}

MetronomeClient::~MetronomeClient() {
}

// static
MetronomeClient* MetronomeClient::Create(DBusClientImplementationType type) {
  if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
    return new MetronomeClientImpl();
  DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);

  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
          switches::kTestMetronomeTimer)) {
    return new MetronomeClientFakeImpl();
  }
  return new MetronomeClientStubImpl();
}

}  // namespace chromeos