//import static main.DateStructures.*;

sclass EnglishDateParser > DateStructures {
  bool assumeFuture = true; // e.g. for "tuesday" [not used]

  SomeDate parse(S s) null {
    new ProbabilisticParser1 parser;

    // action that parses a number
    ProbabilisticParser1.Action number = parser.new Any {
      double calcProbabilityForMatchedText(S s) {
        //print("number? " + s);
        ret isInteger(s) ? 100 : 50;
      }
    };
    
    // action that parses a year
    ProbabilisticParser1.Action year = parser.new Any {
      double calcProbabilityForMatchedText(S s) {
        ret !isInteger(s) ? 50
          : between(parseInt(s), 1900, 2100) ? 100 : 75;
      }
    };

    LS tok = javaTok(s);

    // YMD rule
    parser.addState(tok, parser.ruleFromActions(
      year,
      parser.new ConsumeToken("/"),
      number,
      parser.new ConsumeToken("/"),
      number
    )).userObject = func(Matches m) -> SomeDate {
      new Day(parseInt($3), new Month(parseInt($2), new Year(parseInt($1))))
    };
    
    // year rule
    parser.addState(tok, parser.ruleFromActions(
      year
    )).userObject = func(Matches m) -> SomeDate {
      new Year(parseInt($1))
    };

    // weekday rule
    parser.addState(tok, parser.ruleFromActions(
      parser.new ConsumeOneOfTokens(asCISet(englishWeekdays())),
    )).userObject = func(Matches m) -> SomeDate {
      new Weekday(parseEnglishWeekday($1))
    };
    
    // "next <weekday>" rule
    parser.addState(tok, parser.ruleFromActions(
      parser.new ConsumeToken("next"),
      parser.new ConsumeOneOfTokens(asCISet(englishWeekdays())),
    )).userObject = func(Matches m) -> SomeDate {
      new Weekday(parseEnglishWeekday(print("day", $1)), new CurrentWeekPlus(1))
    };

    // "in <n> days"
    parser.addState(tok, parser.ruleFromActions(
      parser.new ConsumeToken("in"),
      number,
      parser.new ConsumeOneOfTokens("day", "days") 
    )).userObject = func(Matches m) -> SomeDate {
      new TodayPlus(parseInt($1))
    };

    // "<n> days from now"
    parser.addState(tok, parser.ruleFromActions(
      number,
      parser.new ConsumeOneOfTokens("day from now", "days from now"),
    )).userObject = func(Matches m) -> SomeDate {
      new TodayPlus(parseInt($1))
    };
    
    // month rule
    parser.addState(tok, parser.ruleFromActions(
      parser.new ConsumeOneOfTokens(asCISet(englishMonthNames())),
    )).userObject = func(Matches m) -> SomeDate {
      new Month(parseEnglishMonthName($1))
    };
    
    // combine month + year
    
    parser.think();
    ProbabilisticParser1.State state = parser.bestDoneState();
    print(state);
    if (state != null) {
      Matches m = parser.stateToMatches(state, action -> !action instanceof ProbabilisticParser1.ConsumeToken);
      print(m);
      ret (SomeDate) callF(state.userObject, m);
    }
  }
}