// Copyright (c) 2013 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 "ui/message_center/fake_notifier_settings_provider.h"

#include "base/strings/utf_string_conversions.h"
#include "ui/gfx/image/image.h"

namespace message_center {

FakeNotifierSettingsProvider::NotifierGroupItem::NotifierGroupItem() {
}

FakeNotifierSettingsProvider::NotifierGroupItem::~NotifierGroupItem() {
}

FakeNotifierSettingsProvider::FakeNotifierSettingsProvider()
    : closed_called_count_(0),
      active_item_index_(0),
      notifier_settings_requested_count_(0u) { }

FakeNotifierSettingsProvider::FakeNotifierSettingsProvider(
    const std::vector<Notifier*>& notifiers)
    : closed_called_count_(0),
      active_item_index_(0),
      notifier_settings_requested_count_(0u) {
  NotifierGroupItem item;
  item.group = new NotifierGroup(gfx::Image(),
                                 base::UTF8ToUTF16("Fake name"),
                                 base::UTF8ToUTF16("fake@email.com"));
  item.notifiers = notifiers;
  items_.push_back(item);
}

FakeNotifierSettingsProvider::~FakeNotifierSettingsProvider() {
  for (size_t i = 0; i < items_.size(); ++i) {
    delete items_[i].group;
  }
}

size_t FakeNotifierSettingsProvider::GetNotifierGroupCount() const {
  return items_.size();
}

const message_center::NotifierGroup&
FakeNotifierSettingsProvider::GetNotifierGroupAt(size_t index) const {
  return *(items_[index].group);
}

bool FakeNotifierSettingsProvider::IsNotifierGroupActiveAt(
    size_t index) const {
  return active_item_index_ == index;
}

void FakeNotifierSettingsProvider::SwitchToNotifierGroup(size_t index) {
  active_item_index_ = index;
}

const message_center::NotifierGroup&
FakeNotifierSettingsProvider::GetActiveNotifierGroup() const {
  return *(items_[active_item_index_].group);
}

void FakeNotifierSettingsProvider::GetNotifierList(
    std::vector<Notifier*>* notifiers) {
  notifiers->clear();
  for (size_t i = 0; i < items_[active_item_index_].notifiers.size(); ++i)
    notifiers->push_back(items_[active_item_index_].notifiers[i]);
}

void FakeNotifierSettingsProvider::SetNotifierEnabled(const Notifier& notifier,
                                                      bool enabled) {
  enabled_[&notifier] = enabled;
}

void FakeNotifierSettingsProvider::OnNotifierSettingsClosing() {
  closed_called_count_++;
}

bool FakeNotifierSettingsProvider::NotifierHasAdvancedSettings(
    const message_center::NotifierId& notifier_id) const {
  if (!notifier_id_with_settings_handler_)
    return false;
  return *notifier_id_with_settings_handler_ == notifier_id;
}

void FakeNotifierSettingsProvider::OnNotifierAdvancedSettingsRequested(
    const NotifierId& notifier_id,
    const std::string* notification_id) {
  notifier_settings_requested_count_++;
}

void FakeNotifierSettingsProvider::AddObserver(
    NotifierSettingsObserver* observer) {
}

void FakeNotifierSettingsProvider::RemoveObserver(
    NotifierSettingsObserver* observer) {
}

bool FakeNotifierSettingsProvider::WasEnabled(const Notifier& notifier) {
  return enabled_[&notifier];
}

void FakeNotifierSettingsProvider::AddGroup(
    NotifierGroup* group, const std::vector<Notifier*>& notifiers) {
  NotifierGroupItem item;
  item.group = group;
  item.notifiers = notifiers;
  items_.push_back(item);
}

void FakeNotifierSettingsProvider::SetNotifierHasAdvancedSettings(
    const NotifierId& notifier_id) {
  notifier_id_with_settings_handler_.reset(new NotifierId(notifier_id));
}

int FakeNotifierSettingsProvider::closed_called_count() {
  return closed_called_count_;
}

size_t FakeNotifierSettingsProvider::settings_requested_count() const {
  return notifier_settings_requested_count_;
}

}  // namespace message_center