#include "source/common/formatter/substitution_formatter.h"

namespace Envoy {

namespace Formatter {

  // The following regex is used to check validity of the formatter command and to

  // extract groups.

  // The formatter command has the following format:

  //    % COMMAND(SUBCOMMAND):LENGTH%

  // % signs at the beginning and end are used by parser to find next COMMAND.

  // COMMAND must always be present and must consist of characters: "A-Z", "0-9" or "_".

  // SUBCOMMAND presence depends on the COMMAND. Format is flexible but cannot contain ")".:

  // - for some commands SUBCOMMAND is not allowed (for example %PROTOCOL%)

  // - for some commands SUBCOMMAND is required (for example %REQ(:AUTHORITY)%, just %REQ% will

  // cause error)

  // - for some commands SUBCOMMAND is optional (for example %START_TIME% and

  // %START_TIME(%f.%1f.%2f.%3f)% are both correct).

  // LENGTH presence depends on the command. Some

  // commands allow LENGTH to be specified, so not. Regex is used to validate the syntax and also

  // to extract values for COMMAND, SUBCOMMAND and LENGTH.

  //

  // Below is explanation of capturing and non-capturing groups. Non-capturing groups are used

  // to specify that certain part of the formatter command is optional and should contain specific

  // characters. Capturing groups are used to extract the values when regex is matched against

  // formatter command string.

  //

  // clang-format off

  // Non-capturing group specifying optional :LENGTH ----------------------

  //                                                                       |

  // Non-capturing group specifying optional (SUBCOMMAND)---               |

  //                                                        |              |

  // Non-capturing group specifying mandatory COMMAND       |              |

  //  which uses only A-Z, 0-9 and _ characters             |              |

  //  Group is used only to specify allowed characters.     |              |

  //                                      |                 |              |

  //                                      |                 |              |

  //                              _________________  _____________ _____________

  //                              |               |  |           | |           |

  //                             |__________________|     |___|        |______|

  //                                       |                |              |

  // Capturing group specifying COMMAND ---                 |              |

  // The index of this group is 1.                          |              |

  //                                                        |              |

  // Capturing group for SUBCOMMAND. If present, it will ---               |

  // contain SUBCOMMAND without "(" and ")". The index                     |

  // of SUBCOMMAND group is 2.                                             |

  //                                                                       |

  // Capturing group for LENGTH. If present, it will ----------------------

  // contain just number without ":". The index of

  // LENGTH group is 3.

  // clang-format on

// Helper class to write value to output buffer in JSON style.

// NOTE: This helper class has duplicated logic with the Json::BufferStreamer class but

// provides lower level of APIs to operate on the output buffer (like control the

// delimiters). This is designed for special scenario of substitution formatter and

// is not intended to be used by other parts of the code.

class JsonStringSerializer {

public:

  using OutputBufferType = Json::StringOutput;

  // Methods that be used to add JSON delimiter to output buffer.

  // Methods that be used to add JSON key or value to output buffer.

  /**

   * Serializes a number.

   */

  /**

   * Serializes a integer number.

   * NOTE: All numbers in JSON is float. When loading output of this serializer, the parser's

   * implementation decides if the full precision of big integer could be preserved or not.

   * See discussion here https://stackoverflow.com/questions/13502398/json-integers-limit-on-size

   * and spec https://www.rfc-editor.org/rfc/rfc7159#section-6 for more details.

   */

  // Low-level methods that be used to provide a low-level control to buffer.

protected:

  std::string sanitize_buffer_;

  OutputBufferType output_buffer_;

};

// Helper class to parse the Json format configuration. The class will be used to parse

// the JSON format configuration and convert it to a list of raw JSON pieces and

// substitution format template strings. See comments below for more details.

class JsonFormatBuilder {

public:

  struct FormatElement {

    // Pre-sanitized JSON piece or a format template string that contains

    // substitution commands.

    std::string value_;

    // Whether the value is a template string.

    // If true, the value is a format template string that contains substitution commands.

    // If false, the value is a pre-sanitized JSON piece.

    bool is_template_;

  };

  using FormatElements = std::vector<FormatElement>;

  /**

   * Constructor of JsonFormatBuilder.

   */

  /**

   * Convert a proto struct format configuration to an array of raw JSON pieces and

   * substitution format template strings.

   *

   * The keys, raw values, delimiters will be serialized as JSON string pieces (raw

   * JSON strings) directly when loading the configuration.

   * The substitution format template strings will be kept as template string pieces and

   * will be parsed to formatter providers by the JsonFormatter.

   *

   * NOTE: This class is used to parse the configuration of the proto struct format

   * and should only be used in the context of parsing the configuration.

   *

   * For example given the following proto struct format configuration:

   *

   *   json_format:

   *     name: "value"

   *     template: "%START_TIME%"

   *     number: 2

   *     bool: true

   *     list:

   *       - "list_raw_value"

   *       - false

   *       - "%EMIT_TIME%"

   *     nested:

   *       nested_name: "nested_value"

   *

   * It will be parsed to the following pieces:

   *

   *   - '{"name":"value","template":'                                      # Raw JSON piece.

   *   - '%START_TIME%'                                                     # Format template piece.

   *   - ',"number":2,"bool":true,"list":["list_raw_value",false,'          # Raw JSON piece.

   *   - '%EMIT_TIME%'                                                      # Format template piece.

   *   - '],"nested":{"nested_name":"nested_value"}}'                       # Raw JSON piece.

   *

   * Finally, join the raw JSON pieces and output of substitution formatters in order

   * to construct the final JSON output.

   *

   * @param struct_format the proto struct format configuration.

   */

  FormatElements fromStruct(const Protobuf::Struct& struct_format);

private:

  using ProtoDict = Protobuf::Map<std::string, Protobuf::Value>;

  using ProtoList = Protobuf::RepeatedPtrField<Protobuf::Value>;

  void formatValueToFormatElements(const ProtoDict& dict_value);

  void formatValueToFormatElements(const Protobuf::Value& value);

  void formatValueToFormatElements(const ProtoList& list_value);

  std::string buffer_;                       // JSON writer buffer.

  JsonStringSerializer serializer_{buffer_}; // JSON serializer.

  FormatElements elements_;                  // Parsed elements.

};

JsonFormatBuilder::FormatElements

  // This call will iterate through the map tree and serialize the key/values as JSON.

  // If a string value that contains a substitution commands is found, the current

  // JSON piece and the substitution command will be pushed into the output list.

  // After that, the iteration will continue until the whole tree is traversed.

    // The string contains a formatter, we need to push the current exist JSON piece

    // into the output list first.

    // Now a formatter is coming, we need to push the current raw string into

    // the output list.

  // Sort the keys to make the output deterministic.

    // Add the key.

absl::StatusOr<std::vector<FormatterProviderPtr>>

SubstitutionFormatParser::parse(absl::string_view format,

    // escape '%%'

    // First try the command parsers provided by the user. This allows the user to override

    // built-in command parsers.

    // Next, try the built-in command parsers.

    // Create a PlainStringFormatter with the final string literal. If the format string

    // was empty, this creates a PlainStringFormatter with an empty string.

absl::StatusOr<std::unique_ptr<FormatterImpl>>

FormatterImpl::create(absl::string_view format, bool omit_empty_values,

std::string FormatterImpl::format(const Context& context,

    // Add the formatted value if there is one. Otherwise add a default value

    // of "-" if omit_empty_values_ is not set.

void stringValueToLogLine(const JsonFormatterImpl::Formatters& formatters, const Context& context,

                          const StreamInfo::StreamInfo& info, std::string& log_line,

      // Add the empty value. This needn't be sanitized.

    // Sanitize the string value and add it to the buffer. The string value will not be quoted

    // since we handle the quoting by ourselves at the outer level.

JsonFormatterImpl::JsonFormatterImpl(const Protobuf::Struct& struct_format, bool omit_empty_values,

                                     const CommandParsers& commands)

std::string JsonFormatterImpl::format(const Context& context,

    // 1. Handle the raw string element.

      // The raw string element will be added to the buffer directly.

      // It is sanitized when loading the configuration.

      // 2. Handle the formatter element with multiple or zero providers.

      // 3. Handle the formatter element with a single provider and value

      //    type needs to be kept.

} // namespace Formatter

} // namespace Envoy