// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/tools/profile_reset/jtl_parser.h"

#include <algorithm>

#include "base/logging.h"
#include "third_party/re2/re2/re2.h"

namespace {

// RegEx that matches the first line of a text. Will throw away any potential
// double-slash-introduced comments and the potential trailing EOL character.
// Note: will fail in case the first line contains an unmatched double-quote
// outside of comments.
const char kSingleLineWithMaybeCommentsRE[] =
    // Non-greedily match and capture sequences of 1.) string literals inside
    // correctly matched double-quotes, or 2.) any other character.
    "^((?:\"[^\"\\n]*\"|[^\"\\n])*?)"
    // Greedily match and throw away the potential comment.
    "(?://.*)?"
    // Match and throw away EOL, or match end-of-string.
    "(?:\n|$)";

// RegEx to match either a double-quote-enclosed string literal or a whitespace.
// Applied repeatedly and without overlapping, can be used to remove whitespace
// outside of string literals.
const char kRemoveWhitespaceRE[] = "(\"[^\"]*\")|\\s";

// The substitution pattern to use together with the above when replacing. As
// the whitespace is not back-referenced here, it will get removed.
const char kRemoveWhitespaceRewrite[] = "\\1";

// Separator to terminate a sentence.
const char kEndOfSentenceSeparator[] = ";";

// The 'true' Boolean keyword.
const char kTrueKeyword[] = "true";

// RegEx that matches and captures one argument, which is either a double-quote
// enclosed string, or a Boolean value. Will throw away a trailing comma.
const char kSingleArgumentRE[] = "(?:(?:\"([^\"]*)\"|(true|false))(?:,|$))";

// RegEx-es that, when concatenated, will match a single operation, and capture
// the: operation name, the optional arguments, and the separator that follows.
const char kOperationNameRE[] = "([[:word:]]+)";
const char kMaybeArgumentListRE[] =
    "(?:\\("                    // Opening parenthesis.
    "((?:\"[^\"]*\"|[^\")])*)"  // Capture: anything inside, quote-aware.
    "\\))?";                    // Closing parenthesis + everything optional.
const char kOperationSeparatorRE[] = "(;|\\.)";

}  // namespace

struct JtlParser::ParsingState {
  explicit ParsingState(const re2::StringPiece& compacted_source)
      : single_operation_regex(std::string(kOperationNameRE) +
                               kMaybeArgumentListRE +
                               kOperationSeparatorRE),
        single_argument_regex(kSingleArgumentRE),
        remaining_compacted_source(compacted_source),
        last_line_number(0) {}

  RE2 single_operation_regex;
  RE2 single_argument_regex;
  re2::StringPiece remaining_compacted_source;
  re2::StringPiece last_context;
  size_t last_line_number;
};

JtlParser::JtlParser(const std::string& compacted_source_code,
                     const std::vector<size_t>& newline_indices)
    : compacted_source_(compacted_source_code),
      newline_indices_(newline_indices) {
  state_.reset(new ParsingState(compacted_source_));
}

JtlParser::~JtlParser() {}

// static
bool JtlParser::RemoveCommentsAndAllWhitespace(
    const std::string& verbose_text,
    std::string* compacted_text,
    std::vector<size_t>* newline_indices,
    size_t* error_line_number) {
  DCHECK(compacted_text);
  DCHECK(newline_indices);
  std::string line;
  RE2 single_line_regex(kSingleLineWithMaybeCommentsRE);
  RE2 remove_whitespace_regex(kRemoveWhitespaceRE);
  re2::StringPiece verbose_text_piece(verbose_text);
  compacted_text->clear();
  newline_indices->clear();
  while (!verbose_text_piece.empty()) {
    if (!RE2::Consume(&verbose_text_piece, single_line_regex, &line)) {
      if (error_line_number)
        *error_line_number = newline_indices->size();
      return false;
    }
    RE2::GlobalReplace(
        &line, remove_whitespace_regex, kRemoveWhitespaceRewrite);
    *compacted_text += line;
    newline_indices->push_back(compacted_text->size());
  }
  return true;
}

bool JtlParser::HasFinished() {
  return state_->remaining_compacted_source.empty();
}

bool JtlParser::ParseNextOperation(std::string* name,
                                   base::ListValue* argument_list,
                                   bool* ends_sentence) {
  DCHECK(name);
  DCHECK(argument_list);
  DCHECK(ends_sentence);

  state_->last_context = state_->remaining_compacted_source;
  state_->last_line_number = GetOriginalLineNumber(
      compacted_source_.size() - state_->remaining_compacted_source.length());

  std::string arguments, separator;
  if (!RE2::Consume(&state_->remaining_compacted_source,
                    state_->single_operation_regex,
                    name,
                    &arguments,
                    &separator))
    return false;

  *ends_sentence = (separator == kEndOfSentenceSeparator);
  state_->last_context.remove_suffix(state_->remaining_compacted_source.size());

  re2::StringPiece arguments_piece(arguments);
  std::string string_value, boolean_value;
  while (!arguments_piece.empty()) {
    if (!RE2::Consume(&arguments_piece,
                      state_->single_argument_regex,
                      &string_value,
                      &boolean_value))
      return false;

    if (!boolean_value.empty()) {
      argument_list->Append(
          new base::FundamentalValue(boolean_value == kTrueKeyword));
    } else {
      // |string_value| might be empty for an empty string
      argument_list->Append(new base::StringValue(string_value));
    }
  }
  return true;
}

size_t JtlParser::GetOriginalLineNumber(size_t compacted_index) const {
  return static_cast<size_t>(std::upper_bound(newline_indices_.begin(),
                                              newline_indices_.end(),
                                              compacted_index) -
                             newline_indices_.begin());
}

size_t JtlParser::GetLastLineNumber() const { return state_->last_line_number; }

std::string JtlParser::GetLastContext() const {
  return state_->last_context.ToString();
}