// 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/cast_channel/cast_message_handler.h"

#include "base/json/json_reader.h"
#include "base/run_loop.h"
#include "base/strings/stringprintf.h"
#include "base/test/test_simple_task_runner.h"
#include "components/cast_channel/cast_test_util.h"
#include "content/public/test/test_browser_thread_bundle.h"
#include "services/data_decoder/public/cpp/testing_json_parser.h"
#include "services/service_manager/public/cpp/connector.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

using testing::_;
using testing::SaveArg;

namespace cast_channel {

namespace {

constexpr char kTestUserAgentString[] =
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) "
    "Chrome/66.0.3331.0 Safari/537.36";
constexpr char kSourceId[] = "sourceId";
constexpr char kDestinationId[] = "destinationId";

std::unique_ptr<base::Value> GetDictionaryFromCastMessage(
    const CastMessage& message) {
  if (!message.has_payload_utf8())
    return nullptr;

  return base::JSONReader::Read(message.payload_utf8());
}

CastMessageType GetMessageType(const CastMessage& message) {
  std::unique_ptr<base::Value> dict = GetDictionaryFromCastMessage(message);
  if (!dict)
    return CastMessageType::kOther;

  const base::Value* message_type =
      dict->FindKeyOfType("type", base::Value::Type::STRING);
  if (!message_type)
    return CastMessageType::kOther;

  return CastMessageTypeFromString(message_type->GetString());
}

}  // namespace

class CastMessageHandlerTest : public testing::Test {
 public:
  CastMessageHandlerTest()
      : thread_bundle_(
            base::test::ScopedTaskEnvironment::MainThreadType::MOCK_TIME),
        cast_socket_service_(new base::TestSimpleTaskRunner()),
        handler_(&cast_socket_service_,
                 /* connector */ nullptr,
                 base::Token{1, 1},
                 kTestUserAgentString,
                 "66.0.3331.0",
                 "en-US") {
    ON_CALL(cast_socket_service_, GetSocket(_))
        .WillByDefault(testing::Return(&cast_socket_));
  }

  ~CastMessageHandlerTest() override {}

  void OnMessage(const CastMessage& message) {
    handler_.OnMessage(cast_socket_, message);
  }

  void OnError(ChannelError error) { handler_.OnError(cast_socket_, error); }

  void OnAppAvailability(const std::string& app_id,
                         GetAppAvailabilityResult result) {
    if (run_loop_)
      run_loop_->Quit();
    DoOnAppAvailability(app_id, result);
  }

  MOCK_METHOD2(DoOnAppAvailability,
               void(const std::string& app_id,
                    GetAppAvailabilityResult result));

  void ExpectSessionLaunchResult(LaunchSessionResponse::Result expected_result,
                                 LaunchSessionResponse response) {
    if (run_loop_)
      run_loop_->Quit();
    ++session_launch_response_count_;
    EXPECT_EQ(expected_result, response.result);
    if (response.result == LaunchSessionResponse::Result::kOk)
      EXPECT_TRUE(response.receiver_status);
  }

 protected:
  content::TestBrowserThreadBundle thread_bundle_;
  std::unique_ptr<base::RunLoop> run_loop_;
  MockCastSocketService cast_socket_service_;
  data_decoder::TestingJsonParser::ScopedFactoryOverride parser_override_;
  CastMessageHandler handler_;
  MockCastSocket cast_socket_;
  int session_launch_response_count_ = 0;

 private:
  DISALLOW_COPY_AND_ASSIGN(CastMessageHandlerTest);
};

TEST_F(CastMessageHandlerTest, VirtualConnectionCreatedOnlyOnce) {
  CastMessage virtual_connection_request;
  CastMessage app_availability_request1;
  CastMessage app_availability_request2;
  EXPECT_CALL(*cast_socket_.mock_transport(), SendMessage(_, _))
      .WillOnce(SaveArg<0>(&virtual_connection_request))
      .WillOnce(SaveArg<0>(&app_availability_request1))
      .WillOnce(SaveArg<0>(&app_availability_request2));

  handler_.RequestAppAvailability(
      &cast_socket_, "AAAAAAAA",
      base::BindOnce(&CastMessageHandlerTest::OnAppAvailability,
                     base::Unretained(this)));
  handler_.RequestAppAvailability(
      &cast_socket_, "BBBBBBBB",
      base::BindOnce(&CastMessageHandlerTest::OnAppAvailability,
                     base::Unretained(this)));

  EXPECT_EQ(CastMessageType::kConnect,
            GetMessageType(virtual_connection_request));
  EXPECT_EQ(CastMessageType::kGetAppAvailability,
            GetMessageType(app_availability_request1));
  EXPECT_EQ(CastMessageType::kGetAppAvailability,
            GetMessageType(app_availability_request2));
}

TEST_F(CastMessageHandlerTest, RecreateVirtualConnectionAfterError) {
  CastMessage virtual_connection_request;
  CastMessage app_availability_request;
  EXPECT_CALL(*cast_socket_.mock_transport(), SendMessage(_, _))
      .WillOnce(SaveArg<0>(&virtual_connection_request))
      .WillOnce(SaveArg<0>(&app_availability_request));

  handler_.RequestAppAvailability(
      &cast_socket_, "AAAAAAAA",
      base::BindOnce(&CastMessageHandlerTest::OnAppAvailability,
                     base::Unretained(this)));
  EXPECT_EQ(CastMessageType::kConnect,
            GetMessageType(virtual_connection_request));
  EXPECT_EQ(CastMessageType::kGetAppAvailability,
            GetMessageType(app_availability_request));

  EXPECT_CALL(*this, DoOnAppAvailability("AAAAAAAA",
                                         GetAppAvailabilityResult::kUnknown));
  OnError(ChannelError::TRANSPORT_ERROR);

  EXPECT_CALL(*cast_socket_.mock_transport(), SendMessage(_, _))
      .WillOnce(SaveArg<0>(&virtual_connection_request))
      .WillOnce(SaveArg<0>(&app_availability_request));

  handler_.RequestAppAvailability(
      &cast_socket_, "BBBBBBBB",
      base::BindOnce(&CastMessageHandlerTest::OnAppAvailability,
                     base::Unretained(this)));

  EXPECT_EQ(CastMessageType::kConnect,
            GetMessageType(virtual_connection_request));
  EXPECT_EQ(CastMessageType::kGetAppAvailability,
            GetMessageType(app_availability_request));
  // The callback is invoked with kUnknown before the PendingRequests is
  // destroyed.
  EXPECT_CALL(*this, DoOnAppAvailability("BBBBBBBB",
                                         GetAppAvailabilityResult::kUnknown));
}

TEST_F(CastMessageHandlerTest, RequestAppAvailability) {
  CastMessage virtual_connection_request;
  CastMessage app_availability_request;
  EXPECT_CALL(*cast_socket_.mock_transport(), SendMessage(_, _))
      .WillOnce(SaveArg<0>(&virtual_connection_request))
      .WillOnce(SaveArg<0>(&app_availability_request));

  handler_.RequestAppAvailability(
      &cast_socket_, "ABCDEFAB",
      base::BindOnce(&CastMessageHandlerTest::OnAppAvailability,
                     base::Unretained(this)));

  EXPECT_EQ(CastMessageType::kConnect,
            GetMessageType(virtual_connection_request));
  EXPECT_EQ(CastMessageType::kGetAppAvailability,
            GetMessageType(app_availability_request));

  std::unique_ptr<base::Value> dict =
      GetDictionaryFromCastMessage(app_availability_request);
  ASSERT_TRUE(dict);
  const base::Value* request_id_value =
      dict->FindKeyOfType("requestId", base::Value::Type::INTEGER);
  ASSERT_TRUE(request_id_value);
  int request_id = request_id_value->GetInt();
  EXPECT_GT(request_id, 0);

  CastMessage response;
  response.set_namespace_("urn:x-cast:com.google.cast.receiver");
  response.set_source_id("receiver-0");
  response.set_destination_id(handler_.sender_id());
  response.set_payload_type(
      CastMessage::PayloadType::CastMessage_PayloadType_STRING);
  response.set_payload_utf8(
      base::StringPrintf("{\"requestId\": %d, \"availability\": {\"ABCDEFAB\": "
                         "\"APP_AVAILABLE\"}}",
                         request_id));

  run_loop_ = std::make_unique<base::RunLoop>();
  EXPECT_CALL(*this, DoOnAppAvailability("ABCDEFAB",
                                         GetAppAvailabilityResult::kAvailable));
  OnMessage(response);
  run_loop_->Run();
}

TEST_F(CastMessageHandlerTest, RequestAppAvailabilityTimesOut) {
  EXPECT_CALL(*cast_socket_.mock_transport(), SendMessage(_, _)).Times(2);
  handler_.RequestAppAvailability(
      &cast_socket_, "ABCDEFAB",
      base::BindOnce(&CastMessageHandlerTest::OnAppAvailability,
                     base::Unretained(this)));
  EXPECT_CALL(*this, DoOnAppAvailability("ABCDEFAB",
                                         GetAppAvailabilityResult::kUnknown));
  thread_bundle_.FastForwardBy(base::TimeDelta::FromSeconds(5));
}

TEST_F(CastMessageHandlerTest, AppAvailabilitySentOnlyOnceWhilePending) {
  EXPECT_CALL(*cast_socket_.mock_transport(), SendMessage(_, _)).Times(2);
  handler_.RequestAppAvailability(
      &cast_socket_, "ABCDEFAB",
      base::BindOnce(&CastMessageHandlerTest::OnAppAvailability,
                     base::Unretained(this)));

  EXPECT_CALL(*cast_socket_.mock_transport(), SendMessage(_, _)).Times(0);
  handler_.RequestAppAvailability(
      &cast_socket_, "ABCDEFAB",
      base::BindOnce(&CastMessageHandlerTest::OnAppAvailability,
                     base::Unretained(this)));
}

TEST_F(CastMessageHandlerTest, EnsureConnection) {
  CastMessage virtual_connection_request;
  EXPECT_CALL(*cast_socket_.mock_transport(), SendMessage(_, _))
      .WillOnce(SaveArg<0>(&virtual_connection_request));

  handler_.EnsureConnection(cast_socket_.id(), kSourceId, kDestinationId);
  EXPECT_EQ(CastMessageType::kConnect,
            GetMessageType(virtual_connection_request));

  // No-op because connection is already created the first time.
  EXPECT_CALL(*cast_socket_.mock_transport(), SendMessage(_, _)).Times(0);
  handler_.EnsureConnection(cast_socket_.id(), kSourceId, kDestinationId);
}

TEST_F(CastMessageHandlerTest, CloseConnectionFromReceiver) {
  CastMessage virtual_connection_request;
  EXPECT_CALL(*cast_socket_.mock_transport(), SendMessage(_, _));
  handler_.EnsureConnection(cast_socket_.id(), kSourceId, kDestinationId);

  CastMessage response;
  response.set_namespace_("urn:x-cast:com.google.cast.tp.connection");
  response.set_source_id(kDestinationId);
  response.set_destination_id(kSourceId);
  response.set_payload_type(
      CastMessage::PayloadType::CastMessage_PayloadType_STRING);
  response.set_payload_utf8(R"({
      "type": "CLOSE"
  })");
  OnMessage(response);
  // Wait for message to be parsed and handled.
  thread_bundle_.RunUntilIdle();

  // Re-open virtual connection should cause message to be sent.
  EXPECT_CALL(*cast_socket_.mock_transport(), SendMessage(_, _));
  handler_.EnsureConnection(cast_socket_.id(), kSourceId, kDestinationId);
}

TEST_F(CastMessageHandlerTest, LaunchSession) {
  CastMessage virtual_connection_request;
  CastMessage launch_session_request;
  EXPECT_CALL(*cast_socket_.mock_transport(), SendMessage(_, _))
      .WillOnce(SaveArg<0>(&virtual_connection_request))
      .WillOnce(SaveArg<0>(&launch_session_request));

  handler_.LaunchSession(
      cast_socket_.id(), "AAAAAAAA", base::TimeDelta::FromSeconds(30),
      base::BindOnce(&CastMessageHandlerTest::ExpectSessionLaunchResult,
                     base::Unretained(this),
                     LaunchSessionResponse::Result::kOk));
  EXPECT_EQ(CastMessageType::kConnect,
            GetMessageType(virtual_connection_request));
  EXPECT_EQ(CastMessageType::kLaunch, GetMessageType(launch_session_request));

  std::unique_ptr<base::Value> dict =
      GetDictionaryFromCastMessage(launch_session_request);
  ASSERT_TRUE(dict);
  const base::Value* request_id_value =
      dict->FindKeyOfType("requestId", base::Value::Type::INTEGER);
  ASSERT_TRUE(request_id_value);
  int request_id = request_id_value->GetInt();
  EXPECT_GT(request_id, 0);

  CastMessage response;
  response.set_namespace_("urn:x-cast:com.google.cast.receiver");
  response.set_source_id("receiver-0");
  response.set_destination_id(handler_.sender_id());
  response.set_payload_type(
      CastMessage::PayloadType::CastMessage_PayloadType_STRING);
  response.set_payload_utf8(
      base::StringPrintf("{"
                         "\"type\": \"RECEIVER_STATUS\","
                         "\"requestId\": %d,"
                         "\"status\": {}"
                         "}",
                         request_id));

  run_loop_ = std::make_unique<base::RunLoop>();
  OnMessage(response);
  run_loop_->Run();
  EXPECT_EQ(1, session_launch_response_count_);
}

TEST_F(CastMessageHandlerTest, LaunchSessionTimedOut) {
  CastMessage virtual_connection_request;
  CastMessage launch_session_request;
  EXPECT_CALL(*cast_socket_.mock_transport(), SendMessage(_, _))
      .WillOnce(SaveArg<0>(&virtual_connection_request))
      .WillOnce(SaveArg<0>(&launch_session_request));

  handler_.LaunchSession(
      cast_socket_.id(), "AAAAAAAA", base::TimeDelta::FromSeconds(30),
      base::BindOnce(&CastMessageHandlerTest::ExpectSessionLaunchResult,
                     base::Unretained(this),
                     LaunchSessionResponse::Result::kTimedOut));
  EXPECT_EQ(CastMessageType::kConnect,
            GetMessageType(virtual_connection_request));
  EXPECT_EQ(CastMessageType::kLaunch, GetMessageType(launch_session_request));

  thread_bundle_.FastForwardBy(base::TimeDelta::FromSeconds(30));
  EXPECT_EQ(1, session_launch_response_count_);
}

TEST_F(CastMessageHandlerTest, SendAppMessage) {
  CastMessage virtual_connection_request;
  CastMessage app_message;
  EXPECT_CALL(*cast_socket_.mock_transport(), SendMessage(_, _))
      .WillOnce(SaveArg<0>(&virtual_connection_request))
      .WillOnce(SaveArg<0>(&app_message));

  base::Value body(base::Value::Type::DICTIONARY);
  body.SetKey("foo", base::Value("bar"));
  CastMessage message =
      CreateCastMessage("namespace", body, kSourceId, kDestinationId);
  handler_.SendAppMessage(cast_socket_.id(), message);

  EXPECT_EQ(CastMessageType::kConnect,
            GetMessageType(virtual_connection_request));
  EXPECT_EQ(message.payload_utf8(), app_message.payload_utf8());
}

}  // namespace cast_channel