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

#include "VtsCompilerUtils.h"

#include <limits.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#include <cstdint>
#include <fstream>
#include <iostream>
#include <sstream>

#include <google/protobuf/text_format.h>

#include "utils/InterfaceSpecUtil.h"
#include "utils/StringUtil.h"

#include "test/vts/proto/ComponentSpecificationMessage.pb.h"

using namespace std;

namespace android {
namespace vts {

string ComponentClassToString(int component_class) {
  switch (component_class) {
    case UNKNOWN_CLASS:
      return "unknown_class";
    case HAL_CONVENTIONAL:
      return "hal_conventional";
    case HAL_CONVENTIONAL_SUBMODULE:
      return "hal_conventional_submodule";
    case HAL_HIDL:
      return "hal_hidl";
    case HAL_HIDL_WRAPPED_CONVENTIONAL:
      return "hal_hidl_wrapped_conventional";
    case HAL_LEGACY:
      return "hal_legacy";
    case LIB_SHARED:
      return "lib_shared";
  }
  cerr << "error: invalid component_class " << component_class << endl;
  exit(-1);
}

string ComponentTypeToString(int component_type) {
  switch (component_type) {
    case UNKNOWN_TYPE:
      return "unknown_type";
    case AUDIO:
      return "audio";
    case CAMERA:
      return "camera";
    case GPS:
      return "gps";
    case LIGHT:
      return "light";
    case WIFI:
      return "wifi";
    case MOBILE:
      return "mobile";
    case BLUETOOTH:
      return "bluetooth";
    case TV_INPUT:
      return "tv_input";
    case NFC:
      return "nfc";
    case VEHICLE:
      return "vehicle";
    case VIBRATOR:
      return "vibrator";
    case THERMAL:
      return "thermal";
    case CONTEXTHUB:
      return "contexthub";
    case SENSORS:
      return "sensors";
    case VR:
      return "vr";
    case GRAPHICS_ALLOCATOR:
      return "graphics_allocator";
    case GRAPHICS_MAPPER:
      return "graphics_mapper";
    case GRAPHICS_COMPOSER:
      return "graphics_composer";
    case BIONIC_LIBM:
      return "bionic_libm";
    case TV_CEC:
      return "tv_cec";
    case RADIO:
      return "radio";
    case MEDIA_OMX:
      return "media_omx";
    case BIONIC_LIBC:
      return "bionic_libc";
    case VNDK_LIBCUTILS:
      return "vndk_libcutils";
  }
  cerr << "error: invalid component_type " << component_type << endl;
  exit(-1);
}

string GetCppVariableType(const std::string scalar_type_string) {
  if (scalar_type_string == "void" ||
      scalar_type_string == "int32_t" || scalar_type_string == "uint32_t" ||
      scalar_type_string == "int8_t" || scalar_type_string == "uint8_t" ||
      scalar_type_string == "int64_t" || scalar_type_string == "uint64_t" ||
      scalar_type_string == "int16_t" || scalar_type_string == "uint16_t") {
    return scalar_type_string;
  } else if (scalar_type_string == "bool_t") {
    return "bool";
  } else if (scalar_type_string == "float_t") {
    return "float";
  } else if (scalar_type_string == "double_t") {
    return "double";
  } else if (scalar_type_string == "ufloat") {
    return "unsigned float";
  } else if (scalar_type_string == "udouble") {
    return "unsigned double";
  } else if (scalar_type_string == "string") {
    return "std::string";
  } else if (scalar_type_string == "pointer") {
    return "void*";
  } else if (scalar_type_string == "char_pointer") {
    return "char*";
  } else if (scalar_type_string == "uchar_pointer") {
    return "unsigned char*";
  } else if (scalar_type_string == "void_pointer") {
    return "void*";
  } else if (scalar_type_string == "function_pointer") {
    return "void*";
  }

  cerr << __func__ << ":" << __LINE__ << " "
       << "error: unknown scalar_type " << scalar_type_string << endl;
  exit(-1);
}

string GetCppVariableType(const VariableSpecificationMessage& arg,
                          bool generate_const) {
  string result;
  switch (arg.type()) {
    case TYPE_VOID:
    {
      return "void";
    }
    case TYPE_PREDEFINED:
    {
      result = arg.predefined_type();
      break;
    }
    case TYPE_SCALAR:
    {
      result = GetCppVariableType(arg.scalar_type());
      break;
    }
    case TYPE_STRING:
    {
      result = "::android::hardware::hidl_string";
      break;
    }
    case TYPE_ENUM:
    {
      if (!arg.has_enum_value() && arg.has_predefined_type()) {
        result = arg.predefined_type();
      } else if (arg.has_enum_value() && arg.has_name()) {
        result = arg.name();  // nested enum type.
      } else {
        cerr << __func__ << ":" << __LINE__
             << " ERROR no predefined_type set for enum variable" << endl;
        exit(-1);
      }
      break;
    }
    case TYPE_VECTOR:
    {
      string element_type = GetCppVariableType(arg.vector_value(0));
      result = "::android::hardware::hidl_vec<" + element_type + ">";
      break;
    }
    case TYPE_ARRAY:
    {
      VariableSpecificationMessage cur_val = arg;
      vector<int32_t> array_sizes;
      while (cur_val.type() == TYPE_ARRAY) {
        array_sizes.push_back(cur_val.vector_size());
        VariableSpecificationMessage temp = cur_val.vector_value(0);
        cur_val = temp;
      }
      string element_type = GetCppVariableType(cur_val);
      result = "::android::hardware::hidl_array<" + element_type + ", ";
      for (size_t i = 0; i < array_sizes.size(); i++) {
        result += to_string(array_sizes[i]);
        if (i != array_sizes.size() - 1) result += ", ";
      }
      result += ">";
      break;
    }
    case TYPE_STRUCT:
    {
      if (arg.struct_value_size() == 0 && arg.has_predefined_type()) {
        result = arg.predefined_type();
      } else if (arg.has_struct_type()) {
        result = arg.struct_type();
      } else if (arg.sub_struct_size() > 0 || arg.struct_value_size() > 0) {
        result = arg.name();
      } else {
        cerr << __func__ << ":" << __LINE__ << " ERROR"
             << " no predefined_type, struct_type, nor sub_struct set"
             << " for struct variable"
             << " (arg name " << arg.name() << ")" << endl;
        exit(-1);
      }
      break;
    }
    case TYPE_UNION:
    {
      if (arg.union_value_size() == 0 && arg.has_predefined_type()) {
        result = arg.predefined_type();
      } else if (arg.has_union_type()) {
        result = arg.union_type();
      } else {
        cerr << __func__ << ":" << __LINE__
             << " ERROR no predefined_type or union_type set for union"
             << " variable" << endl;
        exit(-1);
      }
      break;
    }
    case TYPE_SAFE_UNION: {
      if (arg.safe_union_value_size() == 0 && arg.has_predefined_type()) {
        result = arg.predefined_type();
      } else {
        cerr << __func__ << ":" << __LINE__
             << " ERROR no predefined_type set for safe union"
             << " variable" << endl;
        exit(-1);
      }
      break;
    }
    case TYPE_HIDL_CALLBACK:
    {
      if (arg.has_predefined_type()) {
        result = "sp<" + arg.predefined_type() + ">";
      } else {
        cerr << __func__ << ":" << __LINE__
             << " ERROR no predefined_type set for hidl callback variable"
             << endl;
        exit(-1);
      }
      break;
    }
    case TYPE_HANDLE:
    {
      result = "::android::hardware::hidl_handle";
      break;
    }
    case TYPE_HIDL_INTERFACE:
    {
      if (arg.has_predefined_type()) {
        result = "sp<" + arg.predefined_type() + ">";
      } else {
        cerr << __func__ << ":" << __LINE__
             << " ERROR no predefined_type set for hidl interface variable"
             << endl;
        exit(-1);
      }
      break;
    }
    case TYPE_MASK:
    {
      result = GetCppVariableType(arg.scalar_type());
      break;
    }
    case TYPE_HIDL_MEMORY:
    {
      result = "::android::hardware::hidl_memory";
      break;
    }
    case TYPE_POINTER:
    {
      result = "void*";
      if (generate_const) {
        result = "const " + result;
      }
      return result;
    }
    case TYPE_FMQ_SYNC:
    {
      string element_type = GetCppVariableType(arg.fmq_value(0));
      result = "::android::hardware::MQDescriptorSync<" + element_type + ">";
      break;
    }
    case TYPE_FMQ_UNSYNC:
    {
      string element_type = GetCppVariableType(arg.fmq_value(0));
      result = "::android::hardware::MQDescriptorUnsync<" + element_type + ">";
      break;
    }
    case TYPE_REF:
    {
      VariableSpecificationMessage cur_val = arg;
      int ref_depth = 0;
      while (cur_val.type() == TYPE_REF) {
        ref_depth++;
        VariableSpecificationMessage temp = cur_val.ref_value();
        cur_val = temp;
      }
      string element_type = GetCppVariableType(cur_val);
      result = element_type;
      for (int i = 0; i < ref_depth; i++) {
        result += " const*";
      }
      return result;
      break;
    }
    default:
    {
      cerr << __func__ << ":" << __LINE__ << " " << ": type " << arg.type()
           << " not supported" << endl;
      exit(-1);
    }
  }
  if (generate_const) {
    return "const " + result + "&";
  }
  return result;
}

string GetConversionToProtobufFunctionName(VariableSpecificationMessage arg) {
  if (arg.type() == TYPE_PREDEFINED) {
    if (arg.predefined_type() == "camera_info_t*") {
      return "ConvertCameraInfoToProtobuf";
    } else if (arg.predefined_type() == "hw_device_t**") {
      return "";
    } else {
      cerr << __FILE__ << ":" << __LINE__ << " "
           << "error: unknown instance type " << arg.predefined_type() << endl;
    }
  }
  cerr << __FUNCTION__ << ": non-supported type " << arg.type() << endl;
  exit(-1);
}

string GetCppInstanceType(
    const VariableSpecificationMessage& arg,
    const string& msg,
    const ComponentSpecificationMessage* message) {
  switch(arg.type()) {
    case TYPE_PREDEFINED: {
      if (arg.predefined_type() == "struct light_state_t*") {
        if (msg.length() == 0) {
          return "GenerateLightState()";
        } else {
          return "GenerateLightStateUsingMessage(" + msg + ")";
        }
      } else if (arg.predefined_type() == "GpsCallbacks*") {
        return "GenerateGpsCallbacks()";
      } else if (arg.predefined_type() == "GpsUtcTime") {
        return "GenerateGpsUtcTime()";
      } else if (arg.predefined_type() == "vts_gps_latitude") {
        return "GenerateLatitude()";
      } else if (arg.predefined_type() == "vts_gps_longitude") {
        return "GenerateLongitude()";
      } else if (arg.predefined_type() == "vts_gps_accuracy") {
        return "GenerateGpsAccuracy()";
      } else if (arg.predefined_type() == "vts_gps_flags_uint16") {
        return "GenerateGpsFlagsUint16()";
      } else if (arg.predefined_type() == "GpsPositionMode") {
        return "GenerateGpsPositionMode()";
      } else if (arg.predefined_type() == "GpsPositionRecurrence") {
        return "GenerateGpsPositionRecurrence()";
      } else if (arg.predefined_type() == "hw_module_t*") {
        return "(hw_module_t*) malloc(sizeof(hw_module_t))";
      } else if (arg.predefined_type() == "hw_module_t**") {
        return "(hw_module_t**) malloc(sizeof(hw_module_t*))";
      } else if (arg.predefined_type() == "hw_device_t**") {
        return "(hw_device_t**) malloc(sizeof(hw_device_t*))";
      } else if (arg.predefined_type() == "camera_info_t*") {
        if (msg.length() == 0) {
          return "GenerateCameraInfo()";
        } else {
          return "GenerateCameraInfoUsingMessage(" + msg + ")";
        }
      } else if (arg.predefined_type() == "camera_module_callbacks_t*") {
        return "GenerateCameraModuleCallbacks()";
      } else if (arg.predefined_type() == "camera_notify_callback") {
        return "GenerateCameraNotifyCallback()";
      } else if (arg.predefined_type() == "camera_data_callback") {
        return "GenerateCameraDataCallback()";
      } else if (arg.predefined_type() == "camera_data_timestamp_callback") {
        return "GenerateCameraDataTimestampCallback()";
      } else if (arg.predefined_type() == "camera_request_memory") {
        return "GenerateCameraRequestMemory()";
      } else if (arg.predefined_type() == "wifi_handle*") {
        return "(wifi_handle*) malloc(sizeof(wifi_handle))";
      } else if (arg.predefined_type() == "struct camera_device*") {
        return "(struct camera_device*) malloc(sizeof(struct camera_device))";
      } else if (arg.predefined_type() == "struct preview_stream_ops*") {
        return "(preview_stream_ops*) malloc(sizeof(preview_stream_ops))";
      } else if (endsWith(arg.predefined_type(), "*")) {
        // known use cases: bt_callbacks_t
        return "(" + arg.predefined_type() + ") malloc(sizeof("
            + arg.predefined_type().substr(0, arg.predefined_type().size() - 1)
            + "))";
      } else {
        cerr << __func__ << ":" << __LINE__ << " "
             << "error: unknown instance type " << arg.predefined_type() << endl;
      }
      break;
    }
    case TYPE_SCALAR: {
      if (arg.scalar_type() == "bool_t") {
        return "RandomBool()";
      } else if (arg.scalar_type() == "uint32_t") {
        return "RandomUint32()";
      } else if (arg.scalar_type() == "int32_t") {
        return "RandomInt32()";
      } else if (arg.scalar_type() == "uint64_t") {
        return "RandomUint64()";
      } else if (arg.scalar_type() == "int64_t") {
        return "RandomInt64()";
      } else if (arg.scalar_type() == "uint16_t") {
        return "RandomUint16()";
      } else if (arg.scalar_type() == "int16_t") {
        return "RandomInt16()";
      } else if (arg.scalar_type() == "uint8_t") {
        return "RandomUint8()";
      } else if (arg.scalar_type() == "int8_t") {
        return "RandomInt8()";
      } else if (arg.scalar_type() == "float_t") {
        return "RandomFloat()";
      } else if (arg.scalar_type() == "double_t") {
        return "RandomDouble()";
      } else if (arg.scalar_type() == "char_pointer") {
        return "RandomCharPointer()";
      } else if (arg.scalar_type() == "uchar_pointer") {
        return "(unsigned char*) RandomCharPointer()";
      } else if (arg.scalar_type() == "pointer" ||
                 arg.scalar_type() == "void_pointer") {
        return "RandomVoidPointer()";
      }
      cerr << __FILE__ << ":" << __LINE__ << " "
           << "error: unsupported scalar data type " << arg.scalar_type() << endl;
      exit(-1);
    }
    case TYPE_ENUM:
    case TYPE_MASK: {
      if (!arg.has_enum_value() && arg.has_predefined_type()) {
        if (!message || message->component_class() != HAL_HIDL) {
          return "(" + arg.predefined_type() +  ") RandomUint32()";
        } else {
          std::string predefined_type_name = arg.predefined_type();
          ReplaceSubString(predefined_type_name, "::", "__");
          return "Random" + predefined_type_name + "()";
          // TODO: generate a function which can dynamically choose the value.
          /* for (const auto& attribute : message->attribute()) {
            if (attribute.type() == TYPE_ENUM &&
                attribute.name() == arg.predefined_type()) {
              // TODO: pick at runtime
              return message->component_name() + "::"
                  + arg.predefined_type() + "::"
                  + attribute.enum_value().enumerator(0);
            }
          } */
        }
      } else {
        cerr << __func__
             << " ENUM either has enum value or doesn't have predefined type"
             << endl;
        exit(-1);
      }
      break;
    }
    case TYPE_STRING: {
      return "android::hardware::hidl_string(RandomCharPointer())";
    }
    case TYPE_STRUCT: {
      if (arg.struct_value_size() == 0 && arg.has_predefined_type()) {
        return message->component_name() + "::" + arg.predefined_type() +  "()";
      }
      break;
    }
    case TYPE_VECTOR: {  // only for HAL_HIDL
      // TODO: generate code that initializes a local hidl_vec.
      return "";
    }
    case TYPE_HIDL_CALLBACK: {
      return arg.predefined_type() + "()";
    }
    default:
      break;
  }
  cerr << __func__ << ": error: unsupported type " << arg.type() << endl;
  exit(-1);
}

int vts_fs_mkdirs(char* file_path, mode_t mode) {
  char* p;

  for (p = strchr(file_path + 1, '/'); p; p = strchr(p + 1, '/')) {
    *p = '\0';
    if (mkdir(file_path, mode) == -1) {
      if (errno != EEXIST) {
        *p = '/';
        return -1;
      }
    }
    *p = '/';
  }
  return 0;
}

string ClearStringWithNameSpaceAccess(const string& str) {
  string result = str;
  ReplaceSubString(result, "::", "__");
  return result;
}

// Returns a string which joins the given dir_path and file_name.
string PathJoin(const char* dir_path, const char* file_name) {
  string result;
  if (dir_path) {
    result = dir_path;
    if (!file_name) return result;
  } else if (!file_name) return result;

  if (file_name[0] != '.') {
    if (result.c_str()[result.length()-1] != '/') {
      result += "/";
    }
  }
  result += file_name;
  return result;
}

// Returns a string which remove given base_path from file_path if included.
string RemoveBaseDir(const string& file_path, const string& base_path) {
  if (base_path.empty() ||
      strncmp(file_path.c_str(), base_path.c_str(), base_path.length())) {
    return file_path;
  }
  string result;
  result = &file_path.c_str()[base_path.length()];
  if (result.c_str()[0] == '/') {
    result = &result.c_str()[1];
  }
  return result;
}

string GetPackageName(const ComponentSpecificationMessage& message) {
  if (!message.package().empty()) {
    return message.package();
  }
  return "";
}

string GetPackagePath(const ComponentSpecificationMessage& message) {
  string package_path = GetPackageName(message);
  ReplaceSubString(package_path, ".", "/");
  return package_path;
}

string GetPackageNamespaceToken(const ComponentSpecificationMessage& message) {
  string package_token = GetPackageName(message);
  ReplaceSubString(package_token, ".", "::");
  return package_token;
}

string GetVersion(const ComponentSpecificationMessage& message,
                  bool for_macro) {
  return GetVersionString(message.component_type_version_major(),
                          message.component_type_version_minor(), for_macro);
}

int GetMajorVersion(const ComponentSpecificationMessage& message) {
  return message.component_type_version_major();
}

int GetMinorVersion(const ComponentSpecificationMessage& message) {
  return message.component_type_version_minor();
}

string GetComponentBaseName(const ComponentSpecificationMessage& message) {
  if (!message.component_name().empty()) {
    return (message.component_name() == "types"
                ? "types"
                : message.component_name().substr(1));
  } else
    return GetComponentName(message);
}

string GetComponentName(const ComponentSpecificationMessage& message) {
  if (!message.component_name().empty()) {
    return message.component_name();
  }

  string component_name = message.original_data_structure_name();
  while (!component_name.empty()
      && (std::isspace(component_name.back()) || component_name.back() == '*')) {
    component_name.pop_back();
  }
  const auto pos = component_name.find_last_of(" ");
  if (pos != std::string::npos) {
    component_name = component_name.substr(pos + 1);
  }
  return component_name;
}

FQName GetFQName(const ComponentSpecificationMessage& message) {
  return FQName(message.package(),
                GetVersionString(message.component_type_version_major(),
                                 message.component_type_version_minor()),
                GetComponentName(message));
}

string GetVarString(const string& var_name) {
  string var_str = var_name;
  for (size_t i = 0; i < var_name.length(); i++) {
    if (!isdigit(var_str[i]) && !isalpha(var_str[i])) {
      var_str[i] = '_';
    }
  }
  return var_str;
}

}  // namespace vts
}  // namespace android