/*
   Wotonomy: OpenStep design patterns for pure Java applications.
   Copyright (C) 2000 Blacksmith, Inc.
   
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.
   
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, see http://www.gnu.org
  */
  
  package net.wotonomy.ui.swing.components;
  
  import java.awt.event.FocusAdapter;
  import java.awt.event.FocusEvent;
  import java.awt.event.KeyEvent;
  import java.text.ParsePosition;
  import java.text.SimpleDateFormat;
  import java.util.Calendar;
  import java.util.Date;
  import java.util.Vector;
  
  import javax.swing.JOptionPane;
  import javax.swing.JTextField;
  
  
  /***
  * DateTextField is a "smart" text field that restricts the user's input.  The
  * input is restructed to a string representing a date format.
  *
  * @author rob@straylight.princeton.com
  * @author $Author: cgruber $
  * @version $Revision: 904 $
  */
  public class DateTextField extends JTextField
  {
  
  /********************************
  * CONSTANTS
  *******************************/
  
  /***
  * Use the current date for this text field.
  */
     public static final int CURRENT_DATE = 0;
  
  /***
  * Use blanks for this text field.
  */
     public static final int BLANKS = 1;
  
  /***
  * Use underscores for this text field.
  */
     public static final int UNDERSCORES = 2;
  
  /***
  * Use just a 4-digit year for this text field.
  */
     public static final int YEAR = 3;
  
     private static final int BACKSPACE = 8;
     private static final int DELETE = 127;
     private static final int PASTE = 22;  // Ctl-V
     private static final int CUT = 24;  // Ctl-X
  
  
  /********************************
  * DATA MEMEBERS
  *******************************/
     private int defaultType = CURRENT_DATE;
  
     private boolean warningMessageActive = false;
  
  
  /********************************
  * PUBLIC METHODS
  *******************************/
  
  /***
  * Default Constructor.
  */
     public DateTextField()
     {
        this(1, 1, 1999, 0);
  
        Calendar rightNow = Calendar.getInstance();
  
        super.setText(createDateString(rightNow.get(Calendar.MONTH) + 1,
                                       rightNow.get(Calendar.DATE),
                                       rightNow.get(Calendar.YEAR)));
     }
 
 /***
 * Constructor.
 * @param month Number of the month, January being 1.
 * @param data The day of the month.
 * @param year The year.
 */
    public DateTextField(int month, int date, int year)
    {
       this(month, date, year, 0);
    }
 
 /***
 * Constructor.
 * @param columns Width of the text field (in characters).
 */
    public DateTextField(int columns)
    {
       this(1, 1, 1998, columns);
 
       Calendar rightNow = Calendar.getInstance();
 
       super.setText(createDateString(rightNow.get(Calendar.MONTH) + 1,
                                      rightNow.get(Calendar.DATE),
                                      rightNow.get(Calendar.YEAR)));
    }
 
 /***
 * Constructor.
 * @param month Number of the month, January being 1.
 * @param data The day of the month.
 * @param year The year.
 * @param columns Width of the text field (in characters).
 */
    public DateTextField(int month, int date, int year, int columns)
    {
       super("", columns);
 
       super.setText(createDateString(month, date, year));
 
       this.addFocusListener(new FocusAdapter()
       {
          public void focusLost(FocusEvent e)
          {
             if (!(e.isTemporary()))
             {
                validateDateString(e);
             }
          }
       });
    }
 
 /***
 * Sets the date type to display when the user has not entered any date yet.
 * Default is the current date.
 * @see #CURRENT_DATE
 * @see #BLANKS
 * @see #UNDERSCORES
 * @param newDefaultType The type of date to display when there is no date data.
 */
    public void setDefaultType(int newDefaultType)
    {
       if (newDefaultType == BLANKS)
       {
          defaultType = BLANKS;
          super.setText("  /  /    ");
       }
       else if (newDefaultType == UNDERSCORES)
       {
          defaultType = UNDERSCORES;
          super.setText("__/__/____");
       }
       else if (newDefaultType == YEAR)
       {
           defaultType = YEAR;
           super.setText("0000");
       }
       else
       {
          defaultType = CURRENT_DATE;
 
          Calendar rightNow = Calendar.getInstance();
 
          super.setText(createDateString(rightNow.get(Calendar.MONTH) + 1,
                                         rightNow.get(Calendar.DATE),
                                         rightNow.get(Calendar.YEAR)));
       }
    }
 
 /***
 * Returns the type of date to display when there is no user input.
 * @see #CURRENT_DATE
 * @see #BLANKS
 * @see #UNDERSCORES
 * @return The type of date to display when there is no date to display.
 */
    public int getDefaultType()
    {
       return defaultType;
    }
 
 /***
 * Sets the text field to the string representation of the specified date.
 * @param aDate The date to set the text field to.
 */
    public void setDate(Date aDate)
    {
        Calendar aCalendar = Calendar.getInstance();
 
        aCalendar.setTime(aDate);
 
        super.setText(createDateString(aCalendar.get(Calendar.MONTH) + 1,
                                       aCalendar.get(Calendar.DATE),
                                       aCalendar.get(Calendar.YEAR)));
    }
 
 /***
 * Sets the text field directly from a Date object.
 * @param aDate The date to set the text field to.
 */
    public void setText( Date aDate )
    {
        setDate( aDate );
    }
 
 /***
 * Sets the text field to the date specified in the string.  This is overridden
 * from the parent class to insure a valid date is inputted.  The format of the
 * date expected is the type of date format this text field is currently set to.
 * @param aString A string representing a date in this text field current format.
 */
    public void setText( String aString )
    {
        Date testDate = null;
 
        if ( aString != null )
        {
            ParsePosition position = new ParsePosition( 0 );
 
            if  ( defaultType == YEAR )
            {
                SimpleDateFormat yearFormatter = new SimpleDateFormat( "yyyy" );
                testDate = yearFormatter.parse( aString, position );
            }
            else
            {
                SimpleDateFormat fullDateFormatter = new SimpleDateFormat( "MM/dd/yyyy" );
                testDate = fullDateFormatter.parse( aString, position );
            }
        }
 
        // The string is not a valid date, use default value for date then.
        if ( testDate == null )
        {
            Calendar aCalendar = Calendar.getInstance();
 
            testDate = aCalendar.getTime();
        }
 
        setDate( testDate );
    }
 
 /***
 * Returns the date as represented by the date string in the text field.
 * @return The date in the text field.
 */
    public Date getDate() throws NumberFormatException
    {
       Calendar aCalendar = Calendar.getInstance();
       int year = 1980;
       int month = 0;
       int date = 1;
       int[] tempArray = {1,3,5,7,8,10,12};
       Vector monthsWith31Days = new Vector(7);
 
       for (int i = 0; i < tempArray.length; ++i)
       {
          monthsWith31Days.addElement(new Integer(tempArray[i]));
       }
 
       aCalendar.set(year, month, date, 12, 0, 0);
 
       try
       {
          String dateString = getText();
          NumberFormatException nfException = new NumberFormatException(new String("Invalid Date String: " + dateString));
 
          if (defaultType == YEAR)
          {
              year = Integer.parseInt(dateString);
              
              aCalendar.set(year, 0, 1, 12, 0, 0);
 
              return aCalendar.getTime();
          }
 
          month = Integer.parseInt(dateString.substring(0, 2).trim());
          date = Integer.parseInt(dateString.substring(3, 5).trim());
          year = Integer.parseInt(dateString.substring(6).trim());
 
          if ((month < 1) || (month > 12))
          {
             throw nfException;
          }
 
          if ((date < 1) || (date > 31))
          {
             throw nfException;
          }
 
          if ((date == 31) && (!(monthsWith31Days.contains(new Integer(month)))))
          {
             throw nfException;
          }
 
          if ((date == 30) && (month == 2))
          {
             throw nfException;
          }
 
          if ((date == 29) && (month == 2))
          {
             if ((year % 100) == 0)
             {
                if ((year % 400) != 0)
                {
                   throw nfException;
                }
             }
             else
             {
                if ((year % 4) != 0)
                {
                   throw nfException;
                }
             }
          }
       }
       catch (IndexOutOfBoundsException ioobe)
       {
          NumberFormatException nfException = new NumberFormatException(new String("Invalid Date String: " + getText()));
          throw nfException;
       }
       catch (NumberFormatException nfe)
       {
          NumberFormatException nfException = new NumberFormatException(new String("Invalid Date String: " + getText()));
          throw nfException;
       }
 
       aCalendar.set(year, (month - 1), date, 12, 0, 0);
 
       return aCalendar.getTime();
    }
 
    public void processKeyEvent(KeyEvent e)
    {
       String currentString = "";
       String testString = "";
       char newChar = e.getKeyChar();
       int currentLength = 0;
       int currentCaretPosition = 0;
       int selectionStart = 0;
       int selectionEnd = 0;
       int modifierPosition = 0;
       int modifierDirection = 1;
       char modifierCharacter;
       boolean backspace = false;
       boolean delete = false;
       boolean paste = false;
       boolean cut = false;
       boolean keyPressed = false;
 
       backspace = (newChar == BACKSPACE);
       delete = (newChar == DELETE);
       paste = (newChar == PASTE);
       cut = (newChar == CUT);
 
       keyPressed = (e.paramString().startsWith("KEY_PRESSED"));
 
       if ((e.getKeyCode() == KeyEvent.VK_UNDEFINED) || ((backspace) || (delete) || (paste) || (cut)))  // A "key-typed" event
       {
          if (isValidCharacter(newChar))
          {
             if ((isPrintableCharacter(newChar)) || (backspace) || (delete))
             {
                // Both the key "pressed" and key "released" events get passed
                // in here for the delete and backspace key.  Only processes
                // these keys if the event is key "pressed".
                if (((backspace) || (delete)) && (!(keyPressed)))
                {
                   // Don't do anything, pass through to consumption.
                }
                else
                {
                   // Analyze the current contents of the field
                   currentString = getText();
                   currentLength = currentString.length();
 
                   char[] tempText = new char[currentLength];
 
                   currentCaretPosition = getCaretPosition();
 
                   selectionStart = getSelectionStart();
                   selectionEnd = getSelectionEnd();
 
                   // if a range is selected, then get rid of it and place the caret
                   // at the begginning of the range and continue processing.
                   if (selectionStart != selectionEnd)
                   {
                      selectionEnd = selectionStart;
                      setSelectionEnd(selectionEnd);
 
                      currentCaretPosition = selectionStart;
                      setCaretPosition(currentCaretPosition);
                   }
 
                   if (currentCaretPosition <= currentLength)
                   {
                      // a number of delete or backspace was pressed, delete and
                      // backspace deletes a number and places a "space" there
 
                      // if caret at start of string and the backspace pressed OR
                      // caret at end of string and delete or number pressed THEN
                      // don't do anything, otherwise process key stroke
                      if (((currentCaretPosition == 0) && (backspace)) ||
                          ((currentCaretPosition == currentLength) && (!(backspace))))
                      {
                         // Don't do any processing.
                      }
                      else
                      {
                         modifierPosition = currentCaretPosition;
                         if (backspace)
                         {
                            modifierDirection = -1;
                            modifierPosition += modifierDirection;
                         }
 
                         // Overwrite the current position with the new character
                         // inputted or overwrite using a space or underscore if
                         // the backspace or delete key was pressed.
                         if (defaultType != YEAR)
                         {
                             modifierCharacter =
                                    ((delete)||(backspace)) ?
                                    ((defaultType == UNDERSCORES) ? '_' : ' ') :
                                    newChar;
                         }
                         else
                         {
                             // We are dealing with a 4-digit year.  Overwrite
                             // with new character or "0" if delete or backspace
                             // was pressed.
                             modifierCharacter = ((delete)||(backspace)) ? ('0') : newChar;
                         }
 
                         if (currentString.charAt(modifierPosition) == '/')
                         {
                            modifierPosition += modifierDirection;
                         }
 
                         for (int i = 0; i < currentLength; ++i)
                         {
                            if (i == modifierPosition)
                            {
                               tempText[i] = modifierCharacter;
                            }
                            else
                            {
                               tempText[i] = currentString.charAt(i);
                            }
                         }
 
                         testString = new String(tempText);
                         if (isValidString(testString))
                         {
                            super.setText(testString);
                            if (backspace)
                            {
                               setCaretPosition(modifierPosition);
                            }
                            else
                            {
                               setCaretPosition(modifierPosition + 1);
                            }
                         }
                      }
                   }
                }
 
                e.consume();
             }
             else if ((cut) || (paste))
             {
                e.consume();
             }
             // else its a non-printable character, let it pass through
          }
          else
          {
             e.consume();
          }
       }
 
       super.processKeyEvent(e);
    }
 
    private boolean isValidCharacter(char aChar)
    {
       if (((aChar >= '!') && (aChar <= '/')) || ((aChar >= ':') && (aChar <= '~')))
       {
          return false;
       }
       return true;
    }
 
    private boolean isPrintableCharacter(char inputChar)
    {
       if ((inputChar >= ' ') && (inputChar <= '~'))
       {
          return true;
       }
       return false;
    }
 
    private boolean isValidDate(int month, int date, int year)
    {
       if ((month < 1) || (month > 12))
       {
          return false;
       }
 
       if ((date < 1) || (date > 31))
       {
          return false;
       }
 
       if ((year < 0) || (year > 9999))
       {
          return false;
       }
 
       return true;
    }
 
    private boolean isValidString(String aString)
    {
       return true;
    }
 
    private String createDateString(int month, int date, int year)
    {
       String dateString = "";
 
       if (isValidDate(month, date, year))
       {
          if (defaultType != YEAR)
          {
              if (month < 10)
              {
                 dateString = "0";
              }
 
              dateString += String.valueOf(month);
              dateString += "/";
 
              if (date < 10)
              {
                 dateString += "0";
              }
 
              dateString += String.valueOf(date);
              dateString += "/";
          }
 
          if (year < 1000)
          {
             dateString += "0";
             if (year < 100)
             {
                dateString += "0";
                if (year < 10)
                {
                   dateString += "0";
                }
             }
          }
 
          dateString += String.valueOf(year);
       }
       else
       {
          if (defaultType == YEAR)
          {
              dateString = "1999";
          }
          else
          {
              dateString = "01/01/1999";
          }
       }
 
       return dateString;
    }
 
    private void validateDateString(FocusEvent e)
    {
       if (!(warningMessageActive))
       {
          try
          {
             getDate();
          }
          catch (NumberFormatException nfe)
          {
             System.out.println("Invalid Date String!!!");
             warningMessageActive = true;
             JOptionPane.showMessageDialog(this, "Invald Date: " + getText(), "Warning", JOptionPane.WARNING_MESSAGE);
             warningMessageActive = false;
             if (defaultType == YEAR)
             {
                 super.setText("1999");
             }
             else
             {
                 super.setText("01/01/1999");
             }
          }
       }
    }
 }