// 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 "chrome/browser/ui/webui/media_router/query_result_manager.h"

#include "base/containers/hash_tables.h"
#include "base/stl_util.h"
#include "chrome/browser/media/router/media_router.h"
#include "chrome/browser/media/router/media_sinks_observer.h"

namespace media_router {

// MediaSinkObserver that propagates results back to |result_manager|.
// An instance of this class is associated with each registered MediaCastMode.
class QueryResultManager::CastModeMediaSinksObserver
    : public MediaSinksObserver {
 public:
  CastModeMediaSinksObserver(MediaCastMode cast_mode,
                             const MediaSource& source,
                             MediaRouter* router,
                             QueryResultManager* result_manager)
      : MediaSinksObserver(router, source),
        cast_mode_(cast_mode),
        result_manager_(result_manager) {
    DCHECK(result_manager);
  }

  ~CastModeMediaSinksObserver() override {}

  // MediaSinksObserver
  void OnSinksReceived(const std::vector<MediaSink>& result) override {
    latest_sink_ids_.clear();
    for (const MediaSink& sink : result) {
      latest_sink_ids_.push_back(sink.id());
    }
    result_manager_->UpdateWithSinksQueryResult(cast_mode_, result);
    result_manager_->NotifyOnResultsUpdated();
  }

  // Returns the most recent sink IDs that were passed to |OnSinksReceived|.
  void GetLatestSinkIds(std::vector<MediaSink::Id>* sink_ids) const {
    DCHECK(sink_ids);
    *sink_ids = latest_sink_ids_;
  }

  MediaCastMode cast_mode() const { return cast_mode_; }

 private:
  MediaCastMode cast_mode_;
  std::vector<MediaSink::Id> latest_sink_ids_;
  QueryResultManager* result_manager_;
};

QueryResultManager::QueryResultManager(MediaRouter* router) : router_(router) {
  DCHECK(router_);
}

QueryResultManager::~QueryResultManager() {
  DCHECK(thread_checker_.CalledOnValidThread());
}

void QueryResultManager::AddObserver(Observer* observer) {
  DCHECK(thread_checker_.CalledOnValidThread());
  DCHECK(observer);
  observers_.AddObserver(observer);
}

void QueryResultManager::RemoveObserver(Observer* observer) {
  DCHECK(thread_checker_.CalledOnValidThread());
  DCHECK(observer);
  observers_.RemoveObserver(observer);
}

void QueryResultManager::StartSinksQuery(MediaCastMode cast_mode,
                                         const MediaSource& source) {
  DCHECK(thread_checker_.CalledOnValidThread());
  if (source.Empty()) {
    LOG(WARNING) << "StartSinksQuery called with empty source for "
                 << cast_mode;
    return;
  }

  SetSourceForCastMode(cast_mode, source);
  RemoveObserverForCastMode(cast_mode);
  UpdateWithSinksQueryResult(cast_mode, std::vector<MediaSink>());

  scoped_ptr<CastModeMediaSinksObserver> observer(
      new CastModeMediaSinksObserver(cast_mode, source, router_, this));
  observer->Init();
  auto result =
      sinks_observers_.insert(std::make_pair(cast_mode, std::move(observer)));
  DCHECK(result.second);
  NotifyOnResultsUpdated();
}

void QueryResultManager::StopSinksQuery(MediaCastMode cast_mode) {
  DCHECK(thread_checker_.CalledOnValidThread());
  RemoveObserverForCastMode(cast_mode);
  SetSourceForCastMode(cast_mode, MediaSource());
  UpdateWithSinksQueryResult(cast_mode, std::vector<MediaSink>());
  NotifyOnResultsUpdated();
}

void QueryResultManager::SetSourceForCastMode(
      MediaCastMode cast_mode, const MediaSource& source) {
  DCHECK(thread_checker_.CalledOnValidThread());
  cast_mode_sources_[cast_mode] = source;
}

void QueryResultManager::RemoveObserverForCastMode(MediaCastMode cast_mode) {
  auto observers_it = sinks_observers_.find(cast_mode);
  if (observers_it != sinks_observers_.end())
    sinks_observers_.erase(observers_it);
}

bool QueryResultManager::IsValid(const MediaSinkWithCastModes& entry) const {
  return !entry.cast_modes.empty();
}

void QueryResultManager::UpdateWithSinksQueryResult(
    MediaCastMode cast_mode,
    const std::vector<MediaSink>& result) {
  base::hash_set<MediaSink::Id> result_sink_ids;
  for (const MediaSink& sink : result)
    result_sink_ids.insert(sink.id());

  // (1) Iterate through current sink set, remove cast mode from those that
  // do not appear in latest result.
  for (auto it = all_sinks_.begin(); it != all_sinks_.end(); /*no-op*/) {
    if (!ContainsKey(result_sink_ids, it->first)) {
      it->second.cast_modes.erase(cast_mode);
    }
    if (!IsValid(it->second)) {
      all_sinks_.erase(it++);
    } else {
      ++it;
    }
  }

  // (2) Add / update sinks with latest result.
  for (const MediaSink& sink : result) {
    auto result =
      all_sinks_.insert(std::make_pair(sink.id(),
                                       MediaSinkWithCastModes(sink)));
    if (!result.second)
      result.first->second.sink = sink;
    result.first->second.cast_modes.insert(cast_mode);
  }
}

void QueryResultManager::GetSupportedCastModes(CastModeSet* cast_modes) const {
  DCHECK(cast_modes);
  cast_modes->clear();
  for (const auto& observer_pair : sinks_observers_) {
    cast_modes->insert(observer_pair.first);
  }
}

MediaSource QueryResultManager::GetSourceForCastMode(
      MediaCastMode cast_mode) const {
  DCHECK(thread_checker_.CalledOnValidThread());
  auto source_it = cast_mode_sources_.find(cast_mode);
  return source_it == cast_mode_sources_.end() ?
    MediaSource() : source_it->second;
}

void QueryResultManager::NotifyOnResultsUpdated() {
  std::vector<MediaSinkWithCastModes> sinks;
  for (const auto& sink_pair : all_sinks_) {
    sinks.push_back(sink_pair.second);
  }
  FOR_EACH_OBSERVER(QueryResultManager::Observer, observers_,
      OnResultsUpdated(sinks));
}

}  // namespace media_router