/*
 *******************************************************************************
 * Copyright (C) 2013-2014, International Business Machines Corporation and    *
 * others. All Rights Reserved.                                                *
 *******************************************************************************
 */
package com.ibm.icu.text;

import java.util.EnumMap;

import com.ibm.icu.impl.CalendarData;
import com.ibm.icu.impl.ICUCache;
import com.ibm.icu.impl.ICUResourceBundle;
import com.ibm.icu.impl.SimpleCache;
import com.ibm.icu.util.ULocale;
import com.ibm.icu.util.UResourceBundle;


/**
 * Formats simple relative dates. There are two types of relative dates that
 * it handles:
 * <ul>
 *   <li>relative dates with a quantity e.g "in 5 days"</li>
 *   <li>relative dates without a quantity e.g "next Tuesday"</li>
 * </ul>
 * <p>
 * This API is very basic and is intended to be a building block for more
 * fancy APIs. The caller tells it exactly what to display in a locale
 * independent way. While this class automatically provides the correct plural
 * forms, the grammatical form is otherwise as neutral as possible. It is the
 * caller's responsibility to handle cut-off logic such as deciding between
 * displaying "in 7 days" or "in 1 week." This API supports relative dates
 * involving one single unit. This API does not support relative dates
 * involving compound units.
 * e.g "in 5 days and 4 hours" nor does it support parsing.
 * This class is both immutable and thread-safe.
 * <p>
 * Here are some examples of use:
 * <blockquote>
 * <pre>
 * RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance();
 * fmt.format(1, Direction.NEXT, RelativeUnit.DAYS); // "in 1 day"
 * fmt.format(3, Direction.NEXT, RelativeUnit.DAYS); // "in 3 days"
 * fmt.format(3.2, Direction.LAST, RelativeUnit.YEARS); // "3.2 years ago"
 * 
 * fmt.format(Direction.LAST, AbsoluteUnit.SUNDAY); // "last Sunday"
 * fmt.format(Direction.THIS, AbsoluteUnit.SUNDAY); // "this Sunday"
 * fmt.format(Direction.NEXT, AbsoluteUnit.SUNDAY); // "next Sunday"
 * fmt.format(Direction.PLAIN, AbsoluteUnit.SUNDAY); // "Sunday"
 * 
 * fmt.format(Direction.LAST, AbsoluteUnit.DAY); // "yesterday"
 * fmt.format(Direction.THIS, AbsoluteUnit.DAY); // "today"
 * fmt.format(Direction.NEXT, AbsoluteUnit.DAY); // "tomorrow"
 * 
 * fmt.format(Direction.PLAIN, AbsoluteUnit.NOW); // "now"
 * </pre>
 * </blockquote>
 * <p>
 * In the future, we may add more forms, such as abbreviated/short forms
 * (3 secs ago), and relative day periods ("yesterday afternoon"), etc.
 * 
 * @draft ICU 53
 * @provisional This API might change or be removed in a future release.
 */
public final class RelativeDateTimeFormatter {
    
    /**
     * Represents the unit for formatting a relative date. e.g "in 5 days"
     * or "in 3 months"
     * @draft ICU 53
     * @provisional This API might change or be removed in a future release.
     */
    public static enum RelativeUnit {
        
        /**
         * Seconds
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        SECONDS,
        
        /**
         * Minutes
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        MINUTES,
        
       /**
        * Hours
        * @draft ICU 53
        * @provisional This API might change or be removed in a future release.
        */
        HOURS,
        
        /**
         * Days
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        DAYS,
        
        /**
         * Weeks
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        WEEKS,
        
        /**
         * Months
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        MONTHS,
        
        /**
         * Years
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        YEARS,
    }
    
    /**
     * Represents an absolute unit.
     * @draft ICU 53
     * @provisional This API might change or be removed in a future release.
     */
    public static enum AbsoluteUnit {
        
       /**
        * Sunday
        * @draft ICU 53
        * @provisional This API might change or be removed in a future release.
        */
        SUNDAY,
        
        /**
         * Monday
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        MONDAY,
        
        /**
         * Tuesday
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        TUESDAY,
        
        /**
         * Wednesday
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        WEDNESDAY,
        
        /**
         * Thursday
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        THURSDAY,
        
        /**
         * Friday
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        FRIDAY,
        
        /**
         * Saturday
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        SATURDAY,
        
        /**
         * Day
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        DAY,
        
        /**
         * Week
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        WEEK,
        
        /**
         * Month
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        MONTH,
        
        /**
         * Year
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        YEAR,
        
        /**
         * Now
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        NOW,
      }

      /**
       * Represents a direction for an absolute unit e.g "Next Tuesday"
       * or "Last Tuesday"
       * @draft ICU 53
       * @provisional This API might change or be removed in a future release.
       */
      public static enum Direction {
          
          /**
           * Two before. Not fully supported in every locale
           * @draft ICU 53
           * @provisional This API might change or be removed in a future release.
           */
          LAST_2,

          
          /**
           * Last
           * @draft ICU 53
           * @provisional This API might change or be removed in a future release.
           */  
        LAST,
        
        /**
         * This
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        THIS,
        
        /**
         * Next
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        NEXT,
        
        /**
         * Two after. Not fully supported in every locale
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        NEXT_2,
        
        /**
         * Plain, which means the absence of a qualifier
         * @draft ICU 53
         * @provisional This API might change or be removed in a future release.
         */
        PLAIN;
      }
    
    /**
     * Returns a RelativeDateTimeFormatter for the default locale.
     * @draft ICU 53
     * @provisional This API might change or be removed in a future release.
     */
    public static RelativeDateTimeFormatter getInstance() {
        return getInstance(ULocale.getDefault());
    }
    
    /**
     * Returns a RelativeDateTimeFormatter for a particular locale.
     * 
     * @param locale the locale.
     * @draft ICU 53
     * @provisional This API might change or be removed in a future release.
     */
    public static RelativeDateTimeFormatter getInstance(ULocale locale) {
        RelativeDateTimeFormatterData data = cache.get(locale);
        return new RelativeDateTimeFormatter(
                data.qualitativeUnitMap,
                data.quantitativeUnitMap,
                new MessageFormat(data.dateTimePattern),
                PluralRules.forLocale(locale),
                NumberFormat.getInstance(locale));
    }
    
    /**
     * Returns a RelativeDateTimeFormatter for a particular locale that uses a particular
     * NumberFormat object.
     * 
     * @param locale the locale
     * @param nf the number format object. It is defensively copied to ensure thread-safety
     * and immutability of this class. 
     * @draft ICU 53
     * @provisional This API might change or be removed in a future release.
     */
    public static RelativeDateTimeFormatter getInstance(ULocale locale, NumberFormat nf) {
        RelativeDateTimeFormatterData data = cache.get(locale);
        return new RelativeDateTimeFormatter(
                data.qualitativeUnitMap,
                data.quantitativeUnitMap,
                new MessageFormat(data.dateTimePattern),
                PluralRules.forLocale(locale),
                (NumberFormat) nf.clone());
    }
           
    /**
     * Formats a relative date with a quantity such as "in 5 days" or
     * "3 months ago"
     * @param quantity The numerical amount e.g 5. This value is formatted
     * according to this object's {@link NumberFormat} object.
     * @param direction NEXT means a future relative date; LAST means a past
     * relative date.
     * @param unit the unit e.g day? month? year?
     * @return the formatted string
     * @throws IllegalArgumentException if direction is something other than
     * NEXT or LAST.
     * @draft ICU 53
     * @provisional This API might change or be removed in a future release.
     */
    public String format(double quantity, Direction direction, RelativeUnit unit) {
        if (direction != Direction.LAST && direction != Direction.NEXT) {
            throw new IllegalArgumentException("direction must be NEXT or LAST");
        }
        // This class is thread-safe, yet numberFormat is not. To ensure thread-safety of this
        // class we must guarantee that only one thread at a time uses our numberFormat.
        synchronized (numberFormat) {
            return getQuantity(
                    unit, direction == Direction.NEXT).format(
                            quantity, numberFormat, pluralRules);
        }
    }
    
    /**
     * Formats a relative date without a quantity.
     * @param direction NEXT, LAST, THIS, etc.
     * @param unit e.g SATURDAY, DAY, MONTH
     * @return the formatted string. If direction has a value that is documented as not being
     *  fully supported in every locale (for example NEXT_2 or LAST_2) then this function may
     *  return null to signal that no formatted string is available.
     * @throws IllegalArgumentException if the direction is incompatible with
     * unit this can occur with NOW which can only take PLAIN.
     * @draft ICU 53
     * @provisional This API might change or be removed in a future release.
     */
    public String format(Direction direction, AbsoluteUnit unit) {
        if (unit == AbsoluteUnit.NOW && direction != Direction.PLAIN) {
            throw new IllegalArgumentException("NOW can only accept direction PLAIN.");
        }
        return this.qualitativeUnitMap.get(unit).get(direction);
    }

    /**
     * Combines a relative date string and a time string in this object's
     * locale. This is done with the same date-time separator used for the
     * default calendar in this locale.
     * @param relativeDateString the relative date e.g 'yesterday'
     * @param timeString the time e.g '3:45'
     * @return the date and time concatenated according to the default
     * calendar in this locale e.g 'yesterday, 3:45'
     * @draft ICU 53
     * @provisional This API might change or be removed in a future release.
     */
    public String combineDateAndTime(String relativeDateString, String timeString) {
        return this.combinedDateAndTime.format(
            new Object[]{timeString, relativeDateString}, new StringBuffer(), null).toString();
    }
    
    /**
     * Returns a copy of the NumberFormat this object is using.
     * 
     * @draft ICU 53
     * @provisional This API might change or be removed in a future release.
     */
    public NumberFormat getNumberFormat() {
        // This class is thread-safe, yet numberFormat is not. To ensure thread-safety of this
        // class we must guarantee that only one thread at a time uses our numberFormat.
        synchronized (numberFormat) {
            return (NumberFormat) numberFormat.clone();
        }
    }
    
    private static void addQualitativeUnit(
            EnumMap<AbsoluteUnit, EnumMap<Direction, String>> qualitativeUnits,
            AbsoluteUnit unit,
            String current) {
        EnumMap<Direction, String> unitStrings =
                new EnumMap<Direction, String>(Direction.class);
        unitStrings.put(Direction.PLAIN, current);
        qualitativeUnits.put(unit,  unitStrings);       
    }

    private static void addQualitativeUnit(
            EnumMap<AbsoluteUnit, EnumMap<Direction, String>> qualitativeUnits,
            AbsoluteUnit unit, ICUResourceBundle bundle, String plain) {
        EnumMap<Direction, String> unitStrings =
                new EnumMap<Direction, String>(Direction.class);
        unitStrings.put(Direction.LAST, bundle.getStringWithFallback("-1"));
        unitStrings.put(Direction.THIS, bundle.getStringWithFallback("0"));
        unitStrings.put(Direction.NEXT, bundle.getStringWithFallback("1"));
        addOptionalDirection(unitStrings, Direction.LAST_2, bundle, "-2");
        addOptionalDirection(unitStrings, Direction.NEXT_2, bundle, "2");
        unitStrings.put(Direction.PLAIN, plain);
        qualitativeUnits.put(unit,  unitStrings);
    }
 
    private static void addOptionalDirection(
            EnumMap<Direction, String> unitStrings,
            Direction direction,
            ICUResourceBundle bundle,
            String key) {
        bundle = bundle.findWithFallback(key);
        if (bundle != null) {
            unitStrings.put(direction, bundle.getString());
        }
    }

    private RelativeDateTimeFormatter(
            EnumMap<AbsoluteUnit, EnumMap<Direction, String>> qualitativeUnitMap,
            EnumMap<RelativeUnit, QuantityFormatter[]> quantitativeUnitMap,
            MessageFormat combinedDateAndTime,
            PluralRules pluralRules,
            NumberFormat numberFormat) {
        this.qualitativeUnitMap = qualitativeUnitMap;
        this.quantitativeUnitMap = quantitativeUnitMap;
        this.combinedDateAndTime = combinedDateAndTime;
        this.pluralRules = pluralRules;
        this.numberFormat = numberFormat;
    }
    
    private QuantityFormatter getQuantity(RelativeUnit unit, boolean isFuture) {
        QuantityFormatter[] quantities = quantitativeUnitMap.get(unit);
        return isFuture ? quantities[1] : quantities[0];
    }
    
    private final EnumMap<AbsoluteUnit, EnumMap<Direction, String>> qualitativeUnitMap;
    private final EnumMap<RelativeUnit, QuantityFormatter[]> quantitativeUnitMap;
    private final MessageFormat combinedDateAndTime;
    private final PluralRules pluralRules;
    private NumberFormat numberFormat;
    
    private static class RelativeDateTimeFormatterData {
        public RelativeDateTimeFormatterData(
                EnumMap<AbsoluteUnit, EnumMap<Direction, String>> qualitativeUnitMap,
                EnumMap<RelativeUnit, QuantityFormatter[]> quantitativeUnitMap,
                String dateTimePattern) {
            this.qualitativeUnitMap = qualitativeUnitMap;
            this.quantitativeUnitMap = quantitativeUnitMap;
            this.dateTimePattern = dateTimePattern;
        }
        
        public final EnumMap<AbsoluteUnit, EnumMap<Direction, String>> qualitativeUnitMap;
        public final EnumMap<RelativeUnit, QuantityFormatter[]> quantitativeUnitMap;
        public final String dateTimePattern;  // Example: "{1}, {0}"
    }
    
    private static class Cache {
        private final ICUCache<String, RelativeDateTimeFormatterData> cache =
            new SimpleCache<String, RelativeDateTimeFormatterData>();

        public RelativeDateTimeFormatterData get(ULocale locale) {
            String key = locale.toString();
            RelativeDateTimeFormatterData result = cache.get(key);
            if (result == null) {
                result = new Loader(locale).load();
                cache.put(key, result);
            }
            return result;
        }
    }
    
    private static class Loader {
        private final ULocale ulocale;
        
        public Loader(ULocale ulocale) {
            this.ulocale = ulocale;
        }

        public RelativeDateTimeFormatterData load() {
            EnumMap<AbsoluteUnit, EnumMap<Direction, String>> qualitativeUnitMap = 
                    new EnumMap<AbsoluteUnit, EnumMap<Direction, String>>(AbsoluteUnit.class);
            
            EnumMap<RelativeUnit, QuantityFormatter[]> quantitativeUnitMap =
                    new EnumMap<RelativeUnit, QuantityFormatter[]>(RelativeUnit.class);
                    
            ICUResourceBundle r = (ICUResourceBundle)UResourceBundle.
                    getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, ulocale);
            addTimeUnit(
                    r.getWithFallback("fields/day"),
                    RelativeUnit.DAYS,
                    AbsoluteUnit.DAY,
                    quantitativeUnitMap,
                    qualitativeUnitMap);
            addTimeUnit(
                    r.getWithFallback("fields/week"),
                    RelativeUnit.WEEKS,
                    AbsoluteUnit.WEEK,
                    quantitativeUnitMap,
                    qualitativeUnitMap);
            addTimeUnit(
                    r.getWithFallback("fields/month"),
                    RelativeUnit.MONTHS,
                    AbsoluteUnit.MONTH,
                    quantitativeUnitMap,
                    qualitativeUnitMap);
            addTimeUnit(
                    r.getWithFallback("fields/year"),
                    RelativeUnit.YEARS,
                    AbsoluteUnit.YEAR,
                    quantitativeUnitMap,
                    qualitativeUnitMap);
            addTimeUnit(
                    r.getWithFallback("fields/second"),
                    RelativeUnit.SECONDS,
                    quantitativeUnitMap);
            addTimeUnit(
                    r.getWithFallback("fields/minute"),
                    RelativeUnit.MINUTES,
                    quantitativeUnitMap);
            addTimeUnit(
                    r.getWithFallback("fields/hour"),
                    RelativeUnit.HOURS,
                    quantitativeUnitMap);
            addQualitativeUnit(
                    qualitativeUnitMap,
                    AbsoluteUnit.NOW,
                    r.getStringWithFallback("fields/second/relative/0"));
            
            EnumMap<AbsoluteUnit, String> dayOfWeekMap = readDaysOfWeek(
                r.getWithFallback("calendar/gregorian/dayNames/stand-alone/wide")
            );
            
            addWeekDay(
                    r.getWithFallback("fields/mon"),
                    dayOfWeekMap,
                    AbsoluteUnit.MONDAY,
                    qualitativeUnitMap);
            addWeekDay(
                    r.getWithFallback("fields/tue"),
                    dayOfWeekMap,
                    AbsoluteUnit.TUESDAY,
                    qualitativeUnitMap);
            addWeekDay(
                    r.getWithFallback("fields/wed"),
                    dayOfWeekMap,
                    AbsoluteUnit.WEDNESDAY,
                    qualitativeUnitMap);
            addWeekDay(
                    r.getWithFallback("fields/thu"),
                    dayOfWeekMap,
                    AbsoluteUnit.THURSDAY,
                    qualitativeUnitMap);
            addWeekDay(
                    r.getWithFallback("fields/fri"),
                    dayOfWeekMap,
                    AbsoluteUnit.FRIDAY,
                    qualitativeUnitMap);
            addWeekDay(
                    r.getWithFallback("fields/sat"),
                    dayOfWeekMap,
                    AbsoluteUnit.SATURDAY,
                    qualitativeUnitMap);
            addWeekDay(
                    r.getWithFallback("fields/sun"),
                    dayOfWeekMap,
                    AbsoluteUnit.SUNDAY,
                    qualitativeUnitMap);   
            CalendarData calData = new CalendarData(
                    ulocale, r.getStringWithFallback("calendar/default"));  
            return new RelativeDateTimeFormatterData(
                    qualitativeUnitMap, quantitativeUnitMap, calData.getDateTimePattern());
        }

        private void addTimeUnit(
                ICUResourceBundle timeUnitBundle,
                RelativeUnit relativeUnit,
                AbsoluteUnit absoluteUnit,
                EnumMap<RelativeUnit, QuantityFormatter[]> quantitativeUnitMap,
                EnumMap<AbsoluteUnit, EnumMap<Direction, String>> qualitativeUnitMap) {
            addTimeUnit(timeUnitBundle, relativeUnit, quantitativeUnitMap);
            String unitName = timeUnitBundle.getStringWithFallback("dn");
            // TODO(Travis Keep): This is a hack to get around CLDR bug 6818.
            if (ulocale.getLanguage().equals("en")) {
                unitName = unitName.toLowerCase();
            }
            timeUnitBundle = timeUnitBundle.getWithFallback("relative");
            addQualitativeUnit(
                    qualitativeUnitMap,
                    absoluteUnit,
                    timeUnitBundle,
                    unitName);
        }

        private static void addTimeUnit(
                ICUResourceBundle timeUnitBundle,
                RelativeUnit relativeUnit,
                EnumMap<RelativeUnit, QuantityFormatter[]> quantitativeUnitMap) {
            QuantityFormatter.Builder future = new QuantityFormatter.Builder();
            QuantityFormatter.Builder past = new QuantityFormatter.Builder();
            timeUnitBundle = timeUnitBundle.getWithFallback("relativeTime");
            addTimeUnit(
                    timeUnitBundle.getWithFallback("future"),
                    future);
            addTimeUnit(
                    timeUnitBundle.getWithFallback("past"),
                    past);
            quantitativeUnitMap.put(
                    relativeUnit, new QuantityFormatter[] { past.build(), future.build() });
        }

        private static void addTimeUnit(
                ICUResourceBundle pastOrFuture, QuantityFormatter.Builder builder) {
            int size = pastOrFuture.getSize();
            for (int i = 0; i < size; i++) {
                UResourceBundle r = pastOrFuture.get(i);
                builder.add(r.getKey(), r.getString());
            }
        }

        private static void addWeekDay(
                ICUResourceBundle weekdayBundle,
                EnumMap<AbsoluteUnit, String> dayOfWeekMap,
                AbsoluteUnit weekDay,
                EnumMap<AbsoluteUnit, EnumMap<Direction, String>> qualitativeUnitMap) {
            weekdayBundle = weekdayBundle.findWithFallback("relative");
            addQualitativeUnit(
                    qualitativeUnitMap,
                    weekDay,
                    weekdayBundle,
                    dayOfWeekMap.get(weekDay));
        }

        private static EnumMap<AbsoluteUnit, String> readDaysOfWeek(ICUResourceBundle daysOfWeekBundle) {
            EnumMap<AbsoluteUnit, String> dayOfWeekMap = new EnumMap<AbsoluteUnit, String>(AbsoluteUnit.class);
            if (daysOfWeekBundle.getSize() != 7) {
                throw new IllegalStateException(String.format("Expect 7 days in a week, got %d", daysOfWeekBundle.getSize()));
            }
            // Sunday always comes first in CLDR data.
            int idx = 0;
            dayOfWeekMap.put(AbsoluteUnit.SUNDAY, daysOfWeekBundle.getString(idx++));
            dayOfWeekMap.put(AbsoluteUnit.MONDAY, daysOfWeekBundle.getString(idx++));
            dayOfWeekMap.put(AbsoluteUnit.TUESDAY, daysOfWeekBundle.getString(idx++));
            dayOfWeekMap.put(AbsoluteUnit.WEDNESDAY, daysOfWeekBundle.getString(idx++));
            dayOfWeekMap.put(AbsoluteUnit.THURSDAY, daysOfWeekBundle.getString(idx++));
            dayOfWeekMap.put(AbsoluteUnit.FRIDAY, daysOfWeekBundle.getString(idx++));
            dayOfWeekMap.put(AbsoluteUnit.SATURDAY, daysOfWeekBundle.getString(idx++));
            return dayOfWeekMap;
        }
    }

    private static final Cache cache = new Cache();
}