/**
    * Copyright 2004 Juan Heyns. All rights reserved.
    * <p/>
    * Redistribution and use in source and binary forms, with or without modification, are
    * permitted provided that the following conditions are met:
    * <p/>
    * 1. Redistributions of source code must retain the above copyright notice, this list of
    * conditions and the following disclaimer.
    * <p/>
   * 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.
   * <p/>
   * THIS SOFTWARE IS PROVIDED BY JUAN HEYNS ``AS IS'' AND ANY EXPRESS 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 JUAN HEYNS OR
   * 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.
   * <p/>
   * The views and conclusions contained in the software and documentation are those of the
   * authors and should not be interpreted as representing official policies, either expressed
   * or implied, of Juan Heyns.
   */
  package org.jdatepicker;
  
  /*
   * #%L
   * Reef DB :: UI
   * $Id:$
   * $HeadURL:$
   * %%
   * Copyright (C) 2014 - 2015 Ifremer
   * %%
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Affero General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   * 
   * This program 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 General Public License for more details.
   * 
   * You should have received a copy of the GNU Affero General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   * #L%
   */
  
  
  import org.jdatepicker.constraints.DateSelectionConstraint;
  
  import javax.swing.*;
  import java.awt.*;
  import java.awt.event.*;
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  import java.text.DateFormat;
  import java.text.SimpleDateFormat;
  import java.util.Date;
  import java.util.HashSet;
  import java.util.Set;
  
  /**
   * Created on 25 Mar 2004
   * Refactored 21 Jun 2004
   * Refactored 14 May 2009
   * Refactored 16 April 2010
   * Updated 26 April 2010
   * Updated 10 August 2012
   * Updated 6 Jun 2015
   * Updated 20/11/2015
   *
   * @author Juan Heyns
   * @author JC Oosthuizen
   * @author Yue Huang
   * @author Ludovic Pecquot
   */
  public class JDatePicker extends JComponent {
  
      private static final long serialVersionUID = 2814777654384974503L;
  
      /** Constant <code>COMMIT_DATE="JDatePanel.COMMIT_DATE"</code> */
      public static final String COMMIT_DATE = JDatePanel.COMMIT_DATE;
  
      private Popup popup;
      private final FittingPopupFactory popupFactory = new FittingPopupFactory();
      private final JFormattedTextField formattedTextField;
      private DateComponentFormatter dateComponentFormatter;
      private final JButton button;
  
      private final JDatePanel datePanel;
  
      private final Set<ActionListener> actionListeners;
  
      /**
      * Create a JDatePicker with a default calendar model.
      */
     public JDatePicker() {
         this(new JDatePanel());
     }
 
     /**
      * Create a JDatePicker with a custom date model.
      *
      * @param model a custom date model
      */
     public JDatePicker(DateModel model) {
         this(new JDatePanel(model));
     }
 
     /**
      * You are able to set the format of the date being displayed on the label.
      * Formatting is described at:
      *
      * @param datePanel The DatePanel to use
      */
     private JDatePicker(JDatePanel datePanel) {
         this.datePanel = datePanel;
         datePanel.setBorder(BorderFactory.createLineBorder(datePanel.getColors().getColor(ComponentColorDefaults.Key.POPUP_BORDER)));
 
         //Initialise Variables
         actionListeners = new HashSet<>();
 
         //Create Layout
         setLayout(new BorderLayout());
 
         //Add and Configure TextField
         formattedTextField = createTextField();
         add(formattedTextField, BorderLayout.CENTER);
 
         //Add and Configure Button
         button = createButton();
         add(button, BorderLayout.LINE_END);
 
         //Add event listeners
         InternalEventHandler internalEventHandler = new InternalEventHandler();
         addHierarchyBoundsListener(internalEventHandler);
 //TODO        addAncestorListener(listener)
         button.addActionListener(internalEventHandler);
         formattedTextField.addPropertyChangeListener("value", internalEventHandler);
         datePanel.addActionListener(internalEventHandler);
         datePanel.getModel().addPropertyChangeListener(internalEventHandler);
         long eventMask = MouseEvent.MOUSE_PRESSED;
         Toolkit.getDefaultToolkit().addAWTEventListener(internalEventHandler, eventMask);
     }
 
     /**
      * <p>createTextField.</p>
      *
      * @return a {@link javax.swing.JFormattedTextField} object.
      */
     protected JFormattedTextField createTextField() {
         dateComponentFormatter = new DateComponentFormatter();
         JFormattedTextField textField = new JFormattedTextField(dateComponentFormatter);
         textField.setValue(datePanel.getModel().getDate());
         textField.setEditable(false);
         return textField;
     }
 
     /**
      * <p>createButton.</p>
      *
      * @return a {@link javax.swing.JButton} object.
      */
     protected JButton createButton() {
         JButton b = new JButton();
         b.setRolloverEnabled(true);
         b.setFocusable(false);
         Icon icon = ComponentIconDefaults.getInstance().getPopupButtonIcon();
         b.setIcon(icon);
         b.setText(icon == null ? "..." : "");
         return b;
     }
 
     /**
      * <p>getDate.</p>
      *
      * @return a {@link java.util.Date} object.
      */
     public Date getDate() {
         return getModel().getDate();
     }
 
     /**
      * <p>setDate.</p>
      *
      * @param date a {@link java.util.Date} object.
      */
     public void setDate(Date date) {
         getModel().setDate(date);
     }
 
     /**
      * <p>addActionListener.</p>
      *
      * @param actionListener a {@link java.awt.event.ActionListener} object.
      */
     public void addActionListener(ActionListener actionListener) {
         actionListeners.add(actionListener);
         datePanel.addActionListener(actionListener);
     }
 
     /**
      * <p>removeActionListener.</p>
      *
      * @param actionListener a {@link java.awt.event.ActionListener} object.
      */
     public void removeActionListener(ActionListener actionListener) {
         actionListeners.remove(actionListener);
         datePanel.removeActionListener(actionListener);
     }
 
     /**
      * <p>getModel.</p>
      *
      * @return a {@link org.jdatepicker.DateModel} object.
      */
     public DateModel getModel() {
         return datePanel.getModel();
     }
 
     /**
      * <p>getEditor.</p>
      *
      * @return a {@link javax.swing.JFormattedTextField} object.
      */
     public JFormattedTextField getEditor() {
         return formattedTextField;
     }
 
     /**
      * <p>setTextEditable.</p>
      *
      * @param editable a boolean.
      */
     public void setTextEditable(boolean editable) {
         formattedTextField.setEditable(editable);
     }
 
     /**
      * <p>isTextEditable.</p>
      *
      * @return a boolean.
      */
     public boolean isTextEditable() {
         return formattedTextField.isEditable();
     }
 
     /**
      * <p>setButtonFocusable.</p>
      *
      * @param focusable a boolean.
      */
     public void setButtonFocusable(boolean focusable) {
         button.setFocusable(focusable);
     }
 
     /**
      * <p>getButtonFocusable.</p>
      *
      * @return a boolean.
      */
     public boolean getButtonFocusable() {
         return button.isFocusable();
     }
 
     /**
      * Called internally to popup the dates.
      */
     private void showPopup() {
         if (popup == null) {
             datePanel.setVisible(true);
             Point loc = getLocationOnScreen();
             popup = popupFactory.getPopup(this, datePanel, loc.x, loc.y + getHeight());
             SwingUtilities.invokeLater(new Runnable() {
                 @Override
                 public void run() {
                     popup.show();
                 }
             });
         }
     }
 
     /**
      * Called internally to hide the popup dates.
      */
     private void hidePopup() {
         if (popup != null) {
             popup.hide();
             popup = null;
         }
     }
 
     private Set<Component> getAllComponents(Component component) {
         Set<Component> children = new HashSet<>();
         children.add(component);
         if (component instanceof Container) {
             Container container = (Container) component;
             Component[] components = container.getComponents();
             for (Component component1 : components) {
                 children.addAll(getAllComponents(component1));
             }
         }
         return children;
     }
 
     /**
      * <p>isDoubleClickAction.</p>
      *
      * @return a boolean.
      */
     public boolean isDoubleClickAction() {
         return datePanel.isDoubleClickAction();
     }
 
     /**
      * <p>isShowYearButtons.</p>
      *
      * @return a boolean.
      */
     public boolean isShowYearButtons() {
         return datePanel.isShowYearButtons();
     }
 
     /**
      * <p>setDoubleClickAction.</p>
      *
      * @param doubleClickAction a boolean.
      */
     public void setDoubleClickAction(boolean doubleClickAction) {
         datePanel.setDoubleClickAction(doubleClickAction);
     }
 
     /**
      * <p>setShowYearButtons.</p>
      *
      * @param showYearButtons a boolean.
      */
     public void setShowYearButtons(boolean showYearButtons) {
         datePanel.setShowYearButtons(showYearButtons);
     }
 
     /**
      * <p>addDateSelectionConstraint.</p>
      *
      * @param constraint a {@link org.jdatepicker.constraints.DateSelectionConstraint} object.
      */
     public void addDateSelectionConstraint(DateSelectionConstraint constraint) {
         datePanel.addDateSelectionConstraint(constraint);
     }
 
     /**
      * <p>removeDateSelectionConstraint.</p>
      *
      * @param constraint a {@link org.jdatepicker.constraints.DateSelectionConstraint} object.
      */
     public void removeDateSelectionConstraint(DateSelectionConstraint constraint) {
         datePanel.removeDateSelectionConstraint(constraint);
     }
 
     /**
      * <p>removeAllDateSelectionConstraints.</p>
      */
     public void removeAllDateSelectionConstraints() {
         datePanel.removeAllDateSelectionConstraints();
     }
 
     /**
      * <p>getDateSelectionConstraints.</p>
      *
      * @return a {@link java.util.Set} object.
      */
     public Set<DateSelectionConstraint> getDateSelectionConstraints() {
         return datePanel.getDateSelectionConstraints();
     }
 
     /** {@inheritDoc} */
     @Override
     public void setVisible(boolean aFlag) {
         if (!aFlag) {
             hidePopup();
         }
         super.setVisible(aFlag);
     }
 
     /** {@inheritDoc} */
     @Override
     public void setEnabled(boolean enabled) {
         button.setEnabled(enabled);
         datePanel.setEnabled(enabled);
         formattedTextField.setEnabled(enabled);
 
         super.setEnabled(enabled);
     }
 
     /**
      * <p>setDateFormat.</p>
      *
      * @param datePattern a {@link java.lang.String} object.
      * @param default2DigitYearStart a {@link java.util.Date} object.
      */
     public void setDateFormat(String datePattern, Date default2DigitYearStart) {
 
         SimpleDateFormat outputDateFormat = new SimpleDateFormat(datePattern);
 
         SimpleDateFormat inputDateFormat;
         if (datePattern.contains("yyyy")) {
             inputDateFormat = new SimpleDateFormat(datePattern.replace("yyyy", "yy"));
         } else {
             inputDateFormat = outputDateFormat;
         }
         inputDateFormat.set2DigitYearStart(default2DigitYearStart);
 
         setFormat(AbstractComponentFormat.Key.OUTPUT_DATE_FIELD, outputDateFormat);
         setFormat(AbstractComponentFormat.Key.INPUT_DATE_FIELD, inputDateFormat);
     }
 
     /**
      * <p>setFormat.</p>
      *
      * @param formatKey a {@link org.jdatepicker.AbstractComponentFormat.Key} object.
      * @param format a {@link java.text.DateFormat} object.
      */
     public void setFormat(AbstractComponentFormat.Key formatKey, DateFormat format) {
         dateComponentFormatter.setFormat(formatKey, format);
     }
 
     /**
      * <p>setColor.</p>
      *
      * @param colorKey a {@link org.jdatepicker.AbstractComponentColor.Key} object.
      * @param color a {@link java.awt.Color} object.
      */
     public void setColor(AbstractComponentColor.Key colorKey, Color color) {
         datePanel.getColors().setColor(colorKey, color);
     }
 
     private void fireActionPerformed() {
         for (ActionListener actionListener : actionListeners) {
             actionListener.actionPerformed(new ActionEvent(this, ActionEvent.ACTION_PERFORMED, COMMIT_DATE));
         }
     }
 
     /**
      * This internal class hides the public event methods from the outside
      */
     private class InternalEventHandler implements ActionListener, HierarchyBoundsListener, PropertyChangeListener, AWTEventListener {
 
         private boolean modelAdjusting;
 
         public void ancestorMoved(HierarchyEvent e) {
             hidePopup();
         }
 
         public void ancestorResized(HierarchyEvent e) {
             hidePopup();
         }
 
         public void actionPerformed(ActionEvent e) {
             if (e.getSource() == button) {
                 if (popup == null) {
                     showPopup();
                 } else {
                     hidePopup();
                 }
             } else if (e.getSource() == datePanel) {
                 hidePopup();
             }
         }
 
         public void propertyChange(PropertyChangeEvent evt) {
 
             if (modelAdjusting) {
                 return;
             }
 
             try {
                 modelAdjusting = true;
 
                 if (evt.getSource() == formattedTextField) {
                     // Short circuit if the following cases are found
                     if (evt.getOldValue() == null && evt.getNewValue() == null) {
                         return;
                     }
                     if (evt.getOldValue() != null && evt.getOldValue().equals(evt.getNewValue())) {
                         return;
                     }
                     if (!formattedTextField.isEditable()) {
                         return;
                     }
 
                     // If the field is editable and we need to parse the date entered
                     if (evt.getNewValue() instanceof Date) {
                         Date value = (Date) evt.getNewValue();
                         DateModel tempModel = new DateModel(value);
                         // check constraints
                         if (!datePanel.checkConstraints(tempModel)) {
                             // rollback
                             formattedTextField.setValue(evt.getOldValue());
                             return;
                         }
                         getModel().setDate(tempModel.getDate());
 
                     } else {
 
                         // Clearing textfield will also fire change event
                         getModel().setDate(null);
                     }
 
                     // fire action
                     fireActionPerformed();
 
                 } else if (evt.getSource() == getModel()) {
 
                     if (DateModel.PROPERTY_VALUE.equals(evt.getPropertyName())) {
                         formattedTextField.setValue(getModel().getDate());
                     }
 
                 }
 
             } finally {
                 modelAdjusting = false;
             }
         }
 
         public void eventDispatched(AWTEvent event) {
             if (MouseEvent.MOUSE_CLICKED == event.getID() && event.getSource() != button) {
                 Set<Component> components = getAllComponents(datePanel);
                 boolean clickInPopup = false;
                 for (Component component : components) {
                     if (event.getSource() == component) {
                         clickInPopup = true;
                     }
                 }
                 if (!clickInPopup) {
                     hidePopup();
                 }
             }
         }
 
     }
 
 }