// Copyright 2018 The Chromium OS 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 <memory>
#include <string>
#include <utility>
#include <vector>

#include <base/bind.h>
#include <base/callback.h>
#include <base/message_loop/message_loop.h>
#include <base/optional.h>
#include <base/run_loop.h>
#include <base/strings/string_piece.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <mojo/edk/embedder/embedder.h>
#include <mojo/public/cpp/bindings/binding.h>
#include <mojo/public/cpp/bindings/interface_ptr.h>
#include <mojo/public/cpp/system/buffer.h>

#include "diagnostics/wilco_dtc_supportd/mock_mojom_wilco_dtc_supportd_client.h"
#include "diagnostics/wilco_dtc_supportd/mojo_test_utils.h"
#include "diagnostics/wilco_dtc_supportd/mojo_utils.h"
#include "diagnostics/wilco_dtc_supportd/wilco_dtc_supportd_mojo_service.h"

#include "mojo/diagnosticsd.mojom.h"

using testing::_;
using testing::Invoke;
using testing::StrictMock;
using testing::WithArg;

using MojomDiagnosticsdClient =
    chromeos::diagnosticsd::mojom::DiagnosticsdClient;
using MojomDiagnosticsdClientPtr =
    chromeos::diagnosticsd::mojom::DiagnosticsdClientPtr;
using MojomDiagnosticsdServiceRequest =
    chromeos::diagnosticsd::mojom::DiagnosticsdServiceRequest;
using MojomDiagnosticsdWebRequestStatus =
    chromeos::diagnosticsd::mojom::DiagnosticsdWebRequestStatus;
using MojomDiagnosticsdWebRequestHttpMethod =
    chromeos::diagnosticsd::mojom::DiagnosticsdWebRequestHttpMethod;

namespace diagnostics {

namespace {

constexpr char kHttpsUrl[] = "https://www.google.com";
constexpr int kHttpStatusOk = 200;
constexpr char kFakeBody[] = "fake response/request body";

void EmptySendUiMessageToDiagnosticsProcessorCallback(
    mojo::ScopedHandle response_json_message) {}

class MockWilcoDtcSupportdMojoServiceDelegate
    : public WilcoDtcSupportdMojoService::Delegate {
 public:
  MOCK_METHOD2(SendGrpcUiMessageToWilcoDtc,
               void(base::StringPiece json_message,
                    const SendGrpcUiMessageToWilcoDtcCallback& callback));
};

// Tests for the WilcoDtcSupportdMojoService class.
class WilcoDtcSupportdMojoServiceTest : public testing::Test {
 protected:
  WilcoDtcSupportdMojoServiceTest() {
    mojo::edk::Init();
    // Obtain Mojo interface pointer that talks to |mojo_client_| - the
    // connection between them will be maintained by |mojo_client_binding_|.
    MojomDiagnosticsdClientPtr mojo_client_interface_ptr;
    mojo_client_binding_ =
        std::make_unique<mojo::Binding<MojomDiagnosticsdClient>>(
            &mojo_client_, &mojo_client_interface_ptr);
    DCHECK(mojo_client_interface_ptr);

    service_ = std::make_unique<WilcoDtcSupportdMojoService>(
        &delegate_,
        MojomDiagnosticsdServiceRequest() /* self_interface_request */,
        std::move(mojo_client_interface_ptr));
  }

  MockWilcoDtcSupportdMojoServiceDelegate* delegate() { return &delegate_; }
  MockMojomWilcoDtcSupportdClient* mojo_client() { return &mojo_client_; }

  // TODO(lamzin@google.com): Extract the response JSON message and verify its
  // value.
  void SendJsonMessage(base::StringPiece json_message) {
    mojo::ScopedHandle handle =
        CreateReadOnlySharedMemoryMojoHandle(json_message);
    ASSERT_TRUE(handle.is_valid());
    service_->SendUiMessageToDiagnosticsProcessor(
        std::move(handle),
        base::Bind(&EmptySendUiMessageToDiagnosticsProcessorCallback));
  }

  void PerformWebRequest(MojomDiagnosticsdWebRequestHttpMethod http_method,
                         const std::string& url,
                         const std::vector<std::string>& headers,
                         const std::string& request_body,
                         MojomDiagnosticsdWebRequestStatus expected_status,
                         int expected_http_status) {
    base::RunLoop run_loop;
    // According to the implementation of MockMojomWilcoDtcSupportdClient
    // response_body is equal to request_body.
    service_->PerformWebRequest(
        http_method, url, headers, request_body,
        base::Bind(
            [](const base::Closure& quit_closure,
               MojomDiagnosticsdWebRequestStatus expected_status,
               int expected_http_status, std::string expected_response_body,
               MojomDiagnosticsdWebRequestStatus status, int http_status,
               base::StringPiece response_body) {
              EXPECT_EQ(expected_status, status);
              EXPECT_EQ(expected_http_status, http_status);
              EXPECT_EQ(expected_response_body, response_body);
              quit_closure.Run();
            },
            run_loop.QuitClosure(), expected_status, expected_http_status,
            request_body));
    run_loop.Run();
  }

  void GetConfigurationData(const std::string& expected_data) {
    base::RunLoop run_loop;
    service_->GetConfigurationData(base::Bind(
        [](const base::Closure& quit_closure, const std::string& expected_data,
           const std::string& json_configuration_data) {
          EXPECT_EQ(expected_data, json_configuration_data);
          quit_closure.Run();
        },
        run_loop.QuitClosure(), expected_data));
    run_loop.Run();
  }

 private:
  base::MessageLoop message_loop_;
  StrictMock<MockMojomWilcoDtcSupportdClient> mojo_client_;
  std::unique_ptr<mojo::Binding<MojomDiagnosticsdClient>> mojo_client_binding_;
  StrictMock<MockWilcoDtcSupportdMojoServiceDelegate> delegate_;
  std::unique_ptr<WilcoDtcSupportdMojoService> service_;
};

}  // namespace

// TODO(crbug.com/946330): Disabled due to flakiness.
TEST_F(WilcoDtcSupportdMojoServiceTest, DISABLED_SendUiMessageToWilcoDtc) {
  base::StringPiece json_message("{\"message\": \"Hello world!\"}");
  EXPECT_CALL(*delegate(), SendGrpcUiMessageToWilcoDtc(json_message, _));
  ASSERT_NO_FATAL_FAILURE(SendJsonMessage(json_message));
}

// TODO(crbug.com/946330): Disabled due to flakiness.
TEST_F(WilcoDtcSupportdMojoServiceTest,
       DISABLED_SendUiMessageToWilcoDtcInvalidJSON) {
  base::StringPiece json_message("{'message': 'Hello world!'}");
  EXPECT_CALL(*delegate(), SendGrpcUiMessageToWilcoDtc(_, _)).Times(0);
  ASSERT_NO_FATAL_FAILURE(SendJsonMessage(json_message));
}

// TODO(crbug.com/946330): Disabled due to flakiness.
TEST_F(WilcoDtcSupportdMojoServiceTest, DISABLED_PerformWebRequest) {
  EXPECT_CALL(
      *mojo_client(),
      PerformWebRequestImpl(MojomDiagnosticsdWebRequestHttpMethod::kGet,
                            kHttpsUrl, std::vector<std::string>(), kFakeBody));
  ASSERT_NO_FATAL_FAILURE(
      PerformWebRequest(MojomDiagnosticsdWebRequestHttpMethod::kGet, kHttpsUrl,
                        std::vector<std::string>(), kFakeBody,
                        MojomDiagnosticsdWebRequestStatus::kOk, kHttpStatusOk));
}

TEST_F(WilcoDtcSupportdMojoServiceTest, GetConfigurationData) {
  constexpr char kFakeJsonConfigurationData[] = "Fake JSON configuration data";
  EXPECT_CALL(*mojo_client(), GetConfigurationData(_))
      .WillOnce(WithArg<0>(
          Invoke([kFakeJsonConfigurationData](
                     const base::Callback<void(const std::string&)>& callback) {
            callback.Run(kFakeJsonConfigurationData);
          })));

  ASSERT_NO_FATAL_FAILURE(GetConfigurationData(kFakeJsonConfigurationData));
}

}  // namespace diagnostics