/*
    * 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 2000 (C) Intalio, Inc. All Rights Reserved.
   *
   * $Id$ Date Author Changes 12/05/2000 Aranud Blandin Added support for
   * OperationNotSupportedException 11/02/2000 Arnaud Blandin Changed the constructor 26/10/2000
   * Arnaud Blandin Created
   */
  package org.exolab.castor.types;
  
  import java.text.ParseException;
  import java.util.StringTokenizer;
  
  import org.exolab.castor.types.RecurringDuration;
  
  /**
   * Describe an XML schema TimePeriod.
   * <p>
   * The time period type is derived from recurringDuration by setting up the facet:
   * <ul>
   * <li>period to "P0Y"</li>
   * </ul>
   * <p>
   * Note: This datatype is not included in any recommendation. It was introduced in
   * http://www.w3.org/TR/2000/WD-xmlschema-2-20000407/ and was last in
   * http://www.w3.org/TR/2000/CR-xmlschema-2-20001024/ and was removed by
   * http://www.w3.org/TR/2001/PR-xmlschema-2-20010316/. It was not in the final approved
   * recommendation: http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/
   *
   * @author <a href="mailto:blandin@intalio.com">Arnaud Blandin</a>
   * @version $Revision$
   * @see RecurringDuration
   * @deprecated since Castor 1.0.6 since this type is not in any recommendation.
   */
  public class TimePeriod extends RecurringDuration {
    /** SerialVersionUID */
    private static final long serialVersionUID = -7057026912711829943L;
  
    /** Set to true and recompile to include debugging code in class. */
    private static final boolean DEBUG = false;
  
    public TimePeriod() {
      super("", "P0Y");
    }
  
    /**
     * returns a TimePeriod with the duration facet set up
     * 
     * @param duration the String value of the duration facet
     */
    public TimePeriod(String duration) {
      super(duration, "P0Y");
    }
  
    /**
     * parse a string to set the fields of a TimePeriod
     * 
     * @param str the string to parse
     */
    public void setFields(String str) throws ParseException {
  
      // remove if necessary the Z at the end
      if (str.endsWith("Z"))
        str = str.substring(0, str.indexOf("Z"));
  
      // isNegative ? is there a time zone ?
      if (str.startsWith("-"))
        this.setNegative();
  
      String zoneStr = str.substring(str.length() - 6, str.length());
      boolean timeZone = (((zoneStr.lastIndexOf("-") != -1) || (zoneStr.lastIndexOf("+") != -1))
         && (zoneStr.lastIndexOf(":") != -1));
 
     if (DEBUG) {
       System.out.println("In parsing method of TimePeriod");
       System.out.println("String to parse : " + str);
       System.out.println("Negative ? " + this.isNegative());
       String tzone = timeZone ? zoneStr : "false";
       System.out.println("Time zone :" + tzone);
     }
 
     if (!timeZone)
       zoneStr = null;
     else {
       int index = str.lastIndexOf("+") != -1 ? str.lastIndexOf("+") : str.lastIndexOf("-");
       str = str.substring(0, index);
     }
 
     // the 'T' is required
     if (str.indexOf('T') == -1) {
       throw new ParseException("The 'T' element is required", 0);
     }
     String date = str.substring(0, str.indexOf("T"));
     String time = str.substring(str.indexOf("T"));
 
     // proceed date
     StringTokenizer token = new StringTokenizer(date, "-");
 
     if (token.countTokens() != 3)
       throw new ParseException(str + ": Bad date format", 0);
 
     // CCYY
     String temp = token.nextToken();
     if (temp.length() != 4)
       throw new ParseException(str + ":Bad year format", 1);
     if (DEBUG) {
       System.out.println("Processing century: " + temp.substring(0, 2));
     }
     this.setCentury(Short.parseShort(temp.substring(0, 2)));
     if (DEBUG) {
       System.out.println("Processing year: " + temp.substring(2, 4));
     }
     try {
       this.setYear(Short.parseShort(temp.substring(2, 4)));
     } catch (UnsupportedOperationException e) {
       // we are sure that this method is used with a timePeriod type
       // (if not a ParseException is thrown) so we can never reach that point
     }
 
 
     // MM
     temp = token.nextToken();
     if (temp.length() != 2)
       throw new ParseException(str + ": Bad month format", 5);
     if (DEBUG) {
       System.out.println("Processing month: " + temp);
     }
     try {
       this.setMonth(Short.parseShort(temp));
     } catch (UnsupportedOperationException e) {
       // we are sure that this method is used with a timePeriod type
       // (if not a ParseException is thrown) so we can never reach that point
     }
 
     // DD
     temp = token.nextToken();
     if (temp.length() != 2)
       throw new ParseException(str + ":Bad day format", 8);
     if (DEBUG) {
       System.out.println("Processing day: " + temp);
     }
     try {
       this.setDay(Short.parseShort(temp));
     } catch (UnsupportedOperationException e) {
       // we are sure that this method is used with a timePeriod type
       // (if not a ParseException is thrown) so we can never reach that point
     }
 
     // proceed Time
     token = new StringTokenizer(time, ":");
 
     if ((token.countTokens() < 3) && (token.countTokens() > 5))
       throw new ParseException(str + ": Bad time format", 11);
 
     // hh
     temp = token.nextToken();
     temp = temp.substring(temp.indexOf("T") + 1);
     if (temp.length() != 2)
       throw new ParseException(str + ": Bad hour format", 11);
     if (DEBUG) {
       System.out.println("Processing hour: " + temp);
     }
 
     try {
       this.setHour(Short.parseShort(temp));
     } catch (UnsupportedOperationException e) {
       // we are sure that this method is used with a timePeriod type
       // (if not a ParseException is thrown) so we can never reach that point
     }
 
     // mm
     temp = token.nextToken();
     if (temp.length() != 2)
       throw new ParseException(str + ": Bad minute format", 14);
     if (DEBUG) {
       System.out.println("Processing minute: " + temp);
     }
     try {
       this.setMinute(Short.parseShort(temp));
     } catch (UnsupportedOperationException e) {
       // we are sure that this method is used with a timePeriod type
       // (if not a ParseException is thrown) so we can never reach that point
     }
 
     // ss
     temp = token.nextToken();
     String milsecond = "0";
     if (temp.indexOf(".") != -1) {
       milsecond = temp.substring(temp.indexOf(".") + 1);
       temp = temp.substring(0, temp.indexOf("."));
     }
 
     if (temp.length() != 2)
       throw new ParseException(str + ": Bad second format", 17);
     if (DEBUG) {
       System.out.println("Processing seconds: " + temp);
     }
     try {
       this.setSecond(Short.parseShort(temp.substring(0, 2)), Short.parseShort(milsecond));
     } catch (UnsupportedOperationException e) {
       // we are sure that this method is used with a timePeriod type
       // (if not a ParseException is thrown) so we can never reach that point
     }
 
 
     // proceed TimeZone if any
     if (timeZone) {
       try {
         if (zoneStr.startsWith("-"))
           this.setZoneNegative();
       } catch (UnsupportedOperationException e) {
         // we are sure that this method is used with a timePeriod type
         // (if not a ParseException is thrown) so we can never reach that point
       }
 
       if (zoneStr.length() != 6)
         throw new ParseException(str + ": Bad time zone format", 20);
       try {
         this.setZone(Short.parseShort(zoneStr.substring(1, 3)),
             Short.parseShort(zoneStr.substring(4, 6)));
       } catch (UnsupportedOperationException e) {
         // we are sure that this method is used with a timePeriod type
         // (if not a ParseException is thrown) so we can never reach that point
       }
 
     } else
       this.isUTC();
     temp = null;
   }// setFields
 
 
   public void setPeriod(TimeDuration period) throws UnsupportedOperationException {
     throw new UnsupportedOperationException("in a time period type,the period must not be changed");
   }
 
 } // TimePeriod