package gw.solr.utils

uses com.guidewire.pl.system.dependency.PLDependencies
uses gw.api.util.Range
uses gw.api.util.UltraFastDateFormat

uses java.lang.Integer
uses java.lang.StringBuilder
uses java.lang.ThreadLocal
uses java.util.Calendar
uses java.util.Date
uses java.util.Locale
uses java.util.TimeZone


@ReadOnly
class PLSolrDateUtil {

  /*
   * Thread safe formatting and parsing expected by a Solr TrieDateField type.
   */
  public static final var SOLR_BASIC_DATE_FORMAT : String = "yyyy-MM-dd"
  public static final var TRIE_DATE_FORMAT : String = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"
  
  public static final var CANONICAL_TZ : TimeZone = TimeZone.getTimeZone("UTC")
  public static final var CANONICAL_LOCALE : Locale = Locale.US
    
  public static final var TRIE_DATE_FORMATTER : UltraFastDateFormat = 
      UltraFastDateFormat.getInstance(TRIE_DATE_FORMAT, CANONICAL_TZ, CANONICAL_LOCALE) 
  public static final var SIMPLE_DATE_FORMATTER : UltraFastDateFormat = 
      UltraFastDateFormat.getInstance(SOLR_BASIC_DATE_FORMAT, CANONICAL_TZ, CANONICAL_LOCALE) 
  
  static final var SPARE_CALENDAR = new ThreadLocal<Calendar>() {
    override function initialValue() : Calendar {
      return Calendar.getInstance()
    }
  }

  static var _enableTrieDates = true

  /**
   * Enable / Disable Solr TrieDate support (defaults to TRUE)
   * 
   * @param trieDateSupport true if using Solr TrieDates or false if using String dates
   */
  static function enableSolrTrieDateSupport( trieDateSupport : boolean ) {
    _enableTrieDates = trieDateSupport
  }

  /**
   * Format a date range as a solr date range query appropriate for either a solr string date
   * or trie date field, depending on how plugin is configured.
   * 
   * @param range date range to format
   *
   * @return Solr range query for the dates in question
   */
  static function formatDateRange( range : Range<Date> ) : String {
    var dateRangeStr = ""
    if(range != null) {
      if(_enableTrieDates) {
        dateRangeStr = formatTrieDateRangeImpl(range.Start, range.End)
      } else {
        dateRangeStr = formatStrDateRangeImpl(range.Start, range.End)
      }
    }
    return dateRangeStr
  }
  
  /**
   * Format a date range query argument for Solr "date as trie date" index field.  For
   * example, the range 1/14/2011-1/15/2012 would return 
   * 
   *   [2011-01-14T00:00:00Z TO 2012-01-15T23:59:59.999Z]
   * 
   * @param beginDate beginning of range
   * @param endDate end of range
   * 
   * @return Solr range query for the dates in question with the time component
   *   expanded to the entire beginning and end days.
   */
  static function formatDateRangeForTrieDateIndex( beginDate : Date, endDate : Date) : String {
    return formatTrieDateRangeImpl(beginDate, endDate)
  }

  /**
   * Format a date range query argument for Solr "date as string" index field.  For example, 
   * the range 1/14/2011-1/15/2012 would return 
   * 
   *   [2011-01-14 TO 2012-01-15]
   * 
   * If the begin and end dates are the same only a single date string (no range) is returned.
   * 
   * @param beginDate beginning of range
   * @param endDate end of range
   * 
   * @return Solr range query for the dates in question or a single date if the 
   *   days are the same
   */
  static function formatDateRangeForStringIndex( beginDate : Date, endDate : Date) : String {
    return formatStrDateRangeImpl(beginDate, endDate)
  }
  
  internal static function formatTrieDateRangeImpl( beginDate : Date, endDate : Date) : String {
    var sb = new StringBuilder(64)
    var cal = SPARE_CALENDAR.get()
    sb.append("[")
    if(beginDate != null) {
      cal.Time = beginDate
      cal.set(Calendar.HOUR_OF_DAY, 0)
      cal.set(Calendar.MINUTE, 0)
      cal.set(Calendar.SECOND, 0)
      cal.set(Calendar.MILLISECOND, 0)
      sb.append(TRIE_DATE_FORMATTER.format(cal.Time))
    } else {
      sb.append("*")
    }
    sb.append(" TO ")
    if(endDate != null) {
      cal.Time = endDate
      cal.set(Calendar.HOUR_OF_DAY, 23)
      cal.set(Calendar.MINUTE, 59)
      cal.set(Calendar.SECOND, 59)
      cal.set(Calendar.MILLISECOND, 999)
      sb.append(TRIE_DATE_FORMATTER.format(cal.Time))
    } else {
      sb.append("*")
    }
    sb.append("]")
    return sb.toString()
  }
  
  internal static function formatStrDateRangeImpl( beginDate : Date, endDate : Date) : String {
    var sb = new StringBuilder(32)
    if(beginDate != null && beginDate.equals(endDate)) {
      sb.append(SIMPLE_DATE_FORMATTER.format(beginDate))
    } else {
      sb.append("[")
      if(beginDate != null) {
        sb.append(SIMPLE_DATE_FORMATTER.format(beginDate))
      } else {
        sb.append("*")
      }
      sb.append(" TO ")
      if(endDate != null) {
        sb.append(SIMPLE_DATE_FORMATTER.format(endDate))
      } else {
        sb.append("*")
      }
      sb.append("]")
    }
    return sb.toString()
  }
  
  /**
   * Create a DBDateRange object from a DateRangeChoiceType type code
   * 
   * @param choice the DateRangeChoiceType to interpret
   * 
   * @return Range<Date> instance for the ChoiceType represented by the typecode
   */
  static function makeDateRangeFromDateRangeSelection( choice : DateRangeChoiceType ) : Range<Date> {
    var systemClock = PLDependencies.getSystemClock()
    var cal = Calendar.getInstance()
    cal.setTime(systemClock.DateTime)
    
    var isMinus = false
    var numDaysStr = choice.Code
    if(numDaysStr.startsWith("n")) {
      isMinus = true
      numDaysStr = numDaysStr.substring(1)
    }
    
    var numDays = Integer.parseInt(numDaysStr)
    if(isMinus) {
      numDays *= -1
    }
    if(numDays != 0) {
      cal.add(Calendar.DAY_OF_YEAR, numDays)
    }
    return Range<Date>.closed(cal.Time, systemClock.DateTime)
  }

}