Age

// Working out how old someone is, in completed years, months and days. It sounds like
// subtraction and is not, because months have different lengths.
//
// The rule is the one people use: count whole years, then whole months, then the days left over.
// A month is complete when its day comes round again. When that day does not exist, the month
// is complete on its last day instead: one month after 31 January is 28 February, and someone
// born on 29 February has their birthday on 28 February in a year that is not a leap year.
//
// `PlusMonths` from the Time package follows exactly that rule, clamping to the end of the
// month, so the program never counts days in a month by hand. It finds the last date, on or
// before the second one, that is a whole number of months after the birth, and the days left
// over are a plain `DaysSince`.
//
// Every date is written out, so the output is the same on every run. A real program would ask
// the clock for today.
import Io::PrintLine;
import Time::{ Date, ParseDate };

struct Age {
    years: int64;
    months: int64;
    days: int64;
}

enum AgeError {
    BornLater,
    OutOfRange
}

// The age on `on` of someone born on `birth`, or why there is none.
func AgeOn(birth: Date, on: Date) -> Age ! AgeError {
    if on.DaysSince(birth) < 0 {
        fail AgeError::BornLater;
    }

    // Counting the calendar months between the two gives the right answer, or one too many
    // when the day of the month has not come round yet. Stepping from `birth` rather than
    // from the previous month keeps the clamping from drifting: 31 January plus two months
    // is 31 March, not 28 March.
    var months = ((on.year - birth.year) as int64) * 12 + (on.month as int64)
        - (birth.month as int64);
    var reached = birth.PlusMonths(months) ?? fail AgeError::OutOfRange;
    if on.DaysSince(reached) < 0 {
        months -= 1;
        reached = birth.PlusMonths(months) ?? fail AgeError::OutOfRange;
    }
    return Age { years: months / 12, months: months % 12, days: on.DaysSince(reached) };
}

func Show(birthText: char8[..], onText: char8[..]) {
    let birth = ParseDate(birthText) catch {
        else => {
            PrintLine("{}  {}  {} is not a date", birthText, onText, birthText);
            return;
        }
    };
    let on = ParseDate(onText) catch {
        else => {
            PrintLine("{}  {}  {} is not a date", birthText, onText, onText);
            return;
        }
    };
    match AgeOn(birth, on) {
        .Success(age) => PrintLine("{}  {}  {:5} {:7} {:5}", birth, on,
            age.years, age.months, age.days),
        .Failure(AgeError::BornLater) => PrintLine("{}  {}  refused, born after that date",
            birth, on),
        .Failure(AgeError::OutOfRange) => PrintLine("{}  {}  outside the calendar", birth, on)
    }
}

func Main() -> int {
    PrintLine("born        on          years  months  days");

    // A birthday already past this year, one still to come, and the day itself.
    Show("1990-03-15", "2026-10-04");
    Show("1990-12-25", "2026-10-04");
    Show("2000-10-04", "2026-10-04");

    // The end of a month. 31 January reaches a whole month on 28 February, and the next on
    // 31 March, so 30 March is one month and 30 days.
    Show("2026-01-31", "2026-02-28");
    Show("2026-01-31", "2026-03-30");
    Show("2026-01-31", "2026-03-31");

    // A leap-day birthday falls on 28 February in an ordinary year, and on the 29th in a
    // leap year, which makes 28 February 2028 the day before it.
    Show("2004-02-29", "2025-02-28");
    Show("2004-02-29", "2028-02-28");
    Show("2004-02-29", "2028-02-29");

    // Dates the other way round, and a date that does not exist.
    Show("2026-10-04", "1990-03-15");
    Show("2023-02-29", "2026-10-04");
    return 0;
}