/*
 * Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, version 2.0,
 * as published by the Free Software Foundation.
 *
 * This program is also distributed with certain software (including
 * but not limited to OpenSSL) that is licensed under separate terms,
 * as designated in a particular file or component or in included license
 * documentation.  The authors of MySQL hereby grant you an additional
 * permission to link the program and your derivative works with the
 * separately licensed software that they have included with MySQL.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License, version 2.0, for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
 */

#include "plugin/x/tests/driver/formatters/message_formatter.h"

#include <algorithm>
#include <vector>

#include "plugin/x/src/helper/to_string.h"

#ifdef GetMessage
#undef GetMessage
#endif

namespace formatter {

using FieldDescriptor = google::protobuf::FieldDescriptor;
using FieldDescriptors = std::vector<const FieldDescriptor *>;
using Reflection = google::protobuf::Reflection;
using Message = xcl::XProtocol::Message;

namespace details {

/**
  Extract fields from a path (path of fields).

  The patch represents fields (objects) that have nested other objects.
  Using a path, user can choose concrete field inside a large message.
  Characters that can be used in fields name are following:

  * '[a-z]'
  * '[A-Z]'
  * '[0-9]'
  * '_'

  Fields inside a path are separated by dot ("."). When a field points to
  an array then user must use by zero-based-index specified inside square
  brackets.


  Path example
  ------------

  * msg1_field1
  * msg1_field1.field1.field2
  * field1[1].field1[0]
  * field1[1].field2
 */
class Field_path_extractor {
 public:
  explicit Field_path_extractor(const std::string &path);

  std::string get_next_fields() const;
  bool get_current_field(std::string *out_result) const;
  bool get_index(bool *out_has_index, int *out_index) const;

 private:
  std::string m_path;
  std::string m_field_full_name;
  std::size_t m_index;
};

Field_path_extractor::Field_path_extractor(const std::string &path)
    : m_path(path),
      m_field_full_name(path.substr(0, path.find('.'))),
      m_index(m_field_full_name.find('[')) {}

std::string Field_path_extractor::get_next_fields() const {
  const std::size_t position = m_field_full_name.length() + 1;
  if (m_path.length() <= position) return "";

  return m_path.substr(position);
}

bool Field_path_extractor::get_current_field(std::string *out_result) const {
  *out_result = m_field_full_name.substr(0, m_index);

  for (std::size_t i = 0; i < out_result->length(); ++i) {
    const char c = (*out_result)[i];

    if (!std::isalnum(c) && '_' != c) return false;
  }

  return true;
}

bool Field_path_extractor::get_index(bool *out_has_index,
                                     int *out_index) const {
  const bool has_index = std::string::npos != m_index;
  if (has_index) {
    if (m_field_full_name.find(']') != m_field_full_name.length() - 1) {
      return false;
    }

    std::string index_str = m_field_full_name.substr(
        m_index + 1, m_field_full_name.length() - 1 - m_index - 1);
    bool valid_index = !index_str.empty();

    for (std::size_t i = 0; i < index_str.length(); ++i)
      valid_index = valid_index && std::isdigit(index_str[i]);

    if (!valid_index) {
      return false;
    }

    *out_index = std::stoi(index_str);
  }

  *out_has_index = has_index;

  return true;
}

class Field {
 public:
  std::string m_name;
  bool m_has_index;
  int m_index;

  bool operator()(const FieldDescriptor *fd) const {
    return m_name == fd->name();
  }
};

typedef std::vector<Field> Fields;

static Fields get_fields_array_from_path(std::string path) {
  Fields result;

  while (!path.empty()) {
    Field_path_extractor path_extractor(path);
    Field field;

    if (!path_extractor.get_current_field(&field.m_name))
      throw std::logic_error("Elements name contains not allowed characters");

    if (!path_extractor.get_index(&field.m_has_index, &field.m_index))
      throw std::logic_error("Wrong filter format, around elements index");

    path = path_extractor.get_next_fields();
    result.push_back(field);
  }

  return result;
}

}  // namespace details

template <typename Message_type>
static std::string message_to_text(const std::string &binary_message) {
  std::string result;
  Message_type message;

  message.ParseFromString(binary_message);
  google::protobuf::TextFormat::PrintToString(message, &result);

  return message.GetDescriptor()->full_name() + " { " + result + " }";
}

static std::string messages_field_to_text(const Message &message,
                                          const FieldDescriptor *fd) {
  const Reflection *reflection = message.GetReflection();

  switch (fd->cpp_type()) {
    case FieldDescriptor::CPPTYPE_INT32:
      return xpl::to_string(reflection->GetInt32(message, fd));

    case FieldDescriptor::CPPTYPE_UINT32:
      return xpl::to_string(reflection->GetUInt32(message, fd));

    case FieldDescriptor::CPPTYPE_INT64:
      return xpl::to_string(reflection->GetInt64(message, fd));

    case FieldDescriptor::CPPTYPE_UINT64:
      return xpl::to_string(reflection->GetUInt64(message, fd));

    case FieldDescriptor::CPPTYPE_DOUBLE:
      return xpl::to_string(reflection->GetDouble(message, fd));

    case FieldDescriptor::CPPTYPE_FLOAT:
      return xpl::to_string(reflection->GetFloat(message, fd));

    case FieldDescriptor::CPPTYPE_BOOL:
      return xpl::to_string(reflection->GetBool(message, fd));

    case FieldDescriptor::CPPTYPE_ENUM:
      return reflection->GetEnum(message, fd)->name();

    case FieldDescriptor::CPPTYPE_STRING:
      return reflection->GetString(message, fd);

    case FieldDescriptor::CPPTYPE_MESSAGE:
      return message_to_text(reflection->GetMessage(message, fd));

    default:
      throw std::logic_error("Unknown protobuf message type");
  }
}

static std::string messages_repeated_field_to_text(const Message &message,
                                                   const FieldDescriptor *fd,
                                                   const int index) {
  const Reflection *reflection = message.GetReflection();

  switch (fd->cpp_type()) {
    case FieldDescriptor::CPPTYPE_INT32:
      return xpl::to_string(reflection->GetRepeatedInt32(message, fd, index));

    case FieldDescriptor::CPPTYPE_UINT32:
      return xpl::to_string(reflection->GetRepeatedUInt32(message, fd, index));

    case FieldDescriptor::CPPTYPE_INT64:
      return xpl::to_string(reflection->GetRepeatedInt64(message, fd, index));

    case FieldDescriptor::CPPTYPE_UINT64:
      return xpl::to_string(reflection->GetRepeatedUInt64(message, fd, index));

    case FieldDescriptor::CPPTYPE_DOUBLE:
      return xpl::to_string(reflection->GetRepeatedDouble(message, fd, index));

    case FieldDescriptor::CPPTYPE_FLOAT:
      return xpl::to_string(reflection->GetRepeatedFloat(message, fd, index));

    case FieldDescriptor::CPPTYPE_BOOL:
      return xpl::to_string(reflection->GetRepeatedBool(message, fd, index));

    case FieldDescriptor::CPPTYPE_ENUM:
      return reflection->GetRepeatedEnum(message, fd, index)->name();

    case FieldDescriptor::CPPTYPE_STRING:
      return reflection->GetRepeatedString(message, fd, index);

    case FieldDescriptor::CPPTYPE_MESSAGE:
      return message_to_text(
          reflection->GetRepeatedMessage(message, fd, index));

    default:
      throw std::logic_error("Unknown protobuf message type");
  }
}

std::string message_to_text(const Message &message) {
  std::string output;
  std::string name;
  google::protobuf::TextFormat::Printer printer;

  printer.SetInitialIndentLevel(1);

  // special handling for nested messages (at least for Notices)
  if (message.GetDescriptor()->full_name() == "Mysqlx.Notice.Frame") {
    Mysqlx::Notice::Frame frame =
        *static_cast<const Mysqlx::Notice::Frame *>(&message);

    switch (frame.type()) {
      case ::Mysqlx::Notice::Frame_Type_WARNING: {
        const auto payload_as_text =
            message_to_text<Mysqlx::Notice::Warning>(frame.payload());

        frame.set_payload(payload_as_text);
        break;
      }
      case ::Mysqlx::Notice::Frame_Type_SESSION_VARIABLE_CHANGED: {
        const auto payload_as_text =
            message_to_text<Mysqlx::Notice::SessionVariableChanged>(
                frame.payload());

        frame.set_payload(payload_as_text);
        break;
      }
      case ::Mysqlx::Notice::Frame_Type_SESSION_STATE_CHANGED: {
        const auto payload_as_text =
            message_to_text<Mysqlx::Notice::SessionStateChanged>(
                frame.payload());

        frame.set_payload(payload_as_text);
        break;
      }

      case ::Mysqlx::Notice::Frame_Type_GROUP_REPLICATION_STATE_CHANGED: {
        const auto payload_as_text =
            message_to_text<Mysqlx::Notice::GroupReplicationStateChanged>(
                frame.payload());

        frame.set_payload(payload_as_text);
        break;
      }
    }

    printer.PrintToString(frame, &output);
  } else {
    printer.PrintToString(message, &output);
  }

  return message.GetDescriptor()->full_name() + " {\n" + output + "}\n";
}

/**
  Message in text format.

  The message_path must be constructed according to format described
  by Field_path_extractor, with following limitation:

  * printing of field which is array (a message or scalar needs to be
    selected)
*/
std::string message_to_text(const Message &message,
                            const std::string &field_path,
                            const bool show_message_name) {
  if (field_path.empty()) return message_to_text(message);

  const FieldDescriptor *field_descriptor = NULL;
  const Message *msg = &message;
  details::Fields fields = details::get_fields_array_from_path(field_path);
  std::size_t index_of_last_element = fields.size() - 1;

  for (std::size_t field_index = 0; field_index < fields.size();
       ++field_index) {
    const bool is_last_element = index_of_last_element == field_index;
    FieldDescriptors output;
    const details::Field &expected_field = fields[field_index];
    const Reflection *reflection = msg->GetReflection();

    reflection->ListFields(*msg, &output);

    FieldDescriptors::iterator i =
        std::find_if(output.begin(), output.end(), expected_field);

    if (output.end() == i) {
      throw std::logic_error("Message '" + msg->GetDescriptor()->full_name() +
                             "' doesn't contains field '" +
                             expected_field.m_name +
                             "'"
                             " or the field isn't set");
    }

    field_descriptor = *i;

    if (field_descriptor->is_repeated() != expected_field.m_has_index) {
      throw std::logic_error(expected_field.m_has_index
                                 ? "Element '" + expected_field.m_name +
                                       "' isn't an array"
                                 : "Element '" + expected_field.m_name +
                                       "' is an array and requires "
                                       "an index");
    }

    if (!is_last_element) {
      if (FieldDescriptor::CPPTYPE_MESSAGE != field_descriptor->cpp_type()) {
        throw std::logic_error(
            "Path must point to a message for "
            "all elements except last");
      }

      /*
        Move the msg pointer to the selected field
      */
      if (expected_field.m_has_index) {
        const int field_array_elements =
            reflection->FieldSize(*msg, field_descriptor);

        if (expected_field.m_index >= field_array_elements) {
          throw std::logic_error("Elements '" + expected_field.m_name +
                                 "' index out of boundary "
                                 "(size of the array is " +
                                 xpl::to_string(field_array_elements) + ")");
        }

        msg = &reflection->GetRepeatedMessage(*msg, field_descriptor,
                                              expected_field.m_index);
      } else {
        msg = &reflection->GetMessage(*msg, field_descriptor);
      }
    }
  }

  if (!field_descriptor)
    throw std::logic_error("Elements descriptor is missing");

  if (field_descriptor->is_repeated() &&
      !fields[index_of_last_element].m_has_index)
    throw std::logic_error("Last selected element is a repeated field");

  std::string prefix = "";

  if (show_message_name)
    prefix = message.GetDescriptor()->full_name() + "(" + field_path + ") = ";

  if (!field_descriptor->is_repeated())
    return prefix + messages_field_to_text(*msg, field_descriptor);

  return prefix +
         messages_repeated_field_to_text(*msg, field_descriptor,
                                         fields[index_of_last_element].m_index);
}

}  // namespace formatter