#include "dynamic_depth/depth_map.h"

#include "android-base/logging.h"
#include "dynamic_depth/const.h"
#include "dynamic_depth/item.h"
#include "strings/numbers.h"
#include "xmpmeta/base64.h"

using ::dynamic_depth::Item;
using ::dynamic_depth::xmpmeta::EncodeFloatArrayBase64;
using ::dynamic_depth::xmpmeta::xml::Deserializer;
using ::dynamic_depth::xmpmeta::xml::Serializer;

namespace dynamic_depth {
namespace {
constexpr const char* kNamespaceHref =
    "http://ns.google.com/photos/dd/1.0/depthmap/";

constexpr const char* kFormat = "Format";
constexpr const char* kNear = "Near";
constexpr const char* kFar = "Far";
constexpr const char* kUnits = "Units";
constexpr const char* kDepthUri = "DepthURI";
constexpr const char* kItemSemantic = "ItemSemantic";
constexpr const char* kConfidenceUri = "ConfidenceURI";
constexpr const char* kMeasureType = "MeasureType";
constexpr const char* kSoftware = "Software";
constexpr const char* kFocalTable = "FocalTable";
constexpr const char* kFocalTableEntryCount = "FocalTableEntryCount";

constexpr const char* kFormatRangeInverse = "RangeInverse";
constexpr const char* kFormatRangeLinear = "RangeLinear";
constexpr const char* kFormatRangeInverseLower = "rangeinverse";
constexpr const char* kFormatRangeLinearLower = "rangelinear";

constexpr const char* kUnitsMeters = "Meters";
constexpr const char* kUnitsDiopters = "Diopters";
constexpr const char* kUnitsNone = "None";
constexpr const char* kUnitsMetersLower = "meters";
constexpr const char* kUnitsDioptersLower = "diopters";

constexpr const char* kMeasureTypeOpticalAxis = "OpticalAxis";
constexpr const char* kMeasureTypeOpticRay = "OpticRay";
constexpr const char* kMeasureTypeOpticRayLower = "opticray";

constexpr const char* kItemSemanticDepth = "Depth";
constexpr const char* kItemSemanticSegmentation = "Segmentation";
constexpr const char* kItemSemanticSegmentationLower = "segmentation";

string ItemSemanticToString(DepthItemSemantic item_semantic) {
  switch (item_semantic) {
    case DepthItemSemantic::kDepth:
      return kItemSemanticDepth;
    case DepthItemSemantic::kSegmentation:
      return kItemSemanticSegmentation;
  }
}

DepthItemSemantic StringToItemSemantic(const string& semantic_str) {
  string semantic_str_lower = semantic_str;
  std::transform(semantic_str_lower.begin(), semantic_str_lower.end(),
                 semantic_str_lower.begin(), ::tolower);
  if (kItemSemanticSegmentationLower == semantic_str_lower) {
    return DepthItemSemantic::kSegmentation;
  }

  return DepthItemSemantic::kDepth;
}

string FormatToString(DepthFormat format) {
  switch (format) {
    case DepthFormat::kRangeInverse:
      return kFormatRangeInverse;
    case DepthFormat::kRangeLinear:
      return kFormatRangeLinear;
    case DepthFormat::kFormatNone:
      return "";
  }
}

// Case insensitive.
DepthFormat StringToFormat(const string& format_str) {
  string format_str_lower = format_str;
  std::transform(format_str_lower.begin(), format_str_lower.end(),
                 format_str_lower.begin(), ::tolower);
  if (kFormatRangeInverseLower == format_str_lower) {
    return DepthFormat::kRangeInverse;
  }

  if (kFormatRangeLinearLower == format_str_lower) {
    return DepthFormat::kRangeLinear;
  }

  return DepthFormat::kFormatNone;
}

string UnitsToString(DepthUnits units) {
  switch (units) {
    case DepthUnits::kMeters:
      return kUnitsMeters;
    case DepthUnits::kDiopters:
      return kUnitsDiopters;
    case DepthUnits::kUnitsNone:
      return kUnitsNone;
  }
}

DepthUnits StringToUnits(const string& units_str) {
  string units_str_lower = units_str;
  std::transform(units_str_lower.begin(), units_str_lower.end(),
                 units_str_lower.begin(), ::tolower);
  if (kUnitsMetersLower == units_str_lower) {
    return DepthUnits::kMeters;
  }

  if (kUnitsDioptersLower == units_str_lower) {
    return DepthUnits::kDiopters;
  }

  return DepthUnits::kUnitsNone;
}

string MeasureTypeToString(DepthMeasureType measure_type) {
  switch (measure_type) {
    case DepthMeasureType::kOpticRay:
      return kMeasureTypeOpticRay;
    case DepthMeasureType::kOpticalAxis:
      return kMeasureTypeOpticalAxis;
  }
}

DepthMeasureType StringToMeasureType(const string& measure_type_str) {
  string measure_type_str_lower = measure_type_str;
  std::transform(measure_type_str_lower.begin(), measure_type_str_lower.end(),
                 measure_type_str_lower.begin(), ::tolower);
  if (kMeasureTypeOpticRayLower == measure_type_str_lower) {
    return DepthMeasureType::kOpticRay;
  }

  return DepthMeasureType::kOpticalAxis;
}

}  // namespace

// Private constructor.
DepthMap::DepthMap(const DepthMapParams& params) : params_(params) {}

// Private parser.
std::unique_ptr<DepthMap> DepthMap::ParseFields(
    const Deserializer& deserializer) {
  const string& prefix = DynamicDepthConst::DepthMap();
  string format_str;
  float near;
  float far;
  string units_str;
  string depth_uri;
  string item_semantic_str;

  if (!deserializer.ParseString(prefix, kItemSemantic, &item_semantic_str) ||
      !deserializer.ParseString(prefix, kFormat, &format_str) ||
      !deserializer.ParseFloat(prefix, kNear, &near) ||
      !deserializer.ParseFloat(prefix, kFar, &far) ||
      !deserializer.ParseString(prefix, kUnits, &units_str) ||
      !deserializer.ParseString(prefix, kDepthUri, &depth_uri)) {
    return nullptr;
  }

  DepthMapParams params(StringToFormat(format_str), near, far,
                        StringToUnits(units_str), depth_uri);
  params.item_semantic = StringToItemSemantic(item_semantic_str);

  string confidence_uri;
  if (deserializer.ParseString(prefix, kConfidenceUri, &confidence_uri)) {
    params.confidence_uri = confidence_uri;
  }

  string measure_type_str;
  if (deserializer.ParseString(prefix, kMeasureType, &measure_type_str)) {
    params.measure_type = StringToMeasureType(measure_type_str);
  }

  string software;
  if (deserializer.ParseString(prefix, kSoftware, &software)) {
    params.software = software;
  }

  std::vector<float> focal_table;
  int focal_table_entry_count;
  if (deserializer.ParseFloatArrayBase64(prefix, kFocalTable, &focal_table) &&
      (!deserializer.ParseInt(prefix, kFocalTableEntryCount,
                              &focal_table_entry_count) &&
       focal_table.size() / 2 != focal_table_entry_count)) {
    return nullptr;
  }
  params.focal_table = focal_table;

  return std::unique_ptr<DepthMap>(new DepthMap(params));  // NOLINT
}

// Public methods.
void DepthMap::GetNamespaces(
    std::unordered_map<string, string>* ns_name_href_map) {
  if (ns_name_href_map == nullptr) {
    LOG(ERROR) << "Namespace list or own namespace is null";
    return;
  }
  ns_name_href_map->emplace(DynamicDepthConst::DepthMap(), kNamespaceHref);
}

std::unique_ptr<DepthMap> DepthMap::FromData(
    const DepthMapParams& params, std::vector<std::unique_ptr<Item>>* items) {
  if (params.format == DepthFormat::kFormatNone) {
    LOG(ERROR)
        << "Format must be specified, cannot be of type DepthFormat::NONE";
    return nullptr;
  }

  if (params.depth_uri.empty() || params.depth_image_data.empty()) {
    LOG(ERROR) << "Depth image data and URI must be provided";
    return nullptr;
  }

  if (!params.focal_table.empty() && params.focal_table.size() % 2 != 0) {
    LOG(ERROR) << "Focal table entries must consist of pairs";
    return nullptr;
  }

  if (items == nullptr) {
    LOG(ERROR) << "List of items is null";
    return nullptr;
  }

  if (params.mime.empty()) {
    LOG(ERROR) << "Depth image mime must be provided to DepthMapParams";
    return nullptr;
  }

  ItemParams depth_item_params(params.mime, params.depth_image_data.size(),
                               params.depth_uri);
  depth_item_params.payload_to_serialize = params.depth_image_data;
  items->emplace_back(Item::FromData(depth_item_params));

  bool available_confidence_uri_and_data = true;
  if (!params.confidence_uri.empty() && !params.confidence_data.empty()) {
    // Assumes that the confidence mime is the same as that of the depth map.
    ItemParams confidence_item_params(
        params.mime, params.confidence_data.size(), params.confidence_uri);
    confidence_item_params.payload_to_serialize = params.confidence_data;
    items->emplace_back(Item::FromData(confidence_item_params));
  } else if (!params.confidence_uri.empty() && params.confidence_data.empty()) {
    LOG(ERROR) << "No confidence data provided, the URI will be set to empty "
                  "and not serialized";
    available_confidence_uri_and_data = false;
  }

  auto depth_map = std::unique_ptr<DepthMap>(new DepthMap(params));  // NOLINT
  if (!available_confidence_uri_and_data) {
    // Ensure we don't serialize the confidence URI if no data has been
    // provided.
    depth_map->params_.confidence_uri = "";
  }

  return depth_map;
}

std::unique_ptr<DepthMap> DepthMap::FromDeserializer(
    const Deserializer& parent_deserializer) {
  std::unique_ptr<Deserializer> deserializer =
      parent_deserializer.CreateDeserializer(
          DynamicDepthConst::Namespace(DynamicDepthConst::DepthMap()),
          DynamicDepthConst::DepthMap());
  if (deserializer == nullptr) {
    return nullptr;
  }

  return ParseFields(*deserializer);
}

DepthFormat DepthMap::GetFormat() const { return params_.format; }
float DepthMap::GetNear() const { return params_.near; }
float DepthMap::GetFar() const { return params_.far; }
DepthUnits DepthMap::GetUnits() const { return params_.units; }
const string DepthMap::GetDepthUri() const { return params_.depth_uri; }
DepthItemSemantic DepthMap::GetItemSemantic() const {
  return params_.item_semantic;
}
const string DepthMap::GetConfidenceUri() const {
  return params_.confidence_uri;
}

DepthMeasureType DepthMap::GetMeasureType() const {
  return params_.measure_type;
}

const string DepthMap::GetSoftware() const { return params_.software; }
const std::vector<float>& DepthMap::GetFocalTable() const {
  return params_.focal_table;
}

size_t DepthMap::GetFocalTableEntryCount() const {
  return params_.focal_table.size() / 2;
}

bool DepthMap::Serialize(Serializer* serializer) const {
  if (serializer == nullptr) {
    LOG(ERROR) << "Serializer is null";
    return false;
  }
  if (params_.depth_uri.empty()) {
    LOG(ERROR) << "Depth image URI is empty";
    return false;
  }

  const string& prefix = DynamicDepthConst::DepthMap();
  // Error checking is already done in FromData.
  if (!serializer->WriteProperty(prefix, kItemSemantic,
                                 ItemSemanticToString(params_.item_semantic)) ||
      !serializer->WriteProperty(prefix, kFormat,
                                 FormatToString(params_.format)) ||
      !serializer->WriteProperty(prefix, kUnits,
                                 UnitsToString(params_.units)) ||
      !serializer->WriteProperty(prefix, kNear, std::to_string(params_.near)) ||
      !serializer->WriteProperty(prefix, kFar, std::to_string(params_.far)) ||
      !serializer->WriteProperty(prefix, kDepthUri, params_.depth_uri)) {
    return false;
  }

  serializer->WriteProperty(prefix, kMeasureType,
                            MeasureTypeToString(params_.measure_type));

  if (!params_.confidence_uri.empty()) {
    serializer->WriteProperty(prefix, kConfidenceUri, params_.confidence_uri);
  }

  if (!params_.software.empty()) {
    serializer->WriteProperty(prefix, kSoftware, params_.software);
  }

  if (!params_.focal_table.empty()) {
    string base64_encoded_focal_table;
    if (!EncodeFloatArrayBase64(params_.focal_table,
                                &base64_encoded_focal_table)) {
      LOG(ERROR) << "Focal table encoding failed";
    } else {
      int focal_table_entry_count =
          static_cast<int>(params_.focal_table.size() / 2);
      if (!serializer->WriteProperty(
              prefix, kFocalTableEntryCount,
              ::dynamic_depth::strings::SimpleItoa(focal_table_entry_count)) ||
          !serializer->WriteProperty(prefix, kFocalTable,
                                     base64_encoded_focal_table)) {
        LOG(ERROR) << "Focal table or entry count could not be serialized";
      }
    }
  }

  return true;
}

}  // namespace dynamic_depth