Ticket #568: iso8601.d

import tango.util.time.Date;

/// Returns the number of chars used to compose a valid date: 0 if no date can be composed.
/// Fields in date will either be correct (e.g. months will be >= 1 and <= 12) or zero.

size_t iso8601Date(T)(T[] src, inout Date date, size_t expanded = 0) {
    ubyte dummy = void;
    T* p = src.ptr;
    return doIso8601Date(p, src, date, expanded, dummy);
}

private size_t doIso8601Date(T)(inout T* p, T[] src, inout Date date, size_t expanded, out ubyte separators)
out {
    assert (!date.month || (              date.month >= 1 && date.month <= 12));
    assert (!date.day   || (date.month && date.day   >= 1 && date.day   <= daysPerMonth(date.month, date.year)));
} body {

    size_t eaten() { return p - src.ptr; }
    bool done(T[] s) { return .done(eaten(), src.length, *p, s); }

    if (!parseYear(p, expanded, date.year))
        return (date.year = 0);

    auto onlyYear = eaten();

    // /([+-]Y{expanded})?(YYYY|YY)/
    if (done("-0123W"))
        return onlyYear;

    if (accept(p, '-'))
        separators = true;

    if (accept(p, 'W')) {
        // (year)-Www-D

        T* p2 = p;

        int i = parseInt(p, 3u);

        if (i) if (p - p2 == 2) {

            // (year)-Www
            if (done("-")) {
                if (getMonthAndDayFromWeek(date, i))
                    return eaten();

            // (year)-Www-D
            } else if (demand(p, '-'))
                if (getMonthAndDayFromWeek(date, i, *p++ - '0'))
                    return eaten();

        } else if (p - p2 == 3)
            // (year)WwwD
            if (getMonthAndDayFromWeek(date, i / 10, i % 10))
                return eaten();

        return onlyYear;
    }

    // next up, MM or MM[-]DD or DDD

    T* p2 = p;

    int i = parseInt(p);
    if (!i)
        return onlyYear;

    switch (p - p2) {
        case 2:
            date.month = i;

            if (!(date.month >= 1 && date.month <= 12)) {
                date.month = 0;
                return onlyYear;
            }

            auto onlyMonth = eaten();

            // (year)-MM
            if (done("-"))
                return onlyMonth;

            // (year)-MM-DD
            if (!(
                demand(p, '-') &&
                (date.day = parseInt(p, 2u)) != 0 && date.day <= daysPerMonth(date.month, date.year)
            )) {
                date.day = 0;
                return onlyMonth;
            }

            break;

        case 4:
            // e.g. 20010203, i = 203 now

            date.month = i / 100;
            date.day   = i % 100;

            // (year)MMDD
            if (!(
                date.month >= 1 && date.month <= 12 &&
                date.day   >= 0 && date.day   <= daysPerMonth(date.month, date.year)
            )) {
                date.month = date.day = 0;
                return onlyYear;
            }

            break;

        case 3:
            // (year)-DDD
            // i is the ordinal of the day within the year

            bool leap = isLeapYear(date.year);

            if (i > 365 + leap)
                return onlyYear;

            if (i <= 31) {
                date.month = 1;
                date.day   = i;

            } else if (i <= 59 + leap) {
                date.month = 2;
                date.day   = i - 31 - leap;

            } else if (i <= 90 + leap) {
                date.month = 3;
                date.day   = i - 59 - leap;

            } else if (i <= 120 + leap) {
                date.month = 4;
                date.day   = i - 90 - leap;

            } else if (i <= 151 + leap) {
                date.month = 5;
                date.day   = i - 120 - leap;

            } else if (i <= 181 + leap) {
                date.month = 6;
                date.day   = i - 151 - leap;

            } else if (i <= 212 + leap) {
                date.month = 7;
                date.day   = i - 181 - leap;

            } else if (i <= 243 + leap) {
                date.month = 8;
                date.day   = i - 212 - leap;

            } else if (i <= 273 + leap) {
                date.month = 9;
                date.day   = i - 243 - leap;

            } else if (i <= 304 + leap) {
                date.month = 10;
                date.day   = i - 273 - leap;

            } else if (i <= 334 + leap) {
                date.month = 11;
                date.day   = i - 304 - leap;

            } else {
                if (i > 365 + leap)
                    assert (false);

                date.month = 12;
                date.day   = i - 334 - leap;
            }

        default: break;
    }

    return eaten();
}

/// Returns the number of chars used to compose a valid date: 0 if no date can be composed.
/// Fields in date will be zero if incorrect: since 00:00:00,000 is a valid time, the return value must be checked to be sure of the result.
/// date.sec may be 60 if the hours and minutes are 23 and 59, as leap seconds are occasionally added to UTC time.
/// date.hour may be 0 or 24: the latter marks the end of a day, the former the beginning.

size_t iso8601Time(T)(T[] src, inout Date date) {
    bool dummy = void;
    T* p = src.ptr;
    return doIso8601Time(p, src, date, WHATEVER, dummy);
}

private enum : ubyte { NO = 0, YES = 1, WHATEVER }

// bothValid is used only to get iso8601() to catch errors correctly
private size_t doIso8601Time(T)(inout T* p, T[] src, inout Date date, ubyte separators, out bool bothValid)
out {
    // yes, I could just write >= 0, but this emphasizes the difference between == 0 and != 0
    assert (!date.hour || (date.hour > 0 && date.hour <=  24));
    assert (!date.min  || (date.min  > 0 && date.min  <=  59));
    assert (!date.sec  || (date.sec  > 0 && date.sec  <=  60));
    assert (!date.ms   || (date.ms   > 0 && date.ms   <= 999));
} body {

    size_t eaten() { return p - src.ptr; }
    bool done(T[] s) { return .done(eaten(), src.length, *p, s); }

    bool checkColon() {
        if (separators == WHATEVER)
            accept(p, ':');

        else if (accept(p, ':') != separators)
            return false;

        return true;
    }

    byte getTimeZone() { return .getTimeZone(p, date, separators, &done); }

    // TODO/BUG: need to convert from local time if got T
    // however, Tango provides nothing like Phobos's std.date.getLocalTZA
    // (which doesn't look like it should work on Windows, it should use tzi.bias only, and GetTimeZoneInformationForYear)
    // (and which uses too complicated code for Posix, tzset should be enough)
    // and I'm not interested in delving into system-specific code right now
    // remember also that -1 BC is the year zero in ISO 8601... -2 BC is -1, etc
    if (separators == WHATEVER)
        accept(p, 'T');

    if (parseInt(p, 2u, date.hour) != 2 || date.hour > 24)
        return (date.hour = 0);

    auto onlyHour = eaten();

    // hh
    if (done("+,-.012345:"))
        return onlyHour;

    switch (getDecimal(p, date, HOUR)) {
        case NOTFOUND: break;
        case    FOUND:
            auto onlyDecimal = eaten();
            if (getTimeZone() == BAD)
                return onlyDecimal;

            // /hh,h+/
            return eaten();

        case BAD: return onlyHour;
        default: assert (false);
    }

    switch (getTimeZone()) {
        case NOTFOUND: break;
        case    FOUND: return eaten();
        case BAD:      return onlyHour;
        default: assert (false);
    }

    if (
        !checkColon() ||

        parseInt(p, 2u, date.min) != 2 || date.min > 59 ||

        // hour 24 is only for 24:00:00
        (date.hour == 24 && date.min != 0)
    ) {
        date.min = 0;
        return onlyHour;
    }

    auto onlyMinute = eaten();

    // hh:mm
    if (done("+,-.0123456:")) {
        bothValid = true;
        return onlyMinute;
    }

    switch (getDecimal(p, date, MINUTE)) {
        case NOTFOUND: break;
        case    FOUND:
            auto onlyDecimal = eaten();
            if (getTimeZone() == BAD)
                return onlyDecimal;

            // /hh:mm,m+/
            bothValid = true;
            return eaten();

        case BAD: return onlyMinute;
        default: assert (false);
    }

    switch (getTimeZone()) {
        case NOTFOUND: break;
        case    FOUND: bothValid = true; return eaten();
        case BAD:      return onlyMinute;
        default: assert (false);
    }

    if (
        !checkColon() ||

        parseInt(p, 2u, date.sec) != 2 || date.sec > 60 ||

        (date.hour == 24 && date.sec  != 0) ||
        (date.sec  == 60 && date.hour != 23 && date.min != 59)
    ) {
        date.sec = 0;
        return onlyMinute;
    }

    auto onlySecond = eaten();

    // hh:mm:ss
    if (done("+,-.Z")) {
        bothValid = true;
        return onlySecond;
    }

    switch (getDecimal(p, date, SECOND)) {
        case NOTFOUND: break;
        case    FOUND:
            auto onlyDecimal = eaten();
            if (getTimeZone() == BAD)
                return onlyDecimal;

            // /hh:mm:ss,s+/
            bothValid = true;
            return eaten();

        case BAD: return onlySecond;
        default: assert (false);
    }

    if (getTimeZone() == BAD)
        return onlySecond;
    else {
        bothValid = true;
        return eaten(); // hh:mm:ss with timezone
    }
}

// combination of date and time
// stricter than just date followed by time:
//  can't have an expanded or reduced date
//  either use separators everywhere or not at all

/// This function is very strict: either a complete date and time can be extracted, or nothing can.
/// If this function returns zero, the fields of date are undefined.

size_t iso8601(T)(T[] src, inout Date date) {
    T* p = src.ptr;
    ubyte sep;
    bool bothValid = false;

    if (
        doIso8601Date(p, src, date, 0u, sep) &&
        date.year && date.month && date.day &&

        // by mutual agreement this T may be omitted
        // but this is just a convenience method for date+time anyway
        demand(p, 'T') &&

        doIso8601Time(p, src, date, sep, bothValid) &&
        bothValid
    )
        return p - src.ptr;
    else
        return 0;
}

/+ +++++++++++++++++++++++++++++++++++++++ +\

   Privates used by date

\+ +++++++++++++++++++++++++++++++++++++++ +/

// /([+-]Y{expanded})?(YYYY|YY)/
private bool parseYear(T)(inout T* p, size_t expanded, out int year) {

    bool doParse() {
        T* p2 = p;

        if (!parseInt(p, expanded + 4u, year))
            return false;

        // it's Y{expanded}YY, Y{expanded}YYYY, or unacceptable

        if (p - p2 - expanded == 2u)
            year *= 100;
        else if (p - p2 - expanded != 4u)
            return false;

        return true;
    }

    if (accept(p, '-')) {
        if (!doParse())
            return false;
        year = -year;
    } else {
        accept(p, '+');
        if (!doParse())
            return false;
    }

    return true;
}

// find the month and day based on the calendar week
// uses date.year for leap year calculations
// returns false if week and date.year are incompatible
// based on the VBA function at http://www.probabilityof.com/ISO8601.shtml
private bool getMonthAndDayFromWeek(inout Date date, int week, int day = 1) {
    if (week < 1 || week > 53 || day < 1 || day > 7)
        return false;

    bool leap = isLeapYear(date.year);

    // only years starting with Thursday and
    // leap years starting with Wednesday have 53 weeks

    if (week == 53) {
        int startingDay = dayOfWeek(date.year, 1, 1, leap);

        if (!(startingDay == 4 || (leap && startingDay == 3)))
            return false;
    }

    // days since year-01-04
    int delta = 7*(week - 1) - dayOfWeek(date.year, 1, 4, leap) + day;

    if (delta <= -4) {
        if (delta < -7)
            assert (false);

        --date.year;
        date.month = 12;
        date.day   = delta + 4 + 31;

    } else if (delta <= 27) {
        date.month = 1;
        date.day   = delta + 4;

    } else if (delta <= 56 + leap) {
        date.month = 2;
        date.day   = delta - 27;

    } else if (delta <= 87 + leap) {
        date.month = 3;
        date.day   = delta - 55 - leap;

    } else if (delta <= 117 + leap) {
        date.month = 4;
        date.day   = delta - 86 - leap;

    } else if (delta <= 148 + leap) {
        date.month = 5;
        date.day   = delta - 116 - leap;

    } else if (delta <= 178 + leap) {
        date.month = 6;
        date.day   = delta - 147 - leap;

    } else if (delta <= 209 + leap) {
        date.month = 7;
        date.day   = delta - 177 - leap;

    } else if (delta <= 240 + leap) {
        date.month = 8;
        date.day   = delta - 208 - leap;

    } else if (delta <= 270 + leap) {
        date.month = 9;
        date.day   = delta - 239 - leap;

    } else if (delta <= 301 + leap) {
        date.month = 10;
        date.day   = delta - 269 - leap;

    } else if (delta <= 331 + leap) {
        date.month = 11;
        date.day   = delta - 300 - leap;

    } else if (delta <= 361 + leap) {
        date.month = 12;
        date.day   = delta - 330 - leap;

    } else {
        if (delta > 365 + leap)
            assert (false);

        ++date.year;
        date.month = 1;
        date.day   = delta - 365 - leap + 4;
    }

    return true;
}

private bool isLeapYear(int year) {
    return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
}

// Babwani's Congruence
private int dayOfWeek(int year, int month, int day, bool leap)
in {
    assert (month  >= 1 && month  <= 12);
    assert (day    >= 1 && day    <= 31);

    // BUG: only works for 1900-3-1 to 2100-2-28
    assert (year >= 1901 && year <= 2099, "iso8601 :: Can't calculate day of week outside the years 1900-2099");

} out(result) {
    assert (result >= 1 && result <= 7);

} body {
    int f() {
        if (leap && month <= 2)
            return [6,2][month-1];

        return [0,3,3,6,1,4,6,2,5,0,3,5][month-1];
    }

    int d = ((5*(year % 100) / 4) - 2*((year / 100) % 4) + f() + day) % 7;

    // defaults to Saturday=0, Friday=6: convert to Monday=1, Sunday=7
    return (d <= 1 ? d+6 : d-1);
}

/+ +++++++++++++++++++++++++++++++++++++++ +\

   Privates used by time

\+ +++++++++++++++++++++++++++++++++++++++ +/

private enum : ubyte { HOUR, MINUTE, SECOND }
private enum :  byte { BAD, FOUND, NOTFOUND }

private byte getDecimal(T)(inout T* p, inout Date date, ubyte which) {
    if (accept(p, ',') || accept(p, '.')) {

        T* p2 = p;

        int i;
        size_t iLen = parseInt(p, i);

        if (
            iLen == 0 ||

            // if i is 0, must have at least 3 digits
            // ... or at least that's what I think the standard means
            // when it says "[i]f the magnitude of the number is less
            // than unity, the decimal sign shall be preceded by two
            // zeros"...
            // surely that should read "followed" and not "preceded"

            (i == 0 && iLen < 3)
        )
            return BAD;

        // 10 to the power of (iLen - 1)
        int pow = 1;
        while (--iLen)
            pow *= 10;

        switch (which) {
            case HOUR:
                date.min = 6 * i / pow;
                date.sec = 6 * i % pow;
                break;
            case MINUTE:
                date.sec = 6    * i / pow;
                date.ms  = 6000 * i / pow % 1000;
                break;
            case SECOND:
                date.ms = 100 * i / pow;
                break;

            default: assert (false);
        }

        return FOUND;
    }

    return NOTFOUND;
}

// the Date is always UTC, so this just adds the offset to the date fields
// another option would be to add time zone fields to Date and have this fill them

private byte <