package pt.utl.ist.fenix.tools.util;

import java.io.Serializable;

import org.joda.time.Chronology;
import org.joda.time.DateTime;
import org.joda.time.DateTimeUtils;
import org.joda.time.Duration;
import org.joda.time.Interval;
import org.joda.time.MutableInterval;
import org.joda.time.Period;
import org.joda.time.PeriodType;
import org.joda.time.ReadableInstant;
import org.joda.time.ReadableInterval;
import org.joda.time.field.FieldUtils;
import org.joda.time.format.DateTimeFormatter;
import org.joda.time.format.ISODateTimeFormat;

/**
 * This class implements all the API of ReadableInterval but conveys the
 * possibility of being null ended. Most of the API behave exactly as the
 * ReadableInterval, some methods, namely: {@link #getEnd()}, {@link #getEndMillis()}, {@link #toInterval()},
 * {@link #toMutableInterval()}, {@link #toDuration()}, {@link #toDurationMillis()}, {@link #toPeriod()},
 * {@link #toPeriod(PeriodType)}, will throw an exception if they are null
 * ended.
 * 
 * @author Pedro Santos
 */
public class PossiblyNullEndedInterval implements Serializable {
    public static class OpenEndedIntervalEndInstantAccessAttempt extends RuntimeException {
        private static final long serialVersionUID = 6714455855595216145L;
    }

    private static final long NULL_END_INSTANT = -1;

    private static final long serialVersionUID = 9210575204515350017L;

    private final long startInstant;

    private final long endInstant;

    private final Chronology chronology;

    public PossiblyNullEndedInterval(long startInstant) {
        this.startInstant = startInstant;
        this.endInstant = NULL_END_INSTANT;
        this.chronology = null;
    }

    public PossiblyNullEndedInterval(long startInstant, long endInstant) {
        this.startInstant = startInstant;
        this.endInstant = endInstant;
        this.chronology = null;
    }

    public PossiblyNullEndedInterval(long startInstant, Chronology chronology) {
        this.startInstant = startInstant;
        this.endInstant = NULL_END_INSTANT;
        this.chronology = chronology;
    }

    public PossiblyNullEndedInterval(long startInstant, long endInstant, Chronology chronology) {
        this.startInstant = startInstant;
        this.endInstant = endInstant;
        this.chronology = chronology;
    }

    public Chronology getChronology() {
        return chronology;
    }

    public DateTime getStart() {
        return new DateTime(getStartMillis(), getChronology());
    }

    public long getStartMillis() {
        return startInstant;
    }

    public DateTime getEnd() {
        return new DateTime(getEndMillis(), getChronology());
    }

    public long getEndMillis() {
        if (endInstant == NULL_END_INSTANT) {
            throw new OpenEndedIntervalEndInstantAccessAttempt();
        }
        return endInstant;
    }

    public boolean contains(long millisInstant) {
        return millisInstant >= getStartMillis();
    }

    public boolean containsNow() {
        return contains(DateTimeUtils.currentTimeMillis());
    }

    public boolean contains(ReadableInstant instant) {
        if (instant == null) {
            return containsNow();
        }
        return contains(instant.getMillis());
    }

    public boolean contains(ReadableInterval interval) {
        if (interval == null) {
            return containsNow();
        }
        return contains(interval.getStartMillis());
    }

    public boolean contains(PossiblyNullEndedInterval interval) {
        if (interval == null) {
            return containsNow();
        }
        return contains(interval.getStartMillis());
    }

    public boolean overlaps(ReadableInterval interval) {
        if (interval == null) {
            return getStartMillis() < DateTimeUtils.currentTimeMillis();
        } else {
            return getStartMillis() < interval.getEndMillis();
        }
    }

    public boolean overlaps(PossiblyNullEndedInterval interval) {
        if (interval == null) {
            return getStartMillis() < DateTimeUtils.currentTimeMillis();
        } else {
            return getStartMillis() < interval.getEndMillis();
        }
    }

    public boolean isBefore(long millisInstant) {
        if (endInstant == NULL_END_INSTANT) {
            return false;
        }
        return (getEndMillis() <= millisInstant);
    }

    public boolean isBeforeNow() {
        return isBefore(DateTimeUtils.currentTimeMillis());
    }

    public boolean isBefore(ReadableInstant instant) {
        if (instant == null) {
            return isBeforeNow();
        }
        return isBefore(instant.getMillis());
    }

    public boolean isBefore(ReadableInterval interval) {
        if (interval == null) {
            return isBeforeNow();
        }
        return isBefore(interval.getStartMillis());
    }

    public boolean isBefore(PossiblyNullEndedInterval interval) {
        if (interval == null) {
            return isBeforeNow();
        }
        return isBefore(interval.getStartMillis());
    }

    public boolean isAfter(long millisInstant) {
        return (getStartMillis() > millisInstant);
    }

    public boolean isAfterNow() {
        return isAfter(DateTimeUtils.currentTimeMillis());
    }

    public boolean isAfter(ReadableInstant instant) {
        if (instant == null) {
            return isAfterNow();
        }
        return isAfter(instant.getMillis());
    }

    public boolean isAfter(ReadableInterval interval) {
        long endMillis;
        if (interval == null) {
            endMillis = DateTimeUtils.currentTimeMillis();
        } else {
            endMillis = interval.getEndMillis();
        }
        return (getStartMillis() >= endMillis);
    }

    public boolean isAfter(PossiblyNullEndedInterval interval) {
        long endMillis;
        if (interval == null) {
            endMillis = DateTimeUtils.currentTimeMillis();
        } else {
            endMillis = interval.getEndMillis();
        }
        if (endMillis == NULL_END_INSTANT) {
            return false;
        }
        return (getStartMillis() >= endMillis);
    }

    public Interval toInterval() {
        return new Interval(getStartMillis(), getEndMillis(), getChronology());
    }

    public MutableInterval toMutableInterval() {
        return new MutableInterval(getStartMillis(), getEndMillis(), getChronology());
    }

    public long toDurationMillis() {
        return FieldUtils.safeAdd(getEndMillis(), -getStartMillis());
    }

    public Duration toDuration() {
        long durMillis = toDurationMillis();
        if (durMillis == 0) {
            return Duration.ZERO;
        } else {
            return new Duration(durMillis);
        }
    }

    public Period toPeriod() {
        return new Period(getStartMillis(), getEndMillis(), getChronology());
    }

    public Period toPeriod(PeriodType type) {
        return new Period(getStartMillis(), getEndMillis(), type, getChronology());
    }

    @Override
    public boolean equals(Object readableInterval) {
        if (this == readableInterval) {
            return true;
        }
        if (!(readableInterval instanceof PossiblyNullEndedInterval)) {
            return false;
        }
        PossiblyNullEndedInterval other = (PossiblyNullEndedInterval) readableInterval;
        return startInstant == other.startInstant && endInstant == other.endInstant
                && FieldUtils.equals(getChronology(), other.getChronology());
    }

    @Override
    public int hashCode() {
        long start = startInstant;
        long end = endInstant;
        int result = 97;
        result = 31 * result + ((int) (start ^ (start >>> 32)));
        result = 31 * result + ((int) (end ^ (end >>> 32)));
        result = 31 * result + getChronology().hashCode();
        return result;
    }

    @Override
    public String toString() {
        DateTimeFormatter printer = ISODateTimeFormat.dateHourMinuteSecondFraction();
        printer = printer.withChronology(getChronology());
        StringBuffer buf = new StringBuffer(48);
        printer.printTo(buf, startInstant);
        buf.append('/');
        printer.printTo(buf, endInstant);
        return buf.toString();
    }
}