// Copyright 2018 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 "components/sync_sessions/test_matchers.h"

#include "components/sessions/core/session_id.h"
#include "components/sync/model/entity_data.h"
#include "components/sync/protocol/session_specifics.pb.h"
#include "components/sync_sessions/synced_session.h"

namespace sync_sessions {
namespace {

using testing::ContainerEq;
using testing::ElementsAreArray;
using testing::Matcher;
using testing::MatcherInterface;
using testing::MatchResultListener;
using testing::PrintToString;

class MatchesHeaderMatcher
    : public MatcherInterface<const sync_pb::SessionSpecifics&> {
 public:
  MatchesHeaderMatcher(Matcher<std::string> session_tag,
                       Matcher<std::vector<int>> window_ids,
                       Matcher<std::vector<int>> tab_ids)
      : session_tag_(session_tag), window_ids_(window_ids), tab_ids_(tab_ids) {}

  bool MatchAndExplain(const sync_pb::SessionSpecifics& actual,
                       MatchResultListener* listener) const override {
    if (!actual.has_header()) {
      *listener << " which is not a header entity";
      return false;
    }
    if (actual.tab_node_id() != -1) {
      *listener << " which has a valid tab node ID: " << actual.tab_node_id();
      return false;
    }
    if (!session_tag_.MatchAndExplain(actual.session_tag(), listener)) {
      *listener << " which contains an unexpected session tag: "
                << actual.session_tag();
      return false;
    }
    std::vector<int> actual_window_ids;
    std::vector<int> actual_tab_ids;
    for (const auto& window : actual.header().window()) {
      actual_window_ids.push_back(window.window_id());
      actual_tab_ids.insert(actual_tab_ids.end(), window.tab().begin(),
                            window.tab().end());
    }
    if (!window_ids_.MatchAndExplain(actual_window_ids, listener)) {
      *listener << " which contains unexpected windows: "
                << PrintToString(actual_window_ids);
      return false;
    }
    if (!tab_ids_.MatchAndExplain(actual_tab_ids, listener)) {
      *listener << " which contains unexpected tabs: "
                << PrintToString(actual_tab_ids);
      return false;
    }
    return true;
  }

  void DescribeTo(::std::ostream* os) const override {
    *os << "matches expected header";
  }

  void DescribeNegationTo(::std::ostream* os) const override {
    *os << "does not match expected header";
  }

 private:
  Matcher<std::string> session_tag_;
  Matcher<std::vector<int>> window_ids_;
  Matcher<std::vector<int>> tab_ids_;
};

class MatchesTabMatcher
    : public MatcherInterface<const sync_pb::SessionSpecifics&> {
 public:
  MatchesTabMatcher(Matcher<std::string> session_tag,
                    Matcher<int> window_id,
                    Matcher<int> tab_id,
                    Matcher<int> tab_node_id,
                    Matcher<std::vector<std::string>> urls)
      : session_tag_(session_tag),
        window_id_(window_id),
        tab_id_(tab_id),
        tab_node_id_(tab_node_id),
        urls_(urls) {}

  bool MatchAndExplain(const sync_pb::SessionSpecifics& actual,
                       MatchResultListener* listener) const override {
    if (!actual.has_tab()) {
      *listener << " which is not a tab entity";
      return false;
    }
    if (!session_tag_.MatchAndExplain(actual.session_tag(), listener)) {
      *listener << " which contains an unexpected session tag: "
                << actual.session_tag();
      return false;
    }
    if (!window_id_.MatchAndExplain(actual.tab().window_id(), listener)) {
      *listener << " which contains an unexpected window ID: "
                << actual.tab().window_id();
      return false;
    }
    if (!tab_id_.MatchAndExplain(actual.tab().tab_id(), listener)) {
      *listener << " which contains an unexpected tab ID: "
                << actual.tab().tab_id();
      return false;
    }
    if (!tab_node_id_.MatchAndExplain(actual.tab_node_id(), listener)) {
      *listener << " which contains an unexpected tab node ID: "
                << actual.tab_node_id();
      return false;
    }
    std::vector<std::string> actual_urls;
    for (const sync_pb::TabNavigation& navigation : actual.tab().navigation()) {
      actual_urls.push_back(navigation.virtual_url());
    }
    if (!urls_.MatchAndExplain(actual_urls, listener)) {
      *listener << " which contains unexpected navigation URLs";
      return false;
    }
    return true;
  }

  void DescribeTo(::std::ostream* os) const override {
    *os << "matches expected tab";
  }

  void DescribeNegationTo(::std::ostream* os) const override {
    *os << "does not match expected tab";
  }

 private:
  Matcher<std::string> session_tag_;
  Matcher<int> window_id_;
  Matcher<int> tab_id_;
  Matcher<int> tab_node_id_;
  Matcher<std::vector<std::string>> urls_;
};

class MatchesSyncedSessionMatcher
    : public MatcherInterface<const SyncedSession*> {
 public:
  MatchesSyncedSessionMatcher(
      Matcher<std::string> session_tag,
      Matcher<std::map<int, std::vector<int>>> window_id_to_tabs)
      : session_tag_(session_tag), window_id_to_tabs_(window_id_to_tabs) {}

  bool MatchAndExplain(const SyncedSession* actual,
                       MatchResultListener* listener) const override {
    if (!actual) {
      *listener << " which is null";
      return false;
    }
    if (!session_tag_.MatchAndExplain(actual->session_tag, listener)) {
      *listener << " which contains an unexpected session tag: "
                << actual->session_tag;
      return false;
    }

    std::map<int, std::vector<int>> actual_window_id_to_tabs;
    for (const auto& id_and_window : actual->windows) {
      const SessionID actual_window_id = id_and_window.first;
      if (actual_window_id != id_and_window.second->wrapped_window.window_id) {
        *listener << " which has an inconsistent window representation";
        return false;
      }
      actual_window_id_to_tabs.emplace(actual_window_id.id(),
                                       std::vector<int>());
      for (const auto& tab : id_and_window.second->wrapped_window.tabs) {
        actual_window_id_to_tabs[actual_window_id.id()].push_back(
            tab->tab_id.id());
      }
    }

    if (!window_id_to_tabs_.MatchAndExplain(actual_window_id_to_tabs,
                                            listener)) {
      return false;
    }
    return true;
  }

  void DescribeTo(::std::ostream* os) const override {
    *os << "matches expected synced session";
  }

  void DescribeNegationTo(::std::ostream* os) const override {
    *os << "does not match expected synced session";
  }

 private:
  Matcher<std::string> session_tag_;
  Matcher<std::map<int, std::vector<int>>> window_id_to_tabs_;
};

}  // namespace

Matcher<const sync_pb::SessionSpecifics&> MatchesHeader(
    Matcher<std::string> session_tag,
    Matcher<std::vector<int>> window_ids,
    Matcher<std::vector<int>> tab_ids) {
  return testing::MakeMatcher(
      new MatchesHeaderMatcher(session_tag, window_ids, tab_ids));
}

Matcher<const sync_pb::SessionSpecifics&> MatchesHeader(
    Matcher<std::string> session_tag,
    const std::vector<int>& window_ids,
    const std::vector<int>& tab_ids) {
  return MatchesHeader(session_tag, ElementsAreArray(window_ids),
                       ElementsAreArray(tab_ids));
}

Matcher<const sync_pb::SessionSpecifics&> MatchesTab(
    Matcher<std::string> session_tag,
    Matcher<int> window_id,
    Matcher<int> tab_id,
    Matcher<int> tab_node_id,
    Matcher<std::vector<std::string>> urls) {
  return testing::MakeMatcher(
      new MatchesTabMatcher(session_tag, window_id, tab_id, tab_node_id, urls));
}

Matcher<const sync_pb::SessionSpecifics&> MatchesTab(
    Matcher<std::string> session_tag,
    Matcher<int> window_id,
    Matcher<int> tab_id,
    Matcher<int> tab_node_id,
    const std::vector<std::string>& urls) {
  return MatchesTab(session_tag, window_id, tab_id, tab_node_id,
                    ElementsAreArray(urls));
}

Matcher<const SyncedSession*> MatchesSyncedSession(
    Matcher<std::string> session_tag,
    Matcher<std::map<int, std::vector<int>>> window_id_to_tabs) {
  return testing::MakeMatcher(
      new MatchesSyncedSessionMatcher(session_tag, window_id_to_tabs));
}

Matcher<const SyncedSession*> MatchesSyncedSession(
    Matcher<std::string> session_tag,
    const std::map<int, std::vector<int>>& window_id_to_tabs) {
  return MatchesSyncedSession(session_tag, ContainerEq(window_id_to_tabs));
}

}  // namespace sync_sessions