/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 **/

#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS
#endif

#include "types/IntervalParser.hpp"

#include <algorithm>
#include <cctype>
#include <cinttypes>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <string>

#include "types/IntervalLit.hpp"

// TODO(chasseur): This file has some moderately complex invocations of
// sscanf() and some branchy conditional parsing. Parsing performance might be
// improved by using some pre-compiled regexes instead of just sscanf().

namespace quickstep {

bool IntervalParser::ParseDatetimeIntervalSimpleFormat(
    const std::int64_t count,
    const std::string &units_lowercase,
    DatetimeIntervalLit *interval) {
  if ((units_lowercase == "microsecond")
      || (units_lowercase == "microseconds")
      || (units_lowercase == "us")) {
    interval->interval_ticks = count * (DatetimeIntervalLit::kTicksPerSecond / 1000000);
    return true;
  } else if ((units_lowercase == "millisecond")
      || (units_lowercase == "milliseconds")
      || (units_lowercase == "ms")) {
    interval->interval_ticks = count * (DatetimeIntervalLit::kTicksPerSecond / 1000);
    return true;
  } else if ((units_lowercase == "second")
      || (units_lowercase == "seconds")
      || (units_lowercase == "s")) {
    interval->interval_ticks = count * DatetimeIntervalLit::kTicksPerSecond;
    return true;
  } else if ((units_lowercase == "minute")
      || (units_lowercase == "minutes")) {
    interval->interval_ticks = count * DatetimeIntervalLit::kTicksPerSecond * 60;
    return true;
  } else if ((units_lowercase == "hour")
      || (units_lowercase == "hours")
      || (units_lowercase == "h")) {
    interval->interval_ticks = count * DatetimeIntervalLit::kTicksPerSecond * 60 * 60;
    return true;
  } else if ((units_lowercase == "day")
      || (units_lowercase == "days")
      || (units_lowercase == "d")) {
    interval->interval_ticks = count * DatetimeIntervalLit::kTicksPerSecond * 60 * 60 * 24;
    return true;
  } else if ((units_lowercase == "week")
      || (units_lowercase == "weeks")
      || (units_lowercase == "w")) {
    interval->interval_ticks = count * DatetimeIntervalLit::kTicksPerSecond * 60 * 60 * 24 * 7;
    return true;
  } else {
    return false;
  }
}

bool IntervalParser::ParseDatetimeIntervalComplexFormat(
    const std::string &interval_string,
    DatetimeIntervalLit *interval) {
  // First, look for a leading minus (we don't just parse the first field as
  // signed, because the first field could look like negative 0, e.g. in
  // "-00:30:00", and we would mistakenly parse such an interval as being
  // futureward rather than pastward).
  int start_offset = 0;
  int matched = std::sscanf(interval_string.c_str(),
                            "%*1[-]%n",
                            &start_offset);

  // Now, 'start_offset' is 0 if there is no leading minus, or nonzero and
  // pointing to the first character after the minus if there is one.

  std::int64_t days, hours;
  int minutes, seconds, subseconds;
  char daysbuf[5];  // Buffer for unit string containing "days" or something similar.
  int seconds_end = 0;
  int parse_end = 0;
  bool have_subseconds = false;

  // First, try matching with "X day(s)" specified at the front of the string.
  matched = std::sscanf(interval_string.c_str() + start_offset,
                        "%" SCNd64 " %4s %2" SCNd64 ":%2d:%2d%n.%6d%n",
                        &days,
                        daysbuf,
                        &hours,
                        &minutes,
                        &seconds,
                        &seconds_end,
                        &subseconds,
                        &parse_end);

  if ((matched == 5) || (matched == 6)) {
    // Make sure there is no garbage at the end of the string.
    switch (matched) {
      case 5:
        if (static_cast<std::string::size_type>(start_offset + seconds_end)
            != interval_string.length()) {
          return false;
        }
        break;
      case 6:
        if (static_cast<std::string::size_type>(start_offset + parse_end)
            != interval_string.length()) {
          return false;
        }
        have_subseconds = true;
        break;
      default:
        return false;
    }

    // Check that "day" or "days" (case insensitive) was specified where we
    // expect.
    const std::size_t daysbuf_length = std::strlen(daysbuf);
    for (std::size_t i = 0; i < daysbuf_length; ++i) {
      daysbuf[i] = ::tolower(daysbuf[i]);
    }
    if (!((std::strcmp("day", daysbuf) == 0)
          || (std::strcmp("days", daysbuf) == 0))) {
      return false;
    }

    // Check that hours are in the range 0-23 when a day is specified.
    if (hours > 23) {
      return false;
    }
  } else {
    // Try again without leading "days" portion.
    days = 0;
    seconds_end = parse_end = 0;
    matched = std::sscanf(interval_string.c_str() + start_offset,
                          "%" SCNd64 ":%2d:%2d%n.%6d%n",
                          &hours,
                          &minutes,
                          &seconds,
                          &seconds_end,
                          &subseconds,
                          &parse_end);

    // Make sure there is no garbage at the end of the string, and that at
    // least hours, minutes, seconds have been specified.
    switch (matched) {
      case 3:
        if (static_cast<std::string::size_type>(start_offset + seconds_end)
            != interval_string.length()) {
          return false;
        }
        break;
      case 4:
        if (static_cast<std::string::size_type>(start_offset + parse_end)
            != interval_string.length()) {
          return false;
        }
        have_subseconds = true;
        break;
      default:
        return false;
    }
  }

  // We already consumed the leading minus (if any) above, so make sure that
  // none of the fields parsed as negative.
  if ((days < 0)
      || (hours < 0)
      || (minutes < 0)
      || (seconds < 0)
      || (have_subseconds && (subseconds < 0))) {
    return false;
  }

  // Check that minutes and seconds are in-range.
  if ((minutes > 59) || (seconds > 59)) {
    return false;
  }

  if (have_subseconds) {
    // If less than 6 digits of subseconds were specified, multiply the
    // the subseconds so that they are scaled properly.
    const int adjustment_digits = 6 - (parse_end - seconds_end - 1);
    for (int i = 0; i < adjustment_digits; ++i) {
      subseconds *= 10;
    }
  } else {
    subseconds = 0;
  }

  // Add up the total magnitude of the interval in ticks.
  const std::int64_t total_ticks
      = (((days * 24 + hours) * 60 + minutes) * 60 + seconds)
            * DatetimeIntervalLit::kTicksPerSecond
        + subseconds;

  // Negate if there was a preceding minus "-".
  interval->interval_ticks = (start_offset == 0) ? total_ticks
                                                 : -total_ticks;

  return true;
}

bool IntervalParser::ParseYearMonthIntervalSimpleFormat(
    const std::int64_t count,
    const std::string &units_lowercase,
    YearMonthIntervalLit *interval) {
  if ((units_lowercase == "month")
      || (units_lowercase == "months")
      || (units_lowercase == "mon")
      || (units_lowercase == "mons")) {
    interval->months = count;
    return true;
  } else if ((units_lowercase == "year")
      || (units_lowercase == "years")
      || (units_lowercase == "y")) {
    interval->months = count * 12;
    return true;
  } else if ((units_lowercase == "decade")
      || (units_lowercase == "decades")) {
    interval->months = count * 12 * 10;
    return true;
  } else if ((units_lowercase == "century")
      || (units_lowercase == "centuries")) {
    interval->months = count * 12 * 100;
    return true;
  } else if ((units_lowercase == "millennium")
      || (units_lowercase == "millennia")) {
    interval->months = count * 12 * 1000;
    return true;
  } else {
    return false;
  }
}

bool IntervalParser::ParseYearMonthIntervalComplexFormat(
    const std::string &interval_string,
    YearMonthIntervalLit *interval) {
  // First, look for a leading minus (we don't just parse the first field as
  // signed, because the first field could look like negative 0, e.g. in
  // "-0 years 2 mons", and we would mistakenly parse such an interval as being
  // futureward rather than pastward).
  int start_offset = 0;
  int matched = std::sscanf(interval_string.c_str(),
                            "%*1[-]%n",
                            &start_offset);

  // Now, 'start_offset' is 0 if there is no leading minus, or nonzero and
  // pointing to the first character after the minus if there is one.

  std::int64_t years;
  int months;
  char yearsbuf[6];
  char monthsbuf[7];
  int parse_end = 0;

  matched = std::sscanf(interval_string.c_str() + start_offset,
                        "%" SCNd64 " %5s %d %6s%n",
                        &years,
                        yearsbuf,
                        &months,
                        monthsbuf,
                        &parse_end);

  // Make sure we matched all the expected fields, that there is no trailing
  // garbage at the end of the string, and that years and months are in range.
  if ((matched != 4)
      || (static_cast<std::string::size_type>(start_offset + parse_end)
          != interval_string.length())
      || (years < 0) || (months < 0) || (months > 11)) {
    return false;
  }

  // Case-insensitive check for some string indicating years.
  const std::size_t yearsbuf_length = std::strlen(yearsbuf);
  for (std::size_t i = 0; i < yearsbuf_length; ++i) {
    yearsbuf[i] = ::tolower(yearsbuf[i]);
  }
  if (!((std::strcmp("year", yearsbuf) == 0)
        || (std::strcmp("years", yearsbuf) == 0)
        || (std::strcmp("y", yearsbuf) == 0))) {
    return false;
  }

  // Case-insensitive check for some string indicating months.
  const std::size_t monthsbuf_length = std::strlen(monthsbuf);
  for (std::size_t i = 0; i < monthsbuf_length; ++i) {
    monthsbuf[i] = ::tolower(monthsbuf[i]);
  }
  if (!((std::strcmp("month", monthsbuf) == 0)
        || (std::strcmp("months", monthsbuf) == 0)
        || (std::strcmp("mon", monthsbuf) == 0)
        || (std::strcmp("mons", monthsbuf) == 0))) {
    return false;
  }

  // Add up total magnitude in months, negate if there was a preceding minus
  // "-".
  interval->months = (start_offset == 0) ? (years * 12 + months)
                                         : - (years * 12 + months);

  return true;
}

bool IntervalParser::ParseSimpleFormatFieldsFromCombinedString(
    const std::string &interval_string,
    std::int64_t *count,
    std::string *units_lowercase) {
  int units_start, units_end, scan_end;

  // Both value and units single-quoted.
  units_start = units_end = scan_end = 0;
  int matched = std::sscanf(interval_string.c_str(),
                            " ' %" SCNd64 " %n%*[^' \t\n\v\f\r]%n ' %n",
                            count, &units_start, &units_end, &scan_end);
  if ((matched == 1)
      && (static_cast<std::string::size_type>(scan_end) == interval_string.length())) {
    units_lowercase->assign(interval_string, units_start, units_end - units_start);
    std::transform(units_lowercase->begin(),
                   units_lowercase->end(),
                   units_lowercase->begin(),
                   ::tolower);
    return true;
  }

  // Value single-quoted, units not.
  units_start = units_end = scan_end = 0;
  matched = std::sscanf(interval_string.c_str(),
                        " ' %" SCNd64 " ' %n%*[^' \t\n\v\f\r]%n %n",
                        count, &units_start, &units_end, &scan_end);
  if ((matched == 1)
      && (static_cast<std::string::size_type>(scan_end) == interval_string.length())) {
    units_lowercase->assign(interval_string, units_start, units_end - units_start);
    std::transform(units_lowercase->begin(),
                   units_lowercase->end(),
                   units_lowercase->begin(),
                   ::tolower);
    return true;
  }

  // No quotes.
  units_start = units_end = scan_end = 0;
  matched = std::sscanf(interval_string.c_str(),
                        " %" SCNd64 " %n%*[^' \t\n\v\f\r]%n %n",
                        count, &units_start, &units_end, &scan_end);
  if ((matched == 1)
      && (static_cast<std::string::size_type>(scan_end) == interval_string.length())) {
    units_lowercase->assign(interval_string, units_start, units_end - units_start);
    std::transform(units_lowercase->begin(),
                   units_lowercase->end(),
                   units_lowercase->begin(),
                   ::tolower);
    return true;
  }

  // Unrecognized format.
  return false;
}

bool IntervalParser::ParseSimpleFormatFieldsFromCombinedStringNoExtraWhitespace(
    const std::string &interval_string,
    std::int64_t *count,
    std::string *units_lowercase) {
  int units_start, units_end, scan_end;

  // Both value and units single-quoted.
  units_start = units_end = scan_end = 0;
  int matched = std::sscanf(interval_string.c_str(),
                            "'%" SCNd64 " %n%*[^' \t\n\v\f\r]%n'%n",
                            count, &units_start, &units_end, &scan_end);
  if ((matched == 1)
      && (static_cast<std::string::size_type>(scan_end) == interval_string.length())) {
    units_lowercase->assign(interval_string, units_start, units_end - units_start);
    std::transform(units_lowercase->begin(),
                   units_lowercase->end(),
                   units_lowercase->begin(),
                   ::tolower);
    return true;
  }

  // Value single-quoted, units not.
  units_start = units_end = scan_end = 0;
  matched = std::sscanf(interval_string.c_str(),
                        "'%" SCNd64 "' %n%*[^' \t\n\v\f\r]%n",
                        count, &units_start, &units_end);
  if ((matched == 1)
      && (static_cast<std::string::size_type>(units_end) == interval_string.length())) {
    units_lowercase->assign(interval_string, units_start, units_end - units_start);
    std::transform(units_lowercase->begin(),
                   units_lowercase->end(),
                   units_lowercase->begin(),
                   ::tolower);
    return true;
  }

  // No quotes.
  units_start = units_end = scan_end = 0;
  matched = std::sscanf(interval_string.c_str(),
                        "%" SCNd64 " %n%*[^' \t\n\v\f\r]%n",
                        count, &units_start, &units_end);
  if ((matched == 1)
      && (static_cast<std::string::size_type>(units_end) == interval_string.length())) {
    units_lowercase->assign(interval_string, units_start, units_end - units_start);
    std::transform(units_lowercase->begin(),
                   units_lowercase->end(),
                   units_lowercase->begin(),
                   ::tolower);
    return true;
  }

  // Unrecognized format.
  return false;
}

}  // namespace quickstep