/*
    * Redistribution and use of this software and associated documentation ("Software"), with or
    * without modification, are permitted provided that the following conditions are met:
    *
    * 1. Redistributions of source code must retain copyright statements and notices. Redistributions
    * must also contain a copy of this document.
    *
    * 2. Redistributions in binary form must reproduce the above copyright notice, this list of
    * conditions and the following disclaimer in the documentation and/or other materials provided with
   * the distribution.
   *
   * 3. The name "Exolab" must not be used to endorse or promote products derived from this Software
   * without prior written permission of Intalio, Inc. For written permission, please contact
   * info@exolab.org.
   *
   * 4. Products derived from this Software may not be called "Exolab" nor may "Exolab" appear in
   * their names without prior written permission of Intalio, Inc. Exolab is a registered trademark of
   * Intalio, Inc.
   *
   * 5. Due credit should be given to the Exolab Project (http://www.exolab.org/).
   *
   * THIS SOFTWARE IS PROVIDED BY INTALIO, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESSED OR
   * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTALIO, INC. OR ITS
   * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
   * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   *
   * Copyright 2001 (C) Intalio, Inc. All Rights Reserved.
   *
   * $Id$ Date Author Changes 07/04/2002 Arnaud Support for milliseconds 04/18/2002 Arnaud String
   * constructor 05/22/2000 Arnaud Blandin Created
   */
  package org.exolab.castor.types;
  
  import java.text.ParseException;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /**
   * This class is the representation of XML Schema datatype: <b>duration</b>.
   * <p>
   * This representation does not support the decimal fraction for the lowest order item.
   * <p>
   * The order relation provided by this implementation does not follow the guidelines of XML Schema
   * Specification that defines only a partial order.
   * <p>
   * For more information see <a href="http://www.w3.org/TR/xmlschema-2/#duration"> X3C XML Schema
   * Specification</a>.
   *
   * @author <a href="mailto:blandin@intalio.com">Arnaud Blandin</a>
   * @author <a href="mailto:edward.kuns@aspect.com">Edward Kuns</a>
   * @version $Revision$ $Date: 2006-04-25 15:08:23 -0600 (Tue, 25 Apr 2006) $
   */
  public class Duration implements java.io.Serializable {
    /** SerialVersionUID. */
    private static final long serialVersionUID = -6475091654291323029L;
    /** Jakarta's common-logging logger. */
    private static final Log LOG = LogFactory.getLog(Duration.class);
  
    /** Set to true and recompile to include debugging code in class. */
    private static final boolean DEBUG = false;
    /** the flag representing the 'T' position. */
    private static final int TIME_FLAG = 8;
  
    /** the number of years. */
    private short _year = 0;
    /** the number of months. */
    private short _month = 0;
    /** the number of days. */
    private short _day = 0;
    /** the number of hours. */
    private short _hour = 0;
    /** the number of minutes. */
    private short _minute = 0;
    /** the number of seconds. */
    private short _second = 0;
    /** the potential number of milliseconds. */
    private long _millisecond = 0;
    /** true if the Duration is negative. */
    private boolean _isNegative = false;
  
    /**
     * default constructor.
     */
    public Duration() {
      // Nothing to do
    }
  
    /**
     * Constructs a duration from a string.
     * 
     * @param duration the string representation of the duration to create
     * @throws ParseException thrown when the string is not a valid duration
     */
    public Duration(String duration) throws ParseException {
     parseDurationInternal(duration, this);
   }
 
   /**
    * This constructor fills in the duration fields according to the value of the long by calling
    * setValue.
    *
    * @see #setValue
    * @param l the long value of the Duration
    */
   public Duration(long l) {
     long refSecond = 1000;
     long refMinute = 60 * refSecond;
     long refHour = 60 * refMinute;
     long refDay = 24 * refHour;
     long refMonth = (long) (30.42 * refDay);
     long refYear = 12 * refMonth;
 
     if (DEBUG) {
       System.out.println("In time duration Constructor");
       System.out.println("long : " + l);
     }
 
     if (l < 0) {
       this.setNegative();
       l = -l;
     }
 
     short year = (short) (l / refYear);
     l = l % refYear;
     if (DEBUG) {
       System.out.println("nb years:" + year);
       System.out.println("New long : " + l);
     }
 
     short month = (short) (l / refMonth);
     l = l % refMonth;
     if (DEBUG) {
       System.out.println("nb months:" + month);
       System.out.println("New long : " + l);
       System.out.println(refDay);
     }
 
     short day = (short) (l / refDay);
     l = l % refDay;
     if (DEBUG) {
       System.out.println("nb days:" + day);
       System.out.println("New long : " + l);
     }
 
     short hour = (short) (l / refHour);
     l = l % refHour;
     if (DEBUG) {
       System.out.println("nb hours:" + hour);
       System.out.println("New long : " + l);
     }
 
     short minute = (short) (l / refMinute);
     l = l % refMinute;
     if (DEBUG) {
       System.out.println("nb minutes:" + minute);
       System.out.println("New long : " + l);
     }
 
     short seconds = (short) (l / refSecond);
     l = l % refSecond;
     if (DEBUG) {
       System.out.println("nb seconds:" + seconds);
     }
 
     long milliseconds = l;
     if (DEBUG) {
       System.out.println("nb milliseconds:" + milliseconds);
     }
 
     this.setValue(year, month, day, hour, minute, seconds, milliseconds);
   }
 
   // Set methods
 
   public void setYear(short year) {
     if (year < 0) {
       String err = "In a duration all fields have to be positive.";
       throw new IllegalArgumentException(err);
     }
     _year = year;
   }
 
   public void setMonth(short month) {
     if (month < 0) {
       String err = "In a duration all fields have to be positive.";
       throw new IllegalArgumentException(err);
     }
     _month = month;
   }
 
   public void setDay(short day) {
     if (day < 0) {
       String err = "In a duration all fields have to be positive.";
       throw new IllegalArgumentException(err);
     }
     _day = day;
   }
 
   public void setHour(short hour) {
     if (hour < 0) {
       String err = "In a duration all fields have to be positive.";
       throw new IllegalArgumentException(err);
     }
     _hour = hour;
   }
 
   public void setMinute(short minute) {
     if (minute < 0) {
       String err = "In a duration all fields have to be positive.";
       throw new IllegalArgumentException(err);
     }
     _minute = minute;
   }
 
   public void setSeconds(short second) {
     if (second < 0) {
       String err = "In a duration all fields have to be positive.";
       throw new IllegalArgumentException(err);
     }
     _second = second;
   }
 
   public void setMilli(long milli) {
     if (milli < 0) {
       String err = "In a duration all fields have to be positive.";
       throw new IllegalArgumentException(err);
     }
     _millisecond = milli;
   }
 
   public void setNegative() {
     _isNegative = true;
   }
 
   /**
    * Fill in the fields of the duration with the given values
    * 
    * @param year the year value
    * @param month the month value
    * @param day the day value
    * @param hour the hour value
    * @param minute the minute value
    * @param second the second value
    * @param millisecond the second value
    */
   public void setValue(short year, short month, short day, short hour, short minute, short second,
       long millisecond) {
     this.setYear(year);
     this.setMonth(month);
     this.setDay(day);
     this.setHour(hour);
     this.setMinute(minute);
     this.setSeconds(second);
     this.setMilli(millisecond);
   }
 
   // Get methods
 
   public short getYear() {
     return _year;
   }
 
   public short getMonth() {
     return _month;
   }
 
   public short getDay() {
     return _day;
   }
 
   public short getHour() {
     return _hour;
   }
 
   public short getMinute() {
     return _minute;
   }
 
   public short getSeconds() {
     return _second;
   }
 
   public long getMilli() {
     return _millisecond;
   }
 
   public boolean isNegative() {
     return _isNegative;
   }
 
   /**
    * <p>
    * Convert a duration into a long This long represents the duration in milliseconds.
    * 
    * @return a long representing the duration
    */
   public long toLong() {
     long result = 0;
 
     // 30.42 days in a month (365/12) (Horner method)
     result =
         (long) (((((((_year * 12L) + _month) * 30.42 + _day) * 24L + _hour) * 60L + _minute) * 60L
             + _second) * 1000L + _millisecond);
 
     result = isNegative() ? -result : result;
     return result;
   }
 
   /**
    * Convert a duration into a String conforming to ISO8601 and
    * <a href="http://www.w3.org/TR/xmlschema-2/#duration"> XML Schema specs </a>
    *
    * @return a string representing the duration
    */
   public String toString() {
     // if the duration is empty, we choose as a standard to return "PTOS"
     if (this.toLong() == 0) {
       return "PT0S";
     }
 
     StringBuilder result = new StringBuilder();
     if (_isNegative) {
       result.append('-');
     }
     result.append('P');
 
     if (_year != 0) {
       result.append(_year).append('Y');
     }
 
     if (_month != 0) {
       result.append(_month).append('M');
     }
 
     if (_day != 0) {
       result.append(_day).append('D');
     }
 
     boolean isThereTime = _hour != 0 || _minute != 0 || _second != 0 || _millisecond != 0;
     if (isThereTime) {
       result.append('T');
 
       if (_hour != 0) {
         result.append(_hour).append('H');
       }
 
       if (_minute != 0) {
         result.append(_minute).append('M');
       }
 
       if (_second != 0 || _millisecond != 0) {
         result.append(_second);
         if (_millisecond != 0) {
           result.append('.');
           if (_millisecond < 100) {
             result.append('0');
             if (_millisecond < 10)
               result.append('0');
           }
           result.append(_millisecond);
         }
         result.append('S');
       }
     }
 
     return result.toString();
   } // toString
 
   /**
    * parse a String and convert it into a java.lang.Object
    * 
    * @param str the string to parse
    * @return the java.lang.Object represented by the string
    * @throws ParseException a parse exception is thrown if the string to parse does not follow the
    *         rigth format (see the description of this class)
    */
   public static Object parse(String str) throws ParseException {
     return parseDuration(str);
   }
 
   /**
    * <p>
    * Parse the given string and return a time duration which represents this string.
    * 
    * @param str the string to parse
    * @return a TimeDuration instance which represent the string
    * @throws ParseException thrown when the string is not valid
    */
   public static Duration parseDuration(String str) throws ParseException {
     Duration result = new Duration();
     return parseDurationInternal(str, result);
   }
 
   private static Duration parseDurationInternal(String str, Duration result) throws ParseException {
     boolean isMilli = false;
     if (str == null) {
       throw new IllegalArgumentException("the string to be parsed must not be null");
     }
 
     // str = "" means a null TimeDuration
     if (str.length() == 0) {
       return null;
     }
 
     if (result == null) {
       result = new Duration();
     }
 
     char[] chars = str.toCharArray();
     int idx = 0;
 
     if (chars[idx] == '-') {
       ++idx;
       result.setNegative();
       if (idx >= chars.length) {
         throw new ParseException("'-' is wrongly placed", 0);
       }
     }
 
     // -- make sure we start with 'P'
     if (chars[idx] != 'P') {
       throw new ParseException("Missing 'P' delimiter", idx);
     }
     ++idx;
 
     if (idx == chars.length) {
       throw new ParseException("Bad format for a duration:" + str, idx);
     }
     int number = 0;
     boolean hasNumber = false;
 
     // -- parse flags
     // YMDTHMS = b1111111 (127)
     // Year = 64, Month = 32, etc
     int flags = 0;
 
     while (idx < chars.length) {
 
       char ch = chars[idx++];
 
       switch (ch) {
 
         // -- Year
         case 'Y':
           // -- check for error
           if (flags > 0) {
             String err = str + ":Syntax error, 'Y' must proceed all other delimiters.";
             throw new ParseException(err, idx);
           }
           // --set flags
           flags = 64;
           if (hasNumber) {
             result.setYear((short) number);
             hasNumber = false;
           } else {
             String err = str + ":missing number of years before 'Y'";
             throw new ParseException(err, idx);
           }
 
           break;
         // -- Month or Minute
         case 'M':
           // -- Either month or minute, check for T flag,
           // -- if present then Minute, otherwise Month
           if ((flags & TIME_FLAG) == 8) {
 
             // make sure no existing minute or second
             // flags have been set.
             if ((flags & 3) > 0) {
               throw new ParseException(str + ": Syntax Error...", idx);
             }
             flags = flags | 2;
             if (hasNumber) {
               result.setMinute((short) number);
               hasNumber = false;
             } else {
               String err = str + ": missing number of minutes before 'M'";
               throw new ParseException(err, idx);
             }
           }
           // -- Month
           else {
             // make sure no existing month, day or time
             // flags have been set
             if ((flags & 63) > 0) {
               throw new ParseException(str + ":Syntax Error...", idx);
             }
             flags = flags | 32;
             if (hasNumber) {
               result.setMonth((short) number);
               hasNumber = false;
             } else {
               String err = str + ":missing number of months before 'M'";
               throw new ParseException(err, idx);
             }
           }
           break;
         // -- Day
         case 'D':
           // make sure no day or time flags have been set
           if ((flags & 31) > 0) {
             throw new ParseException(str + ":Syntax Error...", idx);
           }
           flags = flags | 16;
           if (hasNumber) {
             result.setDay((short) number);
             hasNumber = false;
           } else {
             String err = str + ":missing number of days before 'D'";
             throw new ParseException(err, idx);
           }
           break;
         // -- Time
         case 'T':
           // make sure no T flag already exists
           if ((flags & TIME_FLAG) == 8) {
             String err = str + ":Syntax error, 'T' may not " + "exist more than once.";
             throw new ParseException(err, idx);
           }
           flags = flags | 8;
           break;
         // -- Hour
         case 'H':
           // make sure no time flags have been set, but
           // that T exists
           if ((flags & 15) != 8) {
             String err = null;
             if ((flags & 8) != 8)
               err = str + ": Missing 'T' before 'H'";
             else
               err = str + ": Syntax Error, 'H' must appear for 'M' or 'S'";
             throw new ParseException(err, idx);
           }
           flags = flags | 4;
           if (hasNumber) {
             result.setHour((short) number);
             hasNumber = false;
           } else {
             String err = str + ":missing number of hours before 'H'";
             throw new ParseException(err, idx);
           }
           break;
         case 'S':
           if (flags != 0) {
             // make sure T exists, but no 'S'
             if ((flags & 8) != 8) {
               String err = str + ": Missing 'T' before 'S'";
               throw new ParseException(err, idx);
             }
             if ((flags & 1) == 1) {
               String err = str + ": Syntax error 'S' may not exist more than once.";
               throw new ParseException(err, idx);
             }
 
             flags = flags | 1;
             if (hasNumber) {
               result.setSeconds((short) number);
               hasNumber = false;
             } else {
               String err = str + ": missing number of seconds before 'S'";
               throw new ParseException(err, idx);
             }
           } else {
             if (hasNumber) {
               // remove the "1" prefix used to assist in respecting the decimal place
               String numb = Integer.toString(number).replaceFirst("1", "");
 
               number = Integer.parseInt(numb);
               if (numb.length() < 3) {
                 if (numb.length() < 2) {
                   number = number * 10;
                 }
                 number = number * 10;
               }
               result.setMilli((long) number);
               hasNumber = false;
             } else {
               String err = str + ": missing number of milliseconds before 'S'";
               throw new ParseException(err, idx);
             }
           }
 
           break;
 
         case '.':
 
           // make sure T exists, but no 'S'
           if ((flags & 8) != 8) {
             String err = str + ": Missing 'T' before 'S'";
             throw new ParseException(err, idx);
           }
 
           if ((flags | 1) == 1) {
             String err = str + ": Syntax error '.' may not exist more than once.";
             throw new ParseException(err, idx);
           }
 
           flags = 0;
 
           if (hasNumber) {
             result.setSeconds((short) number);
             hasNumber = false;
           } else {
             String err = str + ": missing number of seconds before 'S'";
             throw new ParseException(err, idx);
           }
           isMilli = true;
           break;
 
         default:
           // make sure ch is a digit...
           if ('0' <= ch && ch <= '9') {
             if (hasNumber) {
               number = (number * 10) + (ch - 48);
             } else {
               hasNumber = true;
               if (isMilli) {
                 // prefix with "1" temporarily to assist in respecting the decimal place
                 number = Integer.parseInt("1" + (ch - 48));
               } else {
                 number = ch - 48;
               }
             }
           } else {
             throw new ParseException(str + ":Invalid character: " + ch, idx);
           }
           break;
       }
     }
 
     // -- check for T, but no HMS
     if ((flags & 15) == 8) {
       LOG.warn("Warning: " + str + ": T shall be omitted");
     }
 
     if (hasNumber) {
       throw new ParseException(str + ": expecting ending delimiter", idx);
     }
 
     return result;
   } // parse
 
 
   /**
    * {@inheritDoc} Overrides the java.lang.Object#hashcode method.
    */
   public int hashCode() {
     return 37 * (_year ^ _month ^ _day ^ _hour ^ _minute ^ _second);
   }
 
   /**
    * {@inheritDoc} Override the java.lang.equals method
    * 
    * @see #equal
    */
   public boolean equals(Object object) {
     if (object instanceof Duration) {
       return equal((Duration) object);
     }
     return false;
   }
 
   /**
    * Returns true if the instance of TimeDuration has the same fields of the parameter
    * 
    * @param duration the time duration to compare
    * @return true if equal, false if not
    */
   public boolean equal(Duration duration) {
     boolean result = false;
     if (duration == null) {
       return result;
     }
     result = (_year == duration.getYear());
     result = result && (_month == duration.getMonth());
     result = result && (_day == duration.getDay());
     result = result && (_hour == duration.getHour());
     result = result && (_minute == duration.getMinute());
     result = result && (_second == duration.getSeconds());
     result = result && (_millisecond == duration.getMilli());
     result = result && (this.isNegative() == duration.isNegative());
     return result;
   } // equals
 
   /**
    * Returns true if the present instance of TimeDuration is greater than the parameter
    * <p>
    * Note This definition does not follow the XML SCHEMA RECOMMENDATION 05022001 the following total
    * order relation is used : <tt>givent t1,t2 timeDuration types
    * t1>t2 iff t1.toLong()>t2.toLong()</tt>
    *
    * @param duration the time duration to compare with the present instance
    * @return true if the present instance is the greatest, false if not
    */
   public boolean isGreater(Duration duration) {
     boolean result = false;
     // to be optimized ??
     result = this.toLong() > duration.toLong();
     return result;
   } // isGreater
 
 } // Duration