/**
    * 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 fr.ifremer.quadrige3.ui.swing.component.date;
  
  /*
   * #%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 fr.ifremer.quadrige3.ui.swing.component.date.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
   * <p>
   * TODO this component will be deprecated soon , use JLocalDatePicker
   */
  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;
  
      public static final String POPUP_LOST = "popupLost";
  
      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;
     private final AWTEventListener awtEventListener;
 
     /**
      * 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
         addHierarchyBoundsListener(new HierarchyBoundsListener() {
             @Override
             public void ancestorMoved(HierarchyEvent e) {
                 hidePopup();
             }
 
             @Override
             public void ancestorResized(HierarchyEvent e) {
                 hidePopup();
             }
         });
 //TODO        addAncestorListener(listener) ?
 
         ActionListener actionListener = e -> {
             if (e.getSource() == button) {
                 if (popup == null) {
                     showPopup();
                 } else {
                     hidePopup();
                 }
             } else if (e.getSource() == datePanel) {
                 hidePopup();
             }
         };
         button.addActionListener(actionListener);
         datePanel.addActionListener(actionListener);
 
         PropertyChangeListener propertyChangeListener = new PropertyChangeListener() {
             private boolean modelAdjusting;
 
             @Override
             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;
                 }
             }
         };
         formattedTextField.addPropertyChangeListener("value", propertyChangeListener);
         datePanel.getModel().addPropertyChangeListener(propertyChangeListener);
 
         awtEventListener = 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) {
                     boolean hidden = hidePopup();
                     firePropertyChange(POPUP_LOST, false, hidden);
                 }
             }
         };
     }
 
     /**
      * <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 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(() -> {
                 popup.show();
                 Toolkit.getDefaultToolkit().addAWTEventListener(awtEventListener, MouseEvent.MOUSE_PRESSED);
             });
         }
     }
 
     /**
      * Called internally to hide the popup dates.
      *
      * @return true if popup has been hidden
      */
     public boolean hidePopup() {
         if (popup != null) {
             Toolkit.getDefaultToolkit().removeAWTEventListener(awtEventListener);
             popup.hide();
             popup = null;
             return true;
         }
         return false;
     }
 
     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 DateSelectionConstraint} object.
      */
     public void addDateSelectionConstraint(DateSelectionConstraint constraint) {
         datePanel.addDateSelectionConstraint(constraint);
     }
 
     /**
      * <p>removeDateSelectionConstraint.</p>
      *
      * @param constraint a {@link 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 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 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));
         }
     }
 
 }