/*
 * Copyright (c) 2025, Manuel Zahariev <manuel@duck.com>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#pragma once

#include <AK/Error.h>
#include <AK/GenericLexer.h>
#include <AK/Optional.h>
#include <AK/StringView.h>
#include <AK/Time.h>
#include <AK/Types.h>
#include <AK/Vector.h>
#include <LibJS/Runtime/Date.h>

#include <cctype> // Not included by default on macOS.

// Parse simplified ISO8601 and non-standard date formats to milliseconds
// from epoch (double). Synopsis:
// (1) Try to parse the string as simplified ISO8601 (case sensitive).
//   - if that worked, assemble result (4 below)
//   - hard fail (return NAN) if the input string "looks like" ISO8601,
//     but deviates.
// (2) If parsing ISO8601 "soft" fails (unlike "hard" above), continue
//     shallow parsing (case insensitive) date string components: time,
//     timezone, keywords, numbers...
// (3) Guess ambiguous date parts, like "1/2/3" --> Jan 2, 2003
// (4) Assemble result from parts (year, month,...) and convert to milliseconds
//     from epoch.
//
// Overall objectives:
// - compliance with ECMA date time string format, incl. ISO8601 extensions
//   for signed 6-digit year and extended time offset format (:SS.nanosecs)
//   https://tc39.es/ecma262/#sec-date-time-string-format
// - Support for Date.toString and Date.toUTCString formats.
// - Compatible with Mozilla Firefox 134.0.1 and Chromium 131.0.6778.264. Within
//   reason. Differences indicated in comments.
//   - Where Firefox and Chrome agree on a parse, support it.
//   - Where they disagree, support the one that seems more sane.
//   - In very limited cases, pick our own way. Example: "<number> Month":
//     - Firefox fails on all "<number> Month" date strings.
//     - In most cases, Chrome interprets "<number> Month" as "Month 01, Year".
//     - Chrome parses "7 Feb" as "Feb 7, 2001".
//     - We always parse as "Month 01, Year".
// - Support Firefox less permissive punctuation but more permissive punctuation
//   syntax.
class DateParser : public GenericLexer {
private:
    Vector<u64> m_numbers;

    Optional<i8> m_sign;
    Optional<i64> m_year;
    Optional<u8> m_month;
    Optional<u8> m_day;
    Optional<u8> m_hours;
    Optional<u8> m_minutes;
    Optional<u8> m_seconds;
    Optional<u16> m_milliseconds;

    // True if GMT/UTC/Z specified and there is no timezone offset; false if timezone offset.
    // No value if there is no timezone information: we have to guess whether the date was given in GMT or local time.
    Optional<bool> m_timezone_utc;
    Optional<i8> m_timezone_sign; // +1 or -1 if there is a timezone offset.
    Optional<u8> m_timezone_hours;
    Optional<u8> m_timezone_minutes;
    Optional<u8> m_timezone_seconds;
    Optional<u64> m_timezone_nanoseconds;

    constexpr static u64 pow10(size_t pow)
    {
        switch (pow) {
        case 0:
            return 1;
        case 1:
            return 10;
        case 2:
            return 100;
        case 3:
            return 1'000;
        case 4:
            return 10'000;
        case 5:
            return 100'000;
        case 6:
            return 1'000'000;
        case 7:
            return 10'000'000;
        case 8:
            return 100'000'000;
        case 9:
            return 1'000'000'000;
        }

        VERIFY_NOT_REACHED();
    }
    // Reads a contiguous sequence of digits. Ignores digits read past MaxLength.
    // Returns the numeric value of the sequence and the number of digits not ignored.
    template<typename T, size_t MaxLength>
    ALWAYS_INLINE std::pair<T, size_t> read_number()
    {
        static_assert(std::is_unsigned<T>(), "Type must be unsigned.");
        static_assert(MaxLength < 11, "Number too long.");
        static_assert((sizeof(T) >= 1) || (MaxLength <= 2), "Number too long.");
        static_assert((sizeof(T) >= 2) || (MaxLength <= 4), "Number too long.");
        static_assert((sizeof(T) >= 4) || (MaxLength <= 9), "Number too long.");
        static_assert((sizeof(T) >= 8) || (MaxLength <= 19), "Number too long.");

        auto result = std::make_pair(T(0), size_t(0));
        for (result.second = 0; result.second < MaxLength; ++result.second) {
            if (is_eof() || !next_is(isdigit))
                return result;
            result.first *= 10;
            result.first += consume() - '0';
        }

        ignore_while(isdigit);
        return result;
    }

    ALWAYS_INLINE bool guess_date_from_numbers() // Guess an ambiguous date, like 1/1/1.
    {
        switch (m_numbers.size()) {
        case 0:
            return true; // The year and possibly month may have already been calculated. Verify later
        case 1:
            return guess_date_from_1_number();
        case 2:
            return guess_date_from_2_numbers();
        case 3:
            return guess_date_from_3_numbers();
        }

        return false; // Too many numbers
    }
    ALWAYS_INLINE bool guess_date_from_3_numbers() // Only "month-day-year" (default) and "year-month-day" are supported (same as firefox and chrome).
    {
        VERIFY(m_numbers.size() == 3);

        u64 const number0 = m_numbers.at(0);
        u64 const number1 = m_numbers.at(1);
        u64 const number2 = m_numbers.at(2);

        if (m_year.has_value() || m_month.has_value())
            return false; // Too many numbers

        if ((number0 > 31) || number0 == 0) { // YMD
            if (number1 > 12)
                return false;
            if (number2 > 31)
                return false;

            if ((number1 == 0) || (number2 == 0)) // 0 for day or month
                return false;

            m_month = number1;
            m_day = number2;
            m_year = guess_year(number0);

            return true;
        }

        // MDY
        if (number0 > 12)
            return false; // Both Firefox and Chrome fail for the first number >12 and <=31. Weird. We do the same
        if (number1 > 31)
            return false;

        if ((number0 == 0) || (number1 == 0)) // 0 for day or month
            return false;

        m_month = number0;
        m_day = number1;
        m_year = guess_year(number2);

        return true;
    }
    ALWAYS_INLINE bool guess_date_from_2_numbers() // Guess default order "day-year" or adapt.
    {
        VERIFY(m_numbers.size() == 2);

        u64 const number0 = m_numbers.at(0);
        u64 const number1 = m_numbers.at(1);

        if (m_year.has_value() && m_month.has_value())
            return false; // Too many numbers

        if (m_year.has_value()) {
            if (number0 <= 12) { // ... is a month
                if (number1 > 31)
                    return false;
                if ((number0 == 0) || (number1 == 0)) // 0 for day or month
                    return false;

                m_month = number0;
                m_day = number1;
                return true;
            }

            if (number0 <= 31) { // ... is a day
                if (number1 > 12)
                    return false;

                if ((number0 == 0) || (number1 == 0)) // 0 for day or month
                    return false;

                m_month = number1;
                m_day = number0;
                return true;
            }
        }

        // At this point, one of the numbers is the year
        if (!m_month.has_value())
            return false; // Firefox fails on guessing 2 numbers. We do the same

        // At this point, the month has been read from a month name
        if ((number0 > 31) && (number1 > 31))
            return false;                       // Neither of the numbers can be a day
        if ((number0 > 31) || (number0 == 0)) { // ... is a year
            if (number1 == 0)                   // 0 for day
                return false;

            m_day = number1;
            m_year = guess_year(number0);
            return true;
        }

        // Default order is day -> year
        if (number0 == 0) // 0 for day
            return false;

        m_day = number0;
        m_year = guess_year(number1);

        return true;
    }
    ALWAYS_INLINE bool guess_date_from_1_number() // Guess in this order: year, month, day.
    {
        VERIFY(m_numbers.size() == 1);

        u64 const number0 = m_numbers.at(0);

        if (!m_year.has_value() && !m_month.has_value())
            return one_number(number0);

        if (!m_year.has_value()) { // the number must be a year
            m_year = guess_year(number0);
            return true;
        }

        if (!m_month.has_value()) // Firefox fails on two numbers. So do we. Chrome is weird.
            return false;

        // At this point, the year and month must have been specified some other way (e.g. "Feb +002002").
        if ((number0 > 31) || (number0 == 0)) // Invalid day number.
            return false;

        m_day = number0;

        return true;
    }
    ALWAYS_INLINE static u64 guess_year(u64 const number) // Guess one- or two-digit year.
    {
        switch (number) {
        case 0 ... 49:
            return 2000 + number;
        case 50 ... 99:
            return 1900 + number;
        }

        return number;
    }
    ALWAYS_INLINE bool one_number(u64 const number) // The whole input string is just one stand-alone number.}
    {
        switch (number) {
        case 0:
            m_year = 2000;
            return true;
        case 1 ... 12:
            m_year = 2001;
            m_month = number; // Firefox and Chrome interpret standalone numbers below 12 as months in 2001. Weird! We do the same.
            return true;
        case 13 ... 31:
            return false; // Firefox and Chrome fail on standalone numbers between 12 and 31. Weird! We do the same.
        case 32 ... 49:
            m_year = 2000 + number;
            return true;
        case 50 ... 99:
            m_year = 1900 + number;
            return true;
        }
        m_year = number;
        return true;
    }

    // Permissive, greedy shallow date parser for date components.
    // Returns:
    // - false: Hard fail. Some invalid input condition has been found. Caller should return NAN.
    // - true: Parsing can continue.
    ALWAYS_INLINE bool loop()
    {
        switch (peek()) {
        case '0' ... '9':
            return maybe_number(); // Also captures time.
        case '+':
        case '-':
            return maybe_sign(); // Also captures signed 6-digit year and timezone offset.
        case 'A' ... 'Z':
            return maybe_word(); // Captures all date string "keywords". Accepts any kind of "junk" before date and time..
        case ' ':
        case '.':
        case ',':
        case '/':
            // Firefox seems to accept (ignore) this punctuation. So do we.
            // Firefox also accepts a bare '+' sometimes. We do not.
            // Chrome is a lot more permissive.
            ignore(); // Ignore punctuation.
            return true;
        case '(':
            ignore_until(')'); // Consume time zone name (Anything in brackets).
            ignore();
            ignore_while(isspace);
            return true;
        }

        return false;
    }
    ALWAYS_INLINE bool maybe_ampm() // Side effect: consumes space at the end of a time component, even if there is no AM/PM.
    {
        VERIFY(m_hours.has_value());

        consume_while(isspace);

        if (consume_specific("AM"sv)) {
            if (!separator())
                return false; // 12:34 AMsomething

            if (m_hours.value() > 12)
                return false; // 14:45AM
            if (m_hours.value() == 12)
                m_hours = 0; // 12:05AM -> 00:05
            return true;
        }

        if (consume_specific("PM"sv)) {
            if (!separator())
                return false; // 12:34 PMsomething
            if (m_hours.value() > 12)
                return false; // 14:45PM
            if (m_hours.value() < 12)
                m_hours = m_hours.value() + 12;
            return true;
        }

        return true;
    }
    ALWAYS_INLINE bool maybe_time(std::pair<u32, size_t> const& hours) // H[H]:MM[:SS[.mss[...]]][ ][AM|PM] At this point, H[H]: has already been read.
    {
        if (m_hours.has_value())
            return false; // Time has already been read.

        if (hours.second > 2)
            return false; // 123:
        if (hours.first > 24)
            return false;
        m_hours = hours.first; // No precision loss during the conversion u32 -> u8 since the hours has at most 2 digits.

        auto const minutes = read_number<u32, 3>();
        if (minutes.second != 2)
            return false; // 12:345 or 12:3
        if (minutes.first > 59)
            return false;
        m_minutes = minutes.first;

        if (consume_specific('.'))
            return false; // 12:34.
        if (!consume_specific(':'))
            return true;

        auto const seconds = read_number<u32, 3>();
        if (seconds.second != 2)
            return false; // 12:34:567 or 12:34:5
        if (seconds.first > 59)
            return false;
        m_seconds = seconds.first;

        if (!consume_specific('.'))
            return true;

        auto const milliseconds = read_number<u32, 3>();
        switch (milliseconds.second) {
        case 0:
            return false; // 12:34:56.
        case 1:
            m_milliseconds = milliseconds.first * 100;
            break;
        case 2:
            m_milliseconds = milliseconds.first * 10;
            break;
        case 3:
            m_milliseconds = milliseconds.first;
            break;
        default:
            VERIFY_NOT_REACHED();
        }

        return true;
    }
    ALWAYS_INLINE bool maybe_number()
    {
        auto const number = read_number<u32, 7>();
        VERIFY(number.second > 0);

        if (number.second > 6)
            return false; // 1234567

        if (consume_specific(':')) {
            if (!maybe_time(number))
                return false;
            if (!maybe_ampm())
                return false;
            return true;
        }

        m_numbers.append(number.first);

        return separator(); // Must be followed by a separator.
    }
    ALWAYS_INLINE bool maybe_sign()
    {
        i8 const sign = (consume() == '-') ? -1 : +1;
        auto const number = read_number<u32, 7>();

        switch (number.second) {
        case 0: // Not a sign after all; '+' is forbidden if it is not a sign. '-' is ignored as punctuation.
            return (sign == -1);
        case 1 ... 5: // Too small to be a signed year;
            if (m_hours.has_value())
                break; // Candidate for timezone offset.

            m_numbers.append(number.first); // Ignore the sign and treat it as a number.
            return true;
        case 6:
            if (m_hours.has_value())
                break; // Candidate for timezone offset.

            if (m_year.has_value())
                return false; // To many digits to be anything else than a signed year.

            m_year = sign * number.first; // Candidate for signed year
            return true;
        default:
            return false;
        }

        m_timezone_sign = sign;
        return tz_offset(number);
    }

    ALWAYS_INLINE bool tz_offset() // Read a full timezone offset, including the sign.
    {
        m_timezone_sign = (consume() == '-') ? -1 : +1;
        auto const number = read_number<u32, 7>();
        return tz_offset(number);
    }
    // Continue reading a timezone offset, after the sign and the first number have beeen read.
    ALWAYS_INLINE bool tz_offset(std::pair<u32, size_t> const& number, bool iso_8601_format = false)
    {
        if (m_timezone_hours.has_value()) // Cannot have more than one timezone offset or a timezone name followed by a timezone offset.
            return false;

        m_timezone_utc = false;
        switch (number.second) {
        case 0:
            return false;
        case 1:
            if (iso_8601_format)
                return false; // +1
            [[fallthrough]];
        case 2:
            break; // Candidate for timezone offset with colon.
        case 3:
            if (iso_8601_format)
                return false; // +123
            [[fallthrough]];
        case 4: { // "Military" timezone offset
            u16 const tz_hhmm = number.first;
            m_timezone_hours = tz_hhmm / 100;
            m_timezone_minutes = tz_hhmm % 100;
            return true;
        }
        case 5:
            if (iso_8601_format)
                return false; // +12345
            [[fallthrough]];
        case 6: { // "Military" timezone offset
            u32 const tz_hhmmss = number.first;
            m_timezone_hours = tz_hhmmss / 10000;
            m_timezone_minutes = tz_hhmmss % 10000 / 100;
            m_timezone_seconds = tz_hhmmss % 100;
            return true;
        }
        default:
            return false;
        }

        m_timezone_hours = number.first; // Guaranteed to be a 1- or 2-digit number.

        if (!consume_specific(':'))
            return true; // +H[H] "military" time offset

        // Timezone with colon
        auto const minutes = read_number<u16, 3>();
        if (minutes.second != 2)
            return false;
        m_timezone_minutes = minutes.first;

        if (!consume_specific(':'))
            return true;

        auto const seconds = read_number<u16, 3>();
        if (seconds.second != 2)
            return false;
        m_timezone_seconds = seconds.first;

        if (!consume_specific('.'))
            return true;

        auto const nanoseconds = read_number<u64, 10>();
        if (nanoseconds.second == 0)
            return false;
        if (nanoseconds.second > 9)
            return false;

        m_timezone_nanoseconds = nanoseconds.first * pow10(9 - nanoseconds.second);

        return true;
    }
    ALWAYS_INLINE bool separator() // Ignore space and Firefox punctuation.
    {
        if (is_eof())
            return true;
        switch (peek()) {
        case ' ':
        case ',':
        case '.':
        case '/':
        case '-':
            ignore();
            return true;
        }
        return false;
    }
    ALWAYS_INLINE bool gmt(StringView const& str) // Z or GMT or UTC can be used interchangeably.
    {
        if (!consume_specific(str))
            return false;

        m_timezone_utc = true;

        bool space = consume_while(isspace).length() > 0;
        switch (peek()) {
        case '+':
        case '-':
            return tz_offset(); // GMT+1234
        }

        return space || separator();
    }
    // Same as Chrome and Firefox, we only support abbreviations for timezones covering the US mainland.
    ALWAYS_INLINE bool us_timezone(StringView const& str, u8 hours, u8 minutes = 0, i8 sign = -1)
    {
        VERIFY(str.length() == 3); // only 3-letter timezone names
        if (!consume_specific(str))
            return false;

        if (!m_hours.has_value() && m_numbers.is_empty() && !m_year.has_value()) // Ignore timezone before date or time.
            return false;

        m_timezone_sign = sign;
        m_timezone_hours = hours;
        m_timezone_minutes = minutes;

        return separator(); // Must end with a separator.
    }
    ALWAYS_INLINE bool month_name(StringView const& str, u8 month)
    {
        VERIFY(str.length() == 3); // Only looking for 3-letter month prefixes.
        for (size_t i = 0; i < 3; ++i)
            if (str[i] != peek(i))
                return false;

        ignore_while(isalpha); // ... which can followed by anything. Just like Firefox and Chrome.
        m_month = month;

        return separator(); // Must end with a separator.
    }
    ALWAYS_INLINE bool word() // Alphanumeric strings that are not date "keywords".
    {
        std::ignore = consume_while(isalpha);
        // Just like Firefox and Chrome:
        // - Ignore junk (bare words) at the beginning (before time or a date fragment has been read).
        // - Fail if a word is read later in the date string (exception: final time zone name, in brackets).
        return (m_numbers.is_empty() && !m_hours.has_value() && !m_year.has_value());
    }
    ALWAYS_INLINE bool maybe_word() // The top of a trie catching date "keywords".
    {
        switch (peek()) {
        case 'A': // APR AUG
            return month_name("APR"sv, 4) || month_name("AUG"sv, 8) || word();
        case 'C': // CST CDT
            return us_timezone("CST"sv, 6) || us_timezone("CDT"sv, 5) || word();
        case 'D': // DEC
            return month_name("DEC"sv, 12) || word();
        case 'E': // EST EDT
            return us_timezone("EST"sv, 5) || us_timezone("EDT"sv, 4) || word();
        case 'F': // FEB
            return month_name("FEB"sv, 2) || word();
        case 'G': // GMT
            return gmt("GMT"sv) || word();
        case 'J': // JAN JUN JUL
            return month_name("JAN"sv, 1) || month_name("JUN"sv, 6) || month_name("JUL"sv, 7) || word();
        case 'M': // MAR MAY MST MDT
            return month_name("MAR"sv, 3) || month_name("MAY"sv, 5) || us_timezone("MST"sv, 7) || us_timezone("MDT"sv, 6) || word();
        case 'N': // NOV
            return month_name("NOV"sv, 11) || word();
        case 'O': // OCT
            return month_name("OCT"sv, 10) || word();
        case 'P': // PST PDT
            return us_timezone("PST"sv, 8) || us_timezone("PDT"sv, 7) || word();
        case 'S': // SEP
            return month_name("SEP"sv, 9) || word();
        case 'U': // UTC
            return gmt("UTC"sv) || word();
        case 'Z': // Z
            return gmt("Z"sv) || word();
        }

        return word();
    }

    // Capture simplified ISO8601 date format. https://tc39.es/ecma262/#sec-date-time-string-format
    // All of the iso_... functions return:
    // - true: if the input can be parsed as an ISO8601 date.
    // - false: cannot be parsed as an ISO8601 date. Will be defered to a non-standard date string.
    // - Error: hard fail; caller is supposed to return NAN.
    ALWAYS_INLINE ErrorOr<bool> maybe_iso_8601()
    {
        for (size_t step = 0; step < 4; ++step) {
            switch (step) {
            case 0:
                if (!TRY(maybe_iso_year()))
                    return false;
                break;
            case 1:
                if (!TRY(maybe_iso_month_day()))
                    return false;
                break;
            case 2:
                if (!TRY(maybe_iso_time()))
                    return false;
                break;
            case 3:
                TRY(maybe_iso_tz());
                break;
            default:
                VERIFY_NOT_REACHED();
            }

            if (is_eof())
                return true;
        }

        return Error::from_string_literal("Read ISO8601 format, but have some input left over.");
    }
    ALWAYS_INLINE ErrorOr<bool> maybe_iso_year()
    {
        switch (peek()) {
        case '0' ... '9':
            if (TRY(maybe_iso_year4()))
                return true;
            break;
        case '+':
        case '-':
            if (TRY(maybe_iso_signed_year6()))
                return true;
            break;
        default:
            return false;
        }

        return false;
    }
    ALWAYS_INLINE ErrorOr<bool> maybe_iso_year4() // Like "2025".
    {
        auto number = read_number<u32, 7>();

        switch (number.second) {
        case 0:
            return false; // no digits
        case 1:
        case 2:
            if (next_is(':')) { // This may not be a year after all but the start of a "time" component.
                ignore();
                if (!maybe_time(number))
                    return Error::from_string_literal("Cannot parse time.");
                if (!maybe_ampm())
                    return Error::from_string_literal("Cannot parse am/pm.");
                return false;
            }
            [[fallthrough]];
        case 3:
        case 5:
        case 6: // Six-digit year number; no sign means not ISO8601 date.
            // At this point, this is not an ISO8601 date.
            m_numbers.append(number.first);
            return false;
        case 4: // Four-digit year number.
            m_year = number.first;
            return true; // This can be the start of an ISO8601 date.
        }

        return Error::from_string_literal("String too long to be a year.");
    }
    ALWAYS_INLINE ErrorOr<bool> maybe_iso_signed_year6() // Like "+002025".
    {
        i64 sign = +1;
        if (consume() == '-')
            sign = -1;
        auto number = read_number<u32, 7>();

        switch (number.second) {
        case 0:
            if (sign == +1) // Standalone '+' is invalid.
                return Error::from_string_literal("Invalid character in date string ('+').");
            return false;
        case 1 ... 5:
            m_numbers.append(number.first); // This is not an ISO8601 date.
            return false;
        case 6:
            break;
        default:
            return Error::from_string_literal("String too long to be a 6-digit signed year.");
        }

        m_year = sign * number.first;

        // "The representation of the year 0 as -000000 is invalid." https://tc39.es/ecma262/#sec-expanded-years
        // Firefox interprets "-000000" as "Jan 1, 2000".
        if ((sign == -1) && (m_year == 0))
            return Error::from_string_literal("The representation of the year 0 as '-000000' is invalid.");

        return true;
    }
    ALWAYS_INLINE ErrorOr<bool> maybe_iso_month_day() // [-MM[-DD]]
    {
        if (!consume_specific('-'))
            return true;

        auto month = read_number<u16, 3>();
        if (consume_specific(':')) { // Like "2000-12:34". Firefox and Chrome parse it correctly. We do the same.
            if (maybe_time(month))
                return false;
            return Error::from_string_literal("Found something that looks like time, but is not.");
        }

        switch (month.second) {
        case 0:
            return false; // Not ISO8601 date format. Continue reading.
        case 1:
            m_month = month.first;
            if (m_month == 0)
                return Error::from_string_literal("Month number cannot be zero.");
            return false;
        case 2:
            break;
        default: // month number too long
            return Error::from_string_literal("Month number too long.");
        }

        m_month = month.first;

        if ((m_month == 0) || (m_month.value() > 12))
            return Error::from_string_literal("Invalid month number.");

        if (!consume_specific('-'))
            return true;

        if (is_eof())
            return Error::from_string_literal("Expecting month number. Got eof.");

        auto day = read_number<u16, 3>();

        switch (day.second) {
        case 0:
            return false; // Not ISO8601 date format. Continue reading.
        case 1:
            m_day = day.first;
            if (m_day == 0)
                return Error::from_string_literal("Day number cannot be zero.");
            return false;
        case 2:
            break;
        default: // month number too long
            return Error::from_string_literal("Day number too long.");
        }

        m_day = day.first;
        if ((m_day == 0) || (m_day.value() > 31))
            return Error::from_string_literal("Invalid day number.");

        return true;
    }
    ALWAYS_INLINE ErrorOr<bool> maybe_iso_time() // THH:MM[:SS[.M[SS...]]]
    {
        // The ECMA date string format requires uppercase 'T' and 'Z' https://tc39.es/ecma262/#sec-date-time-string-format
        // - Chrome supports lower case occurrences.
        // - Firefox and us do not.
        if (!consume_specific('T'))
            return false;

        // After reading the 'T', any failures return NAN (failed parse)
        auto hours = read_number<u16, 3>();

        if (!consume_specific(':')) // 12
            return Error::from_string_literal("Well specified time needs minutes.");

        if (hours.second != 2)
            return Error::from_string_literal("Hours: invalid length.");

        if (!maybe_time(hours)) // The only difference is that ISO8601 requires 2-digit hours.
            return Error::from_string_literal("Cannot parse time.");

        return true;
    }
    ALWAYS_INLINE ErrorOr<void> maybe_iso_tz() // After the 'T' for iso_time has been read, reading an ISO8601 timezone either succeeds or the whole parse fails.
    {
        switch (consume()) {
        case 'Z':
            m_timezone_utc = true;
            return {};
        case '-':
            m_timezone_sign = -1;
            break;
        case '+':
            m_timezone_sign = +1;
            break;
        default:
            return Error::from_string_literal("Invalid timezone offset format.");
        }

        if (!tz_offset(read_number<u32, 7>(), true)) // A sign and a number have been read. Continue reading a timezone offset..
            return Error::from_string_literal("Invalid timezone offset format.");

        return {};
    }

    ALWAYS_INLINE double build_date(bool is_iso8601_date = false) // Build a date (milliseconds since epoch) from parts collected.
    {
        VERIFY(is_eof());

        if (!m_year.has_value())
            return NAN; // Needs at least one year.

        if ((m_hours == 24) && ((m_minutes.value_or(0) > 0) || (m_seconds.value_or(0) > 0)))
            return NAN; // 24:01:02

        AK::UnixDateTime time = AK::UnixDateTime::from_unix_time_parts( // local time
            m_year.value(),
            m_month.value_or(1),
            m_day.value_or(1),
            m_hours.value_or(0),
            m_minutes.value_or(0),
            m_seconds.value_or(0),
            m_milliseconds.value_or(0));

        double time_ms = static_cast<double>(time.milliseconds_since_epoch()); // Assume the date was given in UTC.

        if (m_timezone_sign.has_value()) { // A timezone offset was specified.
            if (m_timezone_hours.has_value() && (m_timezone_hours.value() > 24))
                return NAN;
            if (m_timezone_minutes.has_value() && (m_timezone_minutes.value() > 59))
                return NAN;
            if (m_timezone_seconds.has_value() && (m_timezone_seconds.value() > 59))
                return NAN;

            time_ms -= 1.0 * m_timezone_sign.value() * static_cast<double>( // Convert to a UTC timestamp: local timestamp minus timezone offset.
                           m_timezone_hours.value_or(0) * 3'600'000 + m_timezone_minutes.value_or(0) * 60'000 + m_timezone_seconds.value_or(0) * 1'000 + static_cast<u64>(m_timezone_nanoseconds.value_or(0) / 1'000'000));
        } else if (!m_timezone_utc.has_value() && (!is_iso8601_date || m_hours.has_value())) {
            // If a timezone offset or GMT/UTC/Z was not specified and:
            // - Either this is not an ISO8601 [simplified] date
            // - Or this is a date-time form [of an ISO8601 date].
            // https://tc39.es/ecma262/#sec-date.parse:
            // "When the UTC offset representation is absent, date-only forms are interpreted as a UTC time and date-time forms are interpreted as a local time."

            time_ms = JS::utc_time(time_ms); // The date was given in local time; convert it to a UTC timestamp.
        } else {                             // An ISO8601 date-only form
            ;                                // nop; leave timestamp as UTC
        }

        return JS::time_clip(time_ms);
    }
    ALWAYS_INLINE ErrorOr<double> parse()
    {
        if (TRY(maybe_iso_8601()))
            return build_date(true);

        // Convert the input string to uppercase only ~after~ parsing ISO8601 failed.
        // This saves some time (two string copies) if parsing a ISO8601 date succeeds.
        // The index stays exactly where it was before converting to uppercase.
        auto str_uppercase = m_input.to_ascii_uppercase_string();
        m_input = str_uppercase;
        // FIXME: Two full string copies could be avoided, if to_uppercase can be done in place.
        // The underlying StringView m_input protects itself from modifying its contents. Bummer.

        while (!is_eof())
            if (!loop())
                return Error::from_string_literal("Cannot parse date components.");

        if (!guess_date_from_numbers())
            return Error::from_string_literal("Cannot guess date.");

        return build_date();
    }
    DateParser(StringView const& str)
        : GenericLexer(str)
    {
    }

public:
    ALWAYS_INLINE static double parse(StringView const& str)
    {
        return DateParser(str).parse().value_or(NAN);
    }
};