/*
 * Copyright 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#define LOG_TAG "VtsAgentSocketClient"

#include "SocketClientToDriver.h"

#include <android-base/logging.h>

#include "AgentRequestHandler.h"
#include "test/vts/proto/VtsDriverControlMessage.pb.h"

#define LOCALHOST_IP "127.0.0.1"

namespace android {
namespace vts {

bool VtsDriverSocketClient::Exit() {
  VtsDriverControlCommandMessage command_message;
  command_message.set_command_type(EXIT);
  if (!VtsSocketSendMessage(command_message)) return false;

  VtsDriverControlResponseMessage response_message;
  if (!VtsSocketRecvMessage(&response_message)) return false;
  return true;
}

int32_t VtsDriverSocketClient::LoadHal(
    const string& file_path, int target_class, int target_type,
    int target_version_major, int target_version_minor,
    const string& target_package, const string& target_component_name,
    const string& hw_binder_service_name, const string& module_name) {
  VtsDriverControlCommandMessage command_message;

  command_message.set_command_type(LOAD_HAL);
  command_message.set_file_path(file_path);
  command_message.set_target_class(target_class);
  command_message.set_target_type(target_type);
  command_message.set_target_version_major(target_version_major);
  command_message.set_target_version_minor(target_version_minor);
  command_message.set_target_package(target_package);
  command_message.set_target_component_name(target_component_name);
  command_message.set_module_name(module_name);
  command_message.set_hw_binder_service_name(hw_binder_service_name);
  if (!VtsSocketSendMessage(command_message)) return -1;

  VtsDriverControlResponseMessage response_message;
  if (!VtsSocketRecvMessage(&response_message)) return -1;
  if (response_message.response_code() != VTS_DRIVER_RESPONSE_SUCCESS) {
    LOG(ERROR) << "Failed to load the selected HAL.";
    return -1;
  }
  LOG(INFO) << "Loaded the selected HAL.";
  return response_message.return_value();
}

string VtsDriverSocketClient::GetFunctions() {
  VtsDriverControlCommandMessage command_message;
  command_message.set_command_type(LIST_FUNCTIONS);
  if (!VtsSocketSendMessage(command_message)) {
    return {};
  }

  VtsDriverControlResponseMessage response_message;
  if (!VtsSocketRecvMessage(&response_message)) {
    return {};
  }

  return response_message.return_message();
}

string VtsDriverSocketClient::ReadSpecification(const string& component_name,
                                                int target_class,
                                                int target_type,
                                                int target_version_major,
                                                int target_version_minor,
                                                const string& target_package) {
  VtsDriverControlCommandMessage command_message;

  command_message.set_command_type(
      VTS_DRIVER_COMMAND_READ_SPECIFICATION);
  command_message.set_module_name(component_name);
  command_message.set_target_class(target_class);
  command_message.set_target_type(target_type);
  command_message.set_target_version_major(target_version_major);
  command_message.set_target_version_minor(target_version_minor);
  command_message.set_target_package(target_package);

  if (!VtsSocketSendMessage(command_message)) {
    return {};
  }

  VtsDriverControlResponseMessage response_message;
  if (!VtsSocketRecvMessage(&response_message)) {
    return {};
  }

  return response_message.return_message();
}

string VtsDriverSocketClient::Call(const string& arg, const string& uid) {
  VtsDriverControlCommandMessage command_message;
  command_message.set_command_type(CALL_FUNCTION);
  command_message.set_arg(arg);
  command_message.set_driver_caller_uid(uid);
  if (!VtsSocketSendMessage(command_message)) {
    return {};
  }

  VtsDriverControlResponseMessage response_message;
  if (!VtsSocketRecvMessage(&response_message)) {
    return {};
  }

  LOG(DEBUG) << "Result: " << response_message.return_message();
  return response_message.return_message();
}

string VtsDriverSocketClient::GetAttribute(const string& arg) {
  VtsDriverControlCommandMessage command_message;
  command_message.set_command_type(GET_ATTRIBUTE);
  command_message.set_arg(arg);
  if (!VtsSocketSendMessage(command_message)) {
    return {};
  }

  VtsDriverControlResponseMessage response_message;
  if (!VtsSocketRecvMessage(&response_message)) {
    return {};
  }

  return response_message.return_message();
}

unique_ptr<VtsDriverControlResponseMessage>
VtsDriverSocketClient::ExecuteShellCommand(
    const ::google::protobuf::RepeatedPtrField<string> shell_command) {
  VtsDriverControlCommandMessage command_message;
  command_message.set_command_type(EXECUTE_COMMAND);
  for (const auto& cmd : shell_command) {
    command_message.add_shell_command(cmd);
  }
  if (!VtsSocketSendMessage(command_message)) return nullptr;

  auto response_message = make_unique<VtsDriverControlResponseMessage>();
  if (!VtsSocketRecvMessage(response_message.get())) return nullptr;

  return response_message;
}

bool VtsDriverSocketClient::ProcessFmqCommand(
    const FmqRequestMessage& fmq_request, FmqResponseMessage* fmq_response) {
  VtsDriverControlCommandMessage command_message;
  VtsDriverControlResponseMessage response_message;
  command_message.set_command_type(FMQ_OPERATION);
  (command_message.mutable_fmq_request())->CopyFrom(fmq_request);

  if (!VtsSocketSendMessage(command_message)) return false;
  if (!VtsSocketRecvMessage(&response_message)) return false;

  fmq_response->CopyFrom(response_message.fmq_response());
  return true;
}

bool VtsDriverSocketClient::ProcessHidlMemoryCommand(
    const HidlMemoryRequestMessage& hidl_memory_request,
    HidlMemoryResponseMessage* hidl_memory_response) {
  VtsDriverControlCommandMessage command_message;
  VtsDriverControlResponseMessage response_message;
  command_message.set_command_type(HIDL_MEMORY_OPERATION);
  (command_message.mutable_hidl_memory_request())
      ->CopyFrom(hidl_memory_request);

  if (!VtsSocketSendMessage(command_message)) return false;
  if (!VtsSocketRecvMessage(&response_message)) return false;

  hidl_memory_response->CopyFrom(response_message.hidl_memory_response());
  return true;
}

bool VtsDriverSocketClient::ProcessHidlHandleCommand(
    const HidlHandleRequestMessage& hidl_handle_request,
    HidlHandleResponseMessage* hidl_handle_response) {
  VtsDriverControlCommandMessage command_message;
  VtsDriverControlResponseMessage response_message;
  command_message.set_command_type(HIDL_HANDLE_OPERATION);
  (command_message.mutable_hidl_handle_request())
      ->CopyFrom(hidl_handle_request);

  if (!VtsSocketSendMessage(command_message)) {
    LOG(ERROR) << "Unable to send hidl_handle command from agent to driver.";
    return false;
  }
  if (!VtsSocketRecvMessage(&response_message)) {
    LOG(ERROR) << "Unable to receive hidl_handle message from driver to agent";
    return false;
  }

  hidl_handle_response->CopyFrom(response_message.hidl_handle_response());
  return true;
}

int32_t VtsDriverSocketClient::Status(int32_t type) {
  VtsDriverControlCommandMessage command_message;
  command_message.set_command_type(CALL_FUNCTION);
  command_message.set_status_type(type);
  if (!VtsSocketSendMessage(command_message)) return 0;

  VtsDriverControlResponseMessage response_message;
  if (!VtsSocketRecvMessage(&response_message)) return 0;
  return response_message.return_value();
}

string GetSocketPortFilePath(const string& service_name) {
  string result("/data/local/tmp/");
  result += service_name;
  return result;
}

bool IsDriverRunning(const string& service_name, int retry_count) {
  for (int retry = 0; retry < retry_count; retry++) {
    VtsDriverSocketClient* client = GetDriverSocketClient(service_name);
    if (client) {
      client->Exit();
      delete client;
      return true;
    }
    sleep(1);
  }
  LOG(ERROR) << "Couldn't connect to " << service_name;
  return false;
}

VtsDriverSocketClient* GetDriverSocketClient(const string& service_name) {
  string socket_port_file_path = GetSocketPortFilePath(service_name);
  VtsDriverSocketClient* client = new VtsDriverSocketClient();
  if (!client->Connect(socket_port_file_path)) {
    LOG(ERROR) << "Can't connect to " << socket_port_file_path;
    delete client;
    return NULL;
  }
  return client;
}

}  // namespace vts
}  // namespace android