package timeflow.data.time;

import java.util.*;
import java.text.*;

public class TimeUnit
{

        public static final TimeUnit YEAR = new TimeUnit("Years", Calendar.YEAR, 365 * 24 * 60 * 60 * 1000L, "yyyy", "yyyy");
        public static final TimeUnit MONTH = new TimeUnit("Months", Calendar.MONTH, 30 * 24 * 60 * 60 * 1000L, "MMM", "MMM yyyy");
        public static final TimeUnit WEEK = new TimeUnit("Weeks", Calendar.WEEK_OF_YEAR, 7 * 24 * 60 * 60 * 1000L, "d", "MMM d yyyy");
        public static final TimeUnit DAY = new TimeUnit("Days", Calendar.DAY_OF_MONTH, 24 * 60 * 60 * 1000L, "d", "MMM d yyyy");
        public static final TimeUnit DAY_OF_WEEK = new TimeUnit("Days", Calendar.DAY_OF_WEEK, 24 * 60 * 60 * 1000L, "d", "MMM d yyyy");
        public static final TimeUnit HOUR = new TimeUnit("Hours", Calendar.HOUR_OF_DAY, 60 * 60 * 1000L, "kk:mm", "MMM d yyyy kk:mm");
        public static final TimeUnit MINUTE = new TimeUnit("Minutes", Calendar.MINUTE, 60 * 1000L, ":mm", "MMM d yyyy kk:mm");
        public static final TimeUnit SECOND = new TimeUnit("Seconds", Calendar.SECOND, 1000L, ":ss", "MMM d yyyy kk:mm:ss");
        public static final TimeUnit DECADE = multipleYears(10);
        public static final TimeUnit CENTURY = multipleYears(100);
        private static final double DAY_SIZE = 24 * 60 * 60 * 1000L;
        private int quantity;
        private long roughSize;
        private SimpleDateFormat format, fullFormat;
        private String name;
        private int calendarCode;

        private TimeUnit()
        {
        }

        private TimeUnit(String name, int calendarCode, long roughSize, String formatPattern, String fullFormatPattern)
        {
                this.name = name;
                this.calendarCode = calendarCode;
                this.roughSize = roughSize;
                format = new SimpleDateFormat(formatPattern);
                fullFormat = new SimpleDateFormat(fullFormatPattern);
                quantity = 1;
        }

        public String toString()
        {
                return "[TimeUnit: " + name + "]";
        }

        public static TimeUnit multipleYears(int numYears)
        {
                TimeUnit t = new TimeUnit();
                t.name = numYears + " Years";
                t.calendarCode = Calendar.YEAR;
                t.roughSize = YEAR.roughSize * numYears;
                t.format = YEAR.format;
                t.fullFormat = YEAR.fullFormat;
                t.quantity = numYears;
                return t;
        }

        public static TimeUnit multipleWeeks(int num)
        {
                TimeUnit t = new TimeUnit();
                t.name = num + " Weeks";
                t.calendarCode = Calendar.WEEK_OF_YEAR;
                t.roughSize = WEEK.roughSize * num;
                t.format = WEEK.format;
                t.fullFormat = WEEK.fullFormat;
                t.quantity = num;
                return t;
        }

        public TimeUnit times(int quantity)
        {
                TimeUnit t = new TimeUnit();
                t.name = quantity + " " + this.name;
                t.calendarCode = this.calendarCode;
                t.roughSize = this.roughSize * quantity;
                t.format = this.format;
                t.fullFormat = this.fullFormat;
                t.quantity = quantity;
                return t;

        }

        public int numUnitsIn(TimeUnit u)
        {
                return (int) Math.round(u.getRoughSize() / (double) getRoughSize());
        }

        public boolean isDayOrLess()
        {
                return roughSize <= 24 * 60 * 60 * 1000L;
        }

        public RoughTime roundDown(long timestamp)
        {
                return round(timestamp, false);
        }

        public RoughTime roundUp(long timestamp)
        {
                return round(timestamp, true);
        }
        private static final int[] calendarUnits =
        {
                Calendar.SECOND, Calendar.MINUTE, Calendar.HOUR_OF_DAY, Calendar.DAY_OF_MONTH, Calendar.MONTH, Calendar.YEAR
        };

        public RoughTime round(long timestamp, boolean up)
        {
                Calendar c = TimeUtils.cal(timestamp);

                if (calendarCode == Calendar.WEEK_OF_YEAR)
                {
                        c.set(Calendar.DAY_OF_WEEK, c.getMinimum(Calendar.DAY_OF_WEEK));
                } else
                {

                        // set to minimum all fields of finer granularity.
                        int roundingCode = calendarCode;
                        if (calendarCode == Calendar.WEEK_OF_YEAR || calendarCode == Calendar.DAY_OF_WEEK)
                        {
                                roundingCode = Calendar.DAY_OF_MONTH;
                        }
                        for (int i = 0; i < calendarUnits.length; i++)
                        {
                                if (calendarUnits[i] == roundingCode)
                                {
                                        break;
                                }
                                if (i == calendarUnits.length - 1)
                                {
                                        throw new IllegalArgumentException("Unsupported Calendar Unit: " + calendarCode);
                                }
                                c.set(calendarUnits[i], c.getMinimum(calendarUnits[i]));
                        }
                        if (quantity > 1)
                        {
                                c.set(calendarCode, quantity * (c.get(calendarCode) / quantity));
                        }
                }

                // if rounding up, then add a unit at current granularity.
                if (up)
                {
                        c.add(calendarCode, quantity);
                }

                return new RoughTime(c.getTimeInMillis(), this);
        }

        public int get(long timestamp)
        {
                Calendar c = TimeUtils.cal(timestamp);
                int n = c.get(calendarCode);
                return quantity == 1 ? n : n % quantity;
        }

        public void addTo(RoughTime r)
        {
                addTo(r, 1);
        }

        public void addTo(RoughTime r, int times)
        {
                Calendar c = TimeUtils.cal(r.getTime());
                c.add(calendarCode, quantity * times);
                r.setTime(c.getTimeInMillis());
        }

        // Finding the difference between two dates, in a given unit of time,
        // is much subtler than you'd think! And annoyingly, the Calendar class does not do
        // this for you, even though it actually "knows" how to do so since it
        // can add fields.
        //
        // The most vexing problem is dealing with daylight savings time,
        // which means that one day a year has 23 hours and one day has 25 hours.
        // We also have to handle the fact that months and years aren't constant lengths.
        //
        // Rather than write all this ourselves, in this code we
        // use the Calendar class to do the heavy lifting.
        public long difference(long x, long y)
        {
                // If this is not one of the hard cases,
                // just divide the timespan by the length of time unit.
                // Note that we're not worrying about hours and daylight savings time.
                if (calendarCode != Calendar.YEAR && calendarCode != Calendar.MONTH
                        && calendarCode != Calendar.DAY_OF_MONTH && calendarCode != Calendar.DAY_OF_WEEK
                        && calendarCode != Calendar.WEEK_OF_YEAR)
                {
                        return (x - y) / roughSize;
                }

                Calendar c1 = TimeUtils.cal(x), c2 = TimeUtils.cal(y);
                int diff = 0;
                switch (calendarCode)
                {
                        case Calendar.YEAR:
                                return (c1.get(Calendar.YEAR) - c2.get(Calendar.YEAR)) / quantity;

                        case Calendar.MONTH:
                                diff = 12 * (c1.get(Calendar.YEAR) - c2.get(Calendar.YEAR))
                                        + c1.get(Calendar.MONTH) - c2.get(Calendar.MONTH);
                                return diff / quantity;

                        case Calendar.DAY_OF_MONTH:
                        case Calendar.DAY_OF_WEEK:
                        case Calendar.DAY_OF_YEAR:
                        case Calendar.WEEK_OF_MONTH:
                        case Calendar.WEEK_OF_YEAR:
                                // This is ugly, but believe me, it beats the alternative methods :-)
                                // We use the Calendar class's knowledge of daylight savings time.
                                // and also the fact that if we calculate this naively, then we aren't going
                                // to be off by more than one in either direction.
                                int naive = (int) Math.round((x - y) / (double) roughSize);
                                c2.add(calendarCode, naive * quantity);
                                if (c1.get(calendarCode) == c2.get(calendarCode))
                                {
                                        return naive / quantity;
                                }
                                c2.add(calendarCode, quantity);
                                if (c1.get(calendarCode) == c2.get(calendarCode))
                                {
                                        return naive / quantity + 1;
                                }
                                return naive / quantity - 1;
                }
                throw new IllegalArgumentException("Unexpected calendar code: " + calendarCode);
        }

        public long approxNumInRange(long start, long end)
        {
                return 1 + (end - start) / roughSize;
        }

        public long getRoughSize()
        {
                return roughSize;
        }

        public String format(Date date)
        {
                return format.format(date);
        }

        public String formatFull(Date date)
        {
                return fullFormat.format(date);
        }

        public String formatFull(long timestamp)
        {
                return fullFormat.format(new Date(timestamp));
        }

        public String getName()
        {
                return name;
        }
}