enum CronFieldType {

SECOND(0, 59, null),

MINUTE(0, 59, null),

HOUR(0, 23, null),

DAY_OF_MONTH(1, 31, null),

MONTH(1, 12, Arrays.asList("JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC")),

DAY_OF_WEEK(1, 7, Arrays.asList("MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN"));

final int from, to;

final List<String> names;

CronFieldType(int from, int to, List<String> names) {

this.from = from;

this.to = to;

this.names = names;

}

}

private final String expr;

private final SimpleField secondField;

private final SimpleField minuteField;

private final SimpleField hourField;

private final DayOfWeekField dayOfWeekField;

private final SimpleField monthField;

private final DayOfMonthField dayOfMonthField;

public CronExpression(final String expr) {

this(expr, true);

}

public CronExpression(final String expr, final boolean withSeconds) {

if (expr == null) {

throw new IllegalArgumentException("expr is null"); //$NON-NLS-1$

}

this.expr = expr;

final int expectedParts = withSeconds ? 6 : 5;

final String[] parts = expr.split("\\s+"); //$NON-NLS-1$

if (parts.length != expectedParts) {

throw new IllegalArgumentException(String.format("Invalid cron expression [%s], expected %s felt, got %s"

, expr, expectedParts, parts.length));

}

int ix = withSeconds ? 1 : 0;

this.secondField = new SimpleField(CronFieldType.SECOND, withSeconds ? parts[0] : "0");

this.minuteField = new SimpleField(CronFieldType.MINUTE, parts[ix++]);

this.hourField = new SimpleField(CronFieldType.HOUR, parts[ix++]);

this.dayOfMonthField = new DayOfMonthField(parts[ix++]);

this.monthField = new SimpleField(CronFieldType.MONTH, parts[ix++]);

this.dayOfWeekField = new DayOfWeekField(parts[ix++]);

}

public static CronExpression create(final String expr) {

return new CronExpression(expr, true);

}

public static CronExpression createWithoutSeconds(final String expr) {

return new CronExpression(expr, false);

}

public DateTime nextTimeAfter(DateTime afterTime) {

// will search for the next time within the next 4 years. If there is no

// time matching, an InvalidArgumentException will be thrown (it is very

// likely that the cron expression is invalid, like the February 30th).

return nextTimeAfter(afterTime, afterTime.plusYears(4));

}

public DateTime nextTimeAfter(DateTime afterTime, long durationInMillis) {

// will search for the next time within the next durationInMillis

// millisecond. Be aware that the duration is specified in millis,

// but in fact the limit is checked on a day-to-day basis.

return nextTimeAfter(afterTime, afterTime.plus(durationInMillis));

}

public DateTime nextTimeAfter(DateTime afterTime, DateTime dateTimeBarrier) {

MutableDateTime nextTime = new MutableDateTime(afterTime);

nextTime.setMillisOfSecond(0);

nextTime.secondOfDay().add(1);

while (true) { // day of week

while (true) { // month

while (true) { // day of month

while (true) { // hour

while (true) { // minute

while (true) { // second

if (secondField.matches(nextTime.getSecondOfMinute())) {

break;

}

nextTime.secondOfDay().add(1);

}

if (minuteField.matches(nextTime.getMinuteOfHour())) {

break;

}

nextTime.minuteOfDay().add(1);

nextTime.secondOfMinute().set(0);

}

if (hourField.matches(nextTime.getHourOfDay())) {

break;

}

nextTime.hourOfDay().add(1);

nextTime.minuteOfHour().set(0);

nextTime.secondOfMinute().set(0);

}

if (dayOfMonthField.matches(new LocalDate(nextTime))) {

break;

}

nextTime.addDays(1);

nextTime.setTime(0, 0, 0, 0);

checkIfDateTimeBarrierIsReached(nextTime, dateTimeBarrier);

}

if (monthField.matches(nextTime.getMonthOfYear())) {

break;

}

nextTime.addMonths(1);

nextTime.setDayOfMonth(1);

nextTime.setTime(0, 0, 0, 0);

checkIfDateTimeBarrierIsReached(nextTime, dateTimeBarrier);

}

if (dayOfWeekField.matches(new LocalDate(nextTime))) {

break;

}

nextTime.addDays(1);

nextTime.setTime(0, 0, 0, 0);

checkIfDateTimeBarrierIsReached(nextTime, dateTimeBarrier);

}

return nextTime.toDateTime();

}

private static void checkIfDateTimeBarrierIsReached(MutableDateTime nextTime, DateTime dateTimeBarrier) {

if (nextTime.isAfter(dateTimeBarrier)) {

throw new IllegalArgumentException("No next execution time could be determined that is before the limit of " + dateTimeBarrier);

}

}

@Override

public String toString() {

return getClass().getSimpleName() + "<" + expr + ">";

}

static class FieldPart {

private Integer from, to, increment;

private String modifier, incrementModifier;

}

abstract static class BasicField {

private static final Pattern CRON_FELT_REGEXP = Pattern

.compile("(?: # start of group 1\n"

+ " (?:(?<all>\\*)|(?<ignorer>\\?)|(?<last>L)) # globalt flag (L, ?, *)\n"

+ " | (?<start>[0-9]{1,2}|[a-z]{3,3}) # or start number or symbol\n"

+ " (?: # start of group 2\n"

+ " (?<mod>L|W) # modifier (L,W)\n"

+ " | -(?<end>[0-9]{1,2}|[a-z]{3,3}) # or end nummer or symbol (in range)\n"

+ " )? # end of group 2\n"

+ ") # end of group 1\n"

+ "(?:(?<inkmod>/|\\#)(?<ink>[0-9]{1,7}))? # increment and increment modifier (/ or \\#)\n"

, Pattern.CASE_INSENSITIVE | Pattern.COMMENTS);

final CronFieldType fieldType;

final List<FieldPart> parts = new ArrayList<FieldPart>();

private BasicField(CronFieldType fieldType, String fieldExpr) {

this.fieldType = fieldType;

parse(fieldExpr);

}

private void parse(String fieldExpr) { // NOSONAR

String[] rangeParts = fieldExpr.split(",");

for (String rangePart : rangeParts) {

Matcher m = CRON_FELT_REGEXP.matcher(rangePart);

if (!m.matches()) {

throw new IllegalArgumentException("Invalid cron field '" + rangePart + "' for field [" + fieldType + "]");

}

String startNummer = m.group("start");

String modifier = m.group("mod");

String sluttNummer = m.group("end");

String inkrementModifier = m.group("inkmod");

String inkrement = m.group("ink");

FieldPart part = new FieldPart();

part.increment = 999;

if (startNummer != null) {

part.from = mapValue(startNummer);

part.modifier = modifier;

if (sluttNummer != null) {

part.to = mapValue(sluttNummer);

part.increment = 1;

} else if (inkrement != null) {

part.to = fieldType.to;

} else {

part.to = part.from;

}

} else if (m.group("all") != null) {

part.from = fieldType.from;

part.to = fieldType.to;

part.increment = 1;

} else if (m.group("ignorer") != null) {

part.modifier = m.group("ignorer");

} else if (m.group("last") != null) {

part.modifier = m.group("last");

} else {

throw new IllegalArgumentException("Invalid cron part: " + rangePart);

}

if (inkrement != null) {

part.incrementModifier = inkrementModifier;

part.increment = Integer.valueOf(inkrement);

}

validateRange(part);

validatePart(part);

parts.add(part);

}

}

protected void validatePart(FieldPart part) {

if (part.modifier != null) {

throw new IllegalArgumentException(String.format("Invalid modifier [%s]", part.modifier));

} else if (part.incrementModifier != null && !"/".equals(part.incrementModifier)) {

throw new IllegalArgumentException(String.format("Invalid increment modifier [%s]", part.incrementModifier));

}

}

private void validateRange(FieldPart part) {

if ((part.from != null && part.from < fieldType.from) || (part.to != null && part.to > fieldType.to)) {

throw new IllegalArgumentException(String.format("Invalid interval [%s-%s], must be %s<=_<=%s", part.from, part.to, fieldType.from,

fieldType.to));

} else if (part.from != null && part.to != null && part.from > part.to) {

throw new IllegalArgumentException(

String.format(

"Invalid interval [%s-%s]. Rolling periods are not supported (ex. 5-1, only 1-5) since this won't give a deterministic result. Must be %s<=_<=%s",

part.from, part.to, fieldType.from, fieldType.to));

}

}

protected Integer mapValue(String value) {

Integer idx;

if (fieldType.names != null && (idx = fieldType.names.indexOf(value.toUpperCase(Locale.getDefault()))) >= 0) {

return idx + 1;

}

return Integer.valueOf(value);

}

protected boolean matches(int val, FieldPart part) {

if (val >= part.from && val <= part.to && (val - part.from) % part.increment == 0) {

return true;

}

return false;

}

}

static class SimpleField extends BasicField {

SimpleField(CronFieldType fieldType, String fieldExpr) {

super(fieldType, fieldExpr);

}

public boolean matches(int val) {

if (val >= fieldType.from && val <= fieldType.to) {

for (FieldPart part : parts) {

if (matches(val, part)) {

return true;

}

}

}

return false;

}

}

static class DayOfWeekField extends BasicField {

DayOfWeekField(String fieldExpr) {

super(CronFieldType.DAY_OF_WEEK, fieldExpr);

}

boolean matches(LocalDate dato) {

for (FieldPart part : parts) {

if ("L".equals(part.modifier)) {

return dato.getDayOfWeek() == part.from && dato.getDayOfMonth() > (dato.dayOfMonth().getMaximumValue() - DAYS_PER_WEEK);

} else if ("#".equals(part.incrementModifier)) {

if (dato.getDayOfWeek() == part.from) {

int num = dato.getDayOfMonth() / 7;

return part.increment == (dato.getDayOfMonth() % 7 == 0 ? num : num + 1);

}

return false;

} else if (matches(dato.getDayOfWeek(), part)) {

return true;

}

}

return false;

}

@Override

protected Integer mapValue(String value) {

// Use 1-7 for weedays, but 0 will also represent sunday (linux practice)

return "0".equals(value) ? Integer.valueOf(7) : super.mapValue(value);

}

@Override

protected boolean matches(int val, FieldPart part) {

return "?".equals(part.modifier) || super.matches(val, part);

}

@Override

protected void validatePart(FieldPart part) {

if (part.modifier != null && Arrays.asList("L", "?").indexOf(part.modifier) == -1) {

throw new IllegalArgumentException(String.format("Invalid modifier [%s]", part.modifier));

} else if (part.incrementModifier != null && Arrays.asList("/", "#").indexOf(part.incrementModifier) == -1) {

throw new IllegalArgumentException(String.format("Invalid increment modifier [%s]", part.incrementModifier));

}

}

}

static class DayOfMonthField extends BasicField {

DayOfMonthField(String fieldExpr) {

super(CronFieldType.DAY_OF_MONTH, fieldExpr);

}

boolean matches(LocalDate dato) {

for (FieldPart part : parts) {

if ("L".equals(part.modifier)) {

return dato.getDayOfMonth() == (dato.dayOfMonth().getMaximumValue() - (part.from == null ? 0 : part.from));

} else if ("W".equals(part.modifier)) {

if (dato.getDayOfWeek() <= 5) {

if (dato.getDayOfMonth() == part.from) {

return true;

} else if (dato.getDayOfWeek() == 5) {

return dato.plusDays(1).getDayOfMonth() == part.from;

} else if (dato.getDayOfWeek() == 1) {

return dato.minusDays(1).getDayOfMonth() == part.from;

}

}

} else if (matches(dato.getDayOfMonth(), part)) {

return true;

}

}

return false;

}

@Override

protected void validatePart(FieldPart part) {

if (part.modifier != null && Arrays.asList("L", "W", "?").indexOf(part.modifier) == -1) {

throw new IllegalArgumentException(String.format("Invalid modifier [%s]", part.modifier));

} else if (part.incrementModifier != null && !"/".equals(part.incrementModifier)) {

throw new IllegalArgumentException(String.format("Invalid increment modifier [%s]", part.incrementModifier));

}

}

@Override

protected boolean matches(int val, FieldPart part) {

return "?".equals(part.modifier) || super.matches(val, part);

}

}