// 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.

#ifndef DIAGNOSTICS_WILCO_DTC_SUPPORTD_FAKE_WILCO_DTC_H_
#define DIAGNOSTICS_WILCO_DTC_SUPPORTD_FAKE_WILCO_DTC_H_

#include <memory>
#include <string>
#include <utility>

#include <base/callback.h>
#include <base/macros.h>
#include <base/optional.h>

#include <brillo/grpc/async_grpc_client.h>
#include <brillo/grpc/async_grpc_server.h>

#include "wilco_dtc.grpc.pb.h"           // NOLINT(build/include)
#include "wilco_dtc_supportd.grpc.pb.h"  // NOLINT(build/include)

namespace diagnostics {

// Helper class that allows to test gRPC communication between wilco_dtc and
// support daemon.
//
// This class runs a "WilcoDtc" gRPC server on the given |grpc_server_uri| URI,
// and a gRPC client to the "WilcoDtcSupportd" gRPC service on the
// |wilco_dtc_supportd_grpc_uri| gRPC URI.
class FakeWilcoDtc final {
 public:
  using SendMessageToUiCallback = base::Callback<void(
      grpc::Status status,
      std::unique_ptr<grpc_api::SendMessageToUiResponse> response)>;
  using GetProcDataCallback = base::Callback<void(
      grpc::Status status, std::unique_ptr<grpc_api::GetProcDataResponse>)>;
  using GetEcTelemetryCallback = base::Callback<void(
      grpc::Status status, std::unique_ptr<grpc_api::GetEcTelemetryResponse>)>;
  using HandleMessageFromUiCallback = base::Callback<void(
      grpc::Status status,
      std::unique_ptr<grpc_api::HandleMessageFromUiResponse>)>;
  using HandleEcNotificationCallback = base::Callback<void(
      grpc::Status status,
      std::unique_ptr<grpc_api::HandleEcNotificationResponse>)>;
  using HandlePowerNotificationCallback = base::Callback<void(
      grpc::Status status,
      std::unique_ptr<grpc_api::HandlePowerNotificationResponse>)>;
  using PerformWebRequestResponseCallback = base::Callback<void(
      grpc::Status status,
      std::unique_ptr<grpc_api::PerformWebRequestResponse>)>;
  using GetConfigurationDataCallback = base::Callback<void(
      grpc::Status status,
      std::unique_ptr<grpc_api::GetConfigurationDataResponse>)>;
  using GetDriveSystemDataCallback = base::Callback<void(
      grpc::Status status,
      std::unique_ptr<grpc_api::GetDriveSystemDataResponse>)>;
  using RequestBluetoothDataNotificationCallback = base::Callback<void(
      grpc::Status status,
      std::unique_ptr<grpc_api::RequestBluetoothDataNotificationResponse>)>;
  using GetStatefulPartitionAvailableCapacityCallback = base::Callback<void(
      grpc::Status status,
      std::unique_ptr<
          grpc_api::GetStatefulPartitionAvailableCapacityResponse>)>;
  using HandleConfigurationDataChangedCallback = base::Callback<void(
      grpc::Status status,
      std::unique_ptr<grpc_api::HandleConfigurationDataChangedResponse>)>;
  using HandleBluetoothDataChangedCallback = base::Callback<void(
      grpc::Status status,
      std::unique_ptr<grpc_api::HandleBluetoothDataChangedResponse>)>;
  using GetAvailableRoutinesCallback = base::Callback<void(
      grpc::Status status,
      std::unique_ptr<grpc_api::GetAvailableRoutinesResponse>)>;

  using HandleEcNotificationRequestCallback =
      base::RepeatingCallback<void(int32_t, const std::string&)>;
  using HandlePowerNotificationRequestCallback = base::RepeatingCallback<void(
      grpc_api::HandlePowerNotificationRequest::PowerEvent)>;
  using HandleBluetoothDataChangedRequestCallback =
      base::RepeatingCallback<void(
          const grpc_api::HandleBluetoothDataChangedRequest&)>;

  FakeWilcoDtc(const std::string& grpc_server_uri,
               const std::string& wilco_dtc_supportd_grpc_uri);
  ~FakeWilcoDtc();

  // Methods that correspond to the "WilcoDtcSupportd" gRPC interface and allow
  // to perform actual gRPC requests as if the wilco_dtc daemon would do them:
  void SendMessageToUi(const grpc_api::SendMessageToUiRequest& request,
                       SendMessageToUiCallback callback);
  void GetProcData(const grpc_api::GetProcDataRequest& request,
                   GetProcDataCallback callback);
  void GetEcTelemetry(const grpc_api::GetEcTelemetryRequest& request,
                      GetEcTelemetryCallback callback);
  void PerformWebRequest(const grpc_api::PerformWebRequestParameter& parameter,
                         const PerformWebRequestResponseCallback& callback);
  void GetConfigurationData(
      const grpc_api::GetConfigurationDataRequest& request,
      const GetConfigurationDataCallback& callback);
  void GetDriveSystemData(const grpc_api::GetDriveSystemDataRequest& request,
                          const GetDriveSystemDataCallback& callback);
  void RequestBluetoothDataNotification(
      const grpc_api::RequestBluetoothDataNotificationRequest& request,
      const RequestBluetoothDataNotificationCallback& callback);
  void GetStatefulPartitionAvailableCapacity(
      const grpc_api::GetStatefulPartitionAvailableCapacityRequest& request,
      const GetStatefulPartitionAvailableCapacityCallback& callback);
  void GetAvailableRoutines(const GetAvailableRoutinesCallback& callback);

  // Sets up the passed callback to be used for subsequent
  // |HandleMessageFromUi| gRPC calls.
  void set_handle_message_from_ui_callback(
      base::Closure handle_message_from_ui_callback) {
    handle_message_from_ui_callback_.emplace(
        std::move(handle_message_from_ui_callback));
  }

  // Sets up the passed json message to be used as a response for subsequent
  // |HandleMessageFromUi| gRPC calls.
  void set_handle_message_from_ui_json_message_response(
      const std::string& json_message_response) {
    handle_message_from_ui_json_message_response_.emplace(
        json_message_response);
  }

  // Sets up the passed callback to be used for subsequent
  // |HandleEcNotification| gRPC calls.
  void set_handle_ec_event_request_callback(
      HandleEcNotificationRequestCallback handle_ec_event_request_callback) {
    handle_ec_event_request_callback_ = handle_ec_event_request_callback;
  }

  // Sets up the passed callback to be used for subsequent
  // |HandlePowerNotification| gRPC calls.
  void set_handle_power_event_request_callback(
      HandlePowerNotificationRequestCallback
          handle_powerd_event_request_callback) {
    handle_power_event_request_callback_ = handle_powerd_event_request_callback;
  }

  const base::Optional<std::string>&
  handle_message_from_ui_actual_json_message() const {
    return handle_message_from_ui_actual_json_message_;
  }

  // Sets up the passed callback to be used for subsequent
  // |HandleConfigurationDataChanged| gRPC calls.
  void set_configuration_data_changed_callback(
      base::RepeatingClosure callback) {
    configuration_data_changed_callback_.emplace(std::move(callback));
  }

  // Sets up the passed callback to be used for subsequent
  // |HandleBluetoothDataChanged| gRPC calls.
  void set_bluetooth_data_changed_callback(
      HandleBluetoothDataChangedRequestCallback callback) {
    bluetooth_data_changed_request_callback_.emplace(std::move(callback));
  }

 private:
  using AsyncGrpcWilcoDtcServer =
      brillo::AsyncGrpcServer<grpc_api::WilcoDtc::AsyncService>;
  using AsyncGrpcWilcoDtcSupportdClient =
      brillo::AsyncGrpcClient<grpc_api::WilcoDtcSupportd>;

  // Receives gRPC request and saves json message from request in
  // |handle_message_from_ui_actual_json_message_|.
  // Calls the callback |handle_message_from_ui_callback_| after all.
  void HandleMessageFromUi(
      std::unique_ptr<grpc_api::HandleMessageFromUiRequest> request,
      const HandleMessageFromUiCallback& callback);

  // Receives gRPC request and invokes the given |callback| with gRPC response.
  // Calls the callback |handle_ec_event_request_callback_| after all with the
  // request type and payload.
  void HandleEcNotification(
      std::unique_ptr<grpc_api::HandleEcNotificationRequest> request,
      const HandleEcNotificationCallback& callback);

  // Receives gRPC request and invokes the given |callback| with gRPC response.
  // Calls the callback |handle_power_event_request_callback_| after all with
  // the request type and payload.
  void HandlePowerNotification(
      std::unique_ptr<grpc_api::HandlePowerNotificationRequest> request,
      const HandlePowerNotificationCallback& callback);

  // Receives gRPC request and invokes the given |callback| with gRPC response.
  // Calls the callback |configuration_data_changed_callback_| after all.
  void HandleConfigurationDataChanged(
      std::unique_ptr<grpc_api::HandleConfigurationDataChangedRequest> request,
      const HandleConfigurationDataChangedCallback& callback);

  // Receives gRPC request and invokes the given |callback| with gRPC response.
  // Calls the callback |bluetooth_data_changed_callback_| after all.
  void HandleBluetoothDataChanged(
      std::unique_ptr<grpc_api::HandleBluetoothDataChangedRequest> request,
      const HandleBluetoothDataChangedCallback& callback);

  AsyncGrpcWilcoDtcServer grpc_server_;
  AsyncGrpcWilcoDtcSupportdClient wilco_dtc_supportd_grp_client_;

  base::Optional<base::Closure> handle_message_from_ui_callback_;
  base::Optional<std::string> handle_message_from_ui_actual_json_message_;
  base::Optional<std::string> handle_message_from_ui_json_message_response_;

  base::Optional<HandleEcNotificationRequestCallback>
      handle_ec_event_request_callback_;

  base::Optional<HandlePowerNotificationRequestCallback>
      handle_power_event_request_callback_;

  base::Optional<base::RepeatingClosure> configuration_data_changed_callback_;

  base::Optional<HandleBluetoothDataChangedRequestCallback>
      bluetooth_data_changed_request_callback_;

  DISALLOW_COPY_AND_ASSIGN(FakeWilcoDtc);
};

}  // namespace diagnostics

#endif  // DIAGNOSTICS_WILCO_DTC_SUPPORTD_FAKE_WILCO_DTC_H_