package timeflow.data.time;

import java.util.*;

public class Interval
{

        public long start;
        public long end;

        public Interval(long start, long end)
        {
                this.start = start;
                this.end = end;
        }

        public Interval copy()
        {
                return new Interval(start, end);
        }

        public boolean contains(long x)
        {
                return x >= start && x <= end;
        }

        public boolean intersects(Interval x)
        {
                return intersects(x.start, x.end);
        }

        public boolean intersects(long start1, long end1)
        {
                return start1 <= end && end1 >= start;
        }

        public Interval subinterval(double startFraction, double endFraction)
        {
                return new Interval((long) (start + startFraction * length()),
                        (long) (start + endFraction * length()));
        }

        public void setTo(long start, long end)
        {
                this.start = start;
                this.end = end;
        }

        public void setTo(Interval t)
        {
                start = t.start;
                end = t.end;
        }

        public void include(long time)
        {
                start = Math.min(start, time);
                end = Math.max(end, time);
        }

        public void include(Interval t)
        {
                include(t.start);
                include(t.end);
        }

        public void expand(long amount)
        {
                start -= amount;
                end += amount;
        }

        public void add(long amount)
        {
                start += amount;
                end += amount;
        }

        public long length()
        {
                return end - start;
        }

        public void translateTo(long newStart)
        {
                add(newStart - start);
        }

        public Interval intersection(Interval i)
        {
                start = Math.max(i.start, start);
                end = Math.min(i.end, end);
                return this;
        }

        public void clampInside(Interval container)
        {
                if (length() > container.length())
                {
                        throw new IllegalArgumentException("Containing interval too small: " + container + " < " + this);
                }
                if (start >= container.start && end <= container.end)
                {
                        return;
                }
                add(Math.max(0, container.start - start));
                add(Math.min(0, container.end - end));
        }

        public String toString()
        {
                return "[Interval: From " + new Date(start) + " to " + new Date(end) + "]";
        }
}