// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

part of "dart:_http";

/// Utility functions for working with dates with HTTP specific date
/// formats.
class HttpDate {
  // From RFC-2616 section "3.3.1 Full Date",
  // http://tools.ietf.org/html/rfc2616#section-3.3.1
  //
  // HTTP-date    = rfc1123-date | rfc850-date | asctime-date
  // rfc1123-date = wkday "," SP date1 SP time SP "GMT"
  // rfc850-date  = weekday "," SP date2 SP time SP "GMT"
  // asctime-date = wkday SP date3 SP time SP 4DIGIT
  // date1        = 2DIGIT SP month SP 4DIGIT
  //                ; day month year (e.g., 02 Jun 1982)
  // date2        = 2DIGIT "-" month "-" 2DIGIT
  //                ; day-month-year (e.g., 02-Jun-82)
  // date3        = month SP ( 2DIGIT | ( SP 1DIGIT ))
  //                ; month day (e.g., Jun  2)
  // time         = 2DIGIT ":" 2DIGIT ":" 2DIGIT
  //                ; 00:00:00 - 23:59:59
  // wkday        = "Mon" | "Tue" | "Wed"
  //              | "Thu" | "Fri" | "Sat" | "Sun"
  // weekday      = "Monday" | "Tuesday" | "Wednesday"
  //              | "Thursday" | "Friday" | "Saturday" | "Sunday"
  // month        = "Jan" | "Feb" | "Mar" | "Apr"
  //              | "May" | "Jun" | "Jul" | "Aug"
  //              | "Sep" | "Oct" | "Nov" | "Dec"

  /// Format a date according to
  /// [RFC-1123](http://tools.ietf.org/html/rfc1123 "RFC-1123"),
  /// e.g. `Thu, 1 Jan 1970 00:00:00 GMT`.
  static String format(DateTime date) {
    StringBuffer sb = StringBuffer();
    _formatTo(date, sb);
    return sb.toString();
  }

  static const List<String> _weekdayAbbreviations = <String>[
    "Mon",
    "Tue",
    "Wed",
    "Thu",
    "Fri",
    "Sat",
    "Sun",
  ];

  static const List<String> _weekdays = <String>[
    "Monday",
    "Tuesday",
    "Wednesday",
    "Thursday",
    "Friday",
    "Saturday",
    "Sunday",
  ];

  static const List<String> _monthAbbreviations = <String>[
    "Jan",
    "Feb",
    "Mar",
    "Apr",
    "May",
    "Jun",
    "Jul",
    "Aug",
    "Sep",
    "Oct",
    "Nov",
    "Dec",
  ];

  static String _formatTo(DateTime date, StringSink sb) {
    DateTime d = date.toUtc();
    sb
      ..write(_weekdayAbbreviations[d.weekday - 1])
      ..write(", ")
      ..write(d.day <= 9 ? "0" : "")
      ..write(d.day.toString())
      ..write(" ")
      ..write(_monthAbbreviations[d.month - 1])
      ..write(" ")
      ..write(d.year.toString())
      ..write(d.hour <= 9 ? " 0" : " ")
      ..write(d.hour.toString())
      ..write(d.minute <= 9 ? ":0" : ":")
      ..write(d.minute.toString())
      ..write(d.second <= 9 ? ":0" : ":")
      ..write(d.second.toString())
      ..write(" GMT");
    return sb.toString();
  }

  /// Parse a date string in either of the formats
  /// [RFC-1123](http://tools.ietf.org/html/rfc1123 "RFC-1123"),
  /// [RFC-850](http://tools.ietf.org/html/rfc850 "RFC-850") or
  /// ANSI C's asctime() format. These formats are listed here.
  ///
  /// * Thu, 1 Jan 1970 00:00:00 GMT
  /// * Thursday, 1-Jan-1970 00:00:00 GMT
  /// * Thu Jan  1 00:00:00 1970
  ///
  /// For more information see [RFC-2616 section
  /// 3.1.1](http://tools.ietf.org/html/rfc2616#section-3.3.1
  /// "RFC-2616 section 3.1.1").
  static DateTime parse(String date) =>
      _parse(date, 0, date.length, _invalidHttpDate, isCookieDate: false);

  static Never _invalidHttpDate(String source, int start, int end) =>
      throw HttpException("Invalid HTTP date ${source.substring(start, end)}");

  /// Try parsing like [parse], but return `null` if parsing fails.
  static DateTime? _tryParse(String date) {
    try {
      return _parse(date, 0, date.length, _failedTryParse, isCookieDate: false);
    } on HttpException {
      return null;
    }
  }

  // Cheaper throw for [_tryParse]
  static Never _failedTryParse(String source, int start, int end) =>
      throw const HttpException("");

  /// Implements [parse] on a substring.
  ///
  /// If [isCookieDate] is `true`, also accepts `Thu, 1-Jan-1970 00:00:00 GMT`,
  /// with `-`s between day-month-year.
  /// This format was accepted by the special Cookie-date parser,
  /// which now uses this function too.
  static DateTime _parse(
    String source,
    int start,
    int end,
    Never Function(String, int, int) onError, {
    required bool isCookieDate,
  }) {
    final int SP = 32;

    // Almost same format after the week-day, only differ by one character.
    const int formatRfc1123 = _CharCode.SP;
    const int formatRfc850 = _CharCode.MINUS;
    // Separate format.
    const int formatAsctime = 0;

    int index = start;

    Never throwError() {
      onError(source, start, end);
    }

    bool maybeExpectChar(int charCode) {
      if (index < end && source.codeUnitAt(index) == charCode) {
        index++;
        return true;
      }
      return false;
    }

    void expectChar(int charCode) {
      if (!maybeExpectChar(charCode)) throwError();
    }

    // Detects one of three recognized formats.
    //
    // All three formats start with the week-day in different ways:
    // * `Mon `: [formatAsctime]
    // * `Mon,`: [formatRfc1123]
    // * `Monday,`: [formatRfc850]
    int expectWeekday() {
      for (var i = 0; i < _weekdayAbbreviations.length; i++) {
        var wkday = _weekdayAbbreviations[i]; // Three-letter day abbreviation.
        assert(wkday.length == 3);
        if (index + 3 <= end && _isTextNoCase(source, index, 3, wkday)) {
          var weekday = _weekdays[i]; // Unabbreviated day.
          // Check if following characters are the rest of the day name.
          if (index + weekday.length <= end &&
              _isTextNoCase(
                source,
                index + 3,
                weekday.length - 3,
                weekday,
                3,
              )) {
            index += weekday.length;
            expectChar(_CharCode.COMMA);
            return formatRfc850;
          }
          index += 3;
          if (index < end) {
            var nextChar = source.codeUnitAt(index);
            if (nextChar == _CharCode.COMMA) {
              index++;
              return formatRfc1123;
            }
            if (nextChar == _CharCode.SP) {
              index++;
              return formatAsctime;
            }
          }
          break;
        }
      }
      throwError();
    }

    int expectMonth() {
      for (var i = 0; i < _monthAbbreviations.length; i++) {
        String monthAbbreviation = _monthAbbreviations[i];
        assert(monthAbbreviation.length == 3);
        if (index + 3 <= end &&
            _isTextNoCase(source, index, 3, monthAbbreviation)) {
          index += 3;
          return i;
        }
      }
      throwError();
    }

    int expectNum(int maxLength) {
      int value = 0;
      int start = index;
      while (index < end) {
        int digit = source.codeUnitAt(index) ^ 0x30;
        if (digit <= 9) {
          value = value * 10 + digit;
          index++;
          continue;
        }
        break;
      }
      int length = index - start;
      if (length > 0 && length <= maxLength) {
        return value;
      }
      throwError();
    }

    int format = expectWeekday();
    int year;
    int month;
    int day;
    int hours;
    int minutes;
    int seconds;
    if (format == formatAsctime) {
      month = expectMonth();
      expectChar(_CharCode.SP);
      if (source.codeUnitAt(index) == _CharCode.SP) index++;
      day = expectNum(2);
      expectChar(_CharCode.SP);
      hours = expectNum(2);
      expectChar(_CharCode.COLON);
      minutes = expectNum(2);
      expectChar(_CharCode.COLON);
      seconds = expectNum(2);
      expectChar(_CharCode.SP);
      year = expectNum(4);
    } else {
      var dateSeparator = format;
      var alternateDateSeparator = isCookieDate
          ? _CharCode.MINUS
          : _CharCode.NONE;
      expectChar(_CharCode.SP);
      day = expectNum(2);
      if (!maybeExpectChar(dateSeparator)) expectChar(alternateDateSeparator);
      month = expectMonth();
      if (!maybeExpectChar(dateSeparator)) expectChar(alternateDateSeparator);
      year = expectNum(4);
      expectChar(_CharCode.SP);
      hours = expectNum(2);
      expectChar(_CharCode.COLON);
      minutes = expectNum(2);
      expectChar(_CharCode.COLON);
      seconds = expectNum(2);
      if (index + 4 <= end && _isTextNoCase(source, index, 4, ' GMT')) {
        index += 4;
      } else {
        throwError();
      }
    }
    if (index != end) throwError();
    if (isCookieDate && year < 100) {
      year += year >= 70 ? 1900 : 2000;
    }
    return DateTime.utc(year, month + 1, day, hours, minutes, seconds);
  }

  // Parse a cookie date (sub-)string.
  //
  // Allows all HTTP legacy formats, not just the recommended RFC-1123 format.
  //
  // See https://www.rfc-editor.org/rfc/rfc2616#section-3.3.1
  static DateTime _parseCookieDate(
    String source,
    int sourceStart,
    int sourceEnd,
  ) => _parse(
    source,
    sourceStart,
    sourceEnd,
    _invalidCookieDate,
    isCookieDate: true,
  );

  static Never _invalidCookieDate(String source, int start, int end) =>
      throw HttpException(
        "Invalid cookie date ${source.substring(start, end)}",
      );
}