/*

 * Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.apple.laf;

import java.awt.*;

import java.awt.event.*;

import java.beans.*;

import java.text.*;

import java.text.AttributedCharacterIterator.Attribute;

import java.text.Format.Field;

import java.util.*;

import javax.swing.*;

import javax.swing.JSpinner.DefaultEditor;

import javax.swing.plaf.*;

import javax.swing.text.InternationalFormatter;

import apple.laf.*;

import apple.laf.JRSUIConstants.*;

import com.apple.laf.AquaUtils.RecyclableSingleton;

import com.apple.laf.AquaUtils.RecyclableSingletonFromDefaultConstructor;

/**

 */

public class AquaSpinnerUI extends SpinnerUI {

    private static final RecyclableSingleton<? extends PropertyChangeListener> propertyChangeListener

            = new RecyclableSingletonFromDefaultConstructor<>(PropertyChangeHandler.class);

    static PropertyChangeListener getPropertyChangeListener() {

        return propertyChangeListener.get();

    }

    private static final RecyclableSingleton<ArrowButtonHandler> nextButtonHandler

            = new RecyclableSingleton<ArrowButtonHandler>() {

    static ArrowButtonHandler getNextButtonHandler() {

        return nextButtonHandler.get();

    }

    private static final RecyclableSingleton<ArrowButtonHandler> previousButtonHandler

            = new RecyclableSingleton<ArrowButtonHandler>() {

    static ArrowButtonHandler getPreviousButtonHandler() {

        return previousButtonHandler.get();

    }

    private JSpinner spinner;

    private SpinPainter spinPainter;

    private TransparentButton next;

    private TransparentButton prev;

    public static ComponentUI createUI(final JComponent c) {

        return new AquaSpinnerUI();

    }

    private void maybeAdd(final Component c, final String s) {

        if (c != null) {

            spinner.add(c, s);

        }

    }

    boolean wasOpaque;

    @Override

    public void installUI(final JComponent c) {

        installDefaults();

        installListeners();

        next = createNextButton();

        prev = createPreviousButton();

        spinPainter = new SpinPainter(next, prev);

        maybeAdd(next, "Next");

        maybeAdd(prev, "Previous");

        maybeAdd(createEditor(), "Editor");

        maybeAdd(spinPainter, "Painter");

        updateEnabledState();

        installKeyboardActions();

        // this doesn't work because JSpinner calls setOpaque(true) directly in it's constructor

        // ...so we have to handle the is/was opaque ourselves

        wasOpaque = spinner.isOpaque();

        spinner.setOpaque(false);

    }

    @Override

    public void uninstallUI(final JComponent c) {

        uninstallDefaults();

        uninstallListeners();

        spinner.setOpaque(wasOpaque);

        spinPainter = null;

        spinner = null;

        // AquaButtonUI install some listeners to all parents, which means that

        // we need to uninstall UI here to remove those listeners, because after

        // we remove them from spinner we lost the latest reference to them,

        // and our standard uninstallUI machinery will not call them.

        next.getUI().uninstallUI(next);

        prev.getUI().uninstallUI(prev);

        next = null;

        prev = null;

        c.removeAll();

    }

    protected void installListeners() {

        spinner.addPropertyChangeListener(getPropertyChangeListener());

    }

    protected void uninstallListeners() {

        spinner.removePropertyChangeListener(getPropertyChangeListener());

    }

    protected void installDefaults() {

        spinner.setLayout(createLayout());

        LookAndFeel.installBorder(spinner, "Spinner.border");

        LookAndFeel.installColorsAndFont(spinner, "Spinner.background", "Spinner.foreground", "Spinner.font");

    }

    protected void uninstallDefaults() {

        spinner.setLayout(null);

    }

    protected LayoutManager createLayout() {

        return new SpinnerLayout();

    }

    protected PropertyChangeListener createPropertyChangeListener() {

        return new PropertyChangeHandler();

    }

    protected TransparentButton createPreviousButton() {

        final TransparentButton b = new TransparentButton();

        b.addActionListener(getPreviousButtonHandler());

        b.addMouseListener(getPreviousButtonHandler());

        b.setInheritsPopupMenu(true);

        return b;

    }

    protected TransparentButton createNextButton() {

        final TransparentButton b = new TransparentButton();

        b.addActionListener(getNextButtonHandler());

        b.addMouseListener(getNextButtonHandler());

        b.setInheritsPopupMenu(true);

        return b;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public int getBaseline(JComponent c, int width, int height) {

        super.getBaseline(c, width, height);

        JComponent editor = spinner.getEditor();

        Insets insets = spinner.getInsets();

        width = width - insets.left - insets.right;

        height = height - insets.top - insets.bottom;

        if (width >= 0 && height >= 0) {

            int baseline = editor.getBaseline(width, height);

            if (baseline >= 0) {

                return insets.top + baseline;

            }

        }

        return -1;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public Component.BaselineResizeBehavior getBaselineResizeBehavior(

            JComponent c) {

        super.getBaselineResizeBehavior(c);

        return spinner.getEditor().getBaselineResizeBehavior();

    }

    @SuppressWarnings("serial") // Superclass is not serializable across versions

    class TransparentButton extends JButton implements SwingConstants {

        boolean interceptRepaints = false;

        public TransparentButton() {

            super();

            setFocusable(false);

            // only intercept repaints if we are after this has been initialized

            // otherwise we can't talk to our containing class

            interceptRepaints = true;

        }

        @Override

        @Override

        public void repaint() {

            // only intercept repaints if we are after this has been initialized

            // otherwise we can't talk to our containing class

            if (interceptRepaints) {

                spinPainter.repaint();

            }

            super.repaint();

        }

    }

    protected JComponent createEditor() {

        final JComponent editor = spinner.getEditor();

        fixupEditor(editor);

        return editor;

    }

    protected void replaceEditor(final JComponent oldEditor, final JComponent newEditor) {

        spinner.remove(oldEditor);

        fixupEditor(newEditor);

        spinner.add(newEditor, "Editor");

    }

    protected void fixupEditor(final JComponent editor) {

        editor.setOpaque(false);

        editor.setInheritsPopupMenu(true);

        if (editor.getFont() instanceof UIResource) {

            editor.setFont(new FontUIResource(spinner.getFont()));

        }

        if (editorTextField.getFont() instanceof UIResource) {

            editorTextField.setFont(new FontUIResource(spinner.getFont()));

        }

        final InputMap spinnerInputMap = getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);

        final InputMap editorInputMap = editorTextField.getInputMap();

        final KeyStroke[] keys = spinnerInputMap.keys();

        for (final KeyStroke k : keys) {

            editorInputMap.put(k, spinnerInputMap.get(k));

        }

    }

    void updateEnabledState() {

        updateEnabledState(spinner, spinner.isEnabled());

    }

    private void updateEnabledState(final Container c, final boolean enabled) {

        for (int counter = c.getComponentCount() - 1; counter >= 0; counter--) {

            final Component child = c.getComponent(counter);

            child.setEnabled(enabled);

            if (child instanceof Container) {

            }

        }

    }

    private void installKeyboardActions() {

        final InputMap iMap = getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);

        SwingUtilities.replaceUIInputMap(spinner, JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, iMap);

        SwingUtilities.replaceUIActionMap(spinner, getActionMap());

    }

    private InputMap getInputMap(final int condition) {

        if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT) {

        }

        return null;

    }

    private ActionMap getActionMap() {

        if (map == null) {

            map = createActionMap();

            if (map != null) {

                UIManager.getLookAndFeelDefaults().put("Spinner.actionMap", map);

            }

        }

        return map;

    }

    private ActionMap createActionMap() {

        final ActionMap map = new ActionMapUIResource();

        map.put("increment", getNextButtonHandler());

        map.put("decrement", getPreviousButtonHandler());

        return map;

    }

    @SuppressWarnings("serial") // Superclass is not serializable across versions

    private static class ArrowButtonHandler extends AbstractAction implements MouseListener {

        final javax.swing.Timer autoRepeatTimer;

        final boolean isNext;

        JSpinner spinner = null;

        ArrowButtonHandler(final String name, final boolean isNext) {

            super(name);

            this.isNext = isNext;

            autoRepeatTimer = new javax.swing.Timer(60, this);

            autoRepeatTimer.setInitialDelay(300);

        }

        private JSpinner eventToSpinner(final AWTEvent e) {

            Object src = e.getSource();

            while ((src instanceof Component) && !(src instanceof JSpinner)) {

            }

        }

        @Override

        public void actionPerformed(final ActionEvent e) {

            if (!(e.getSource() instanceof javax.swing.Timer)) {

                // Most likely resulting from being in ActionMap.

                spinner = eventToSpinner(e);

            }

            try {

                final int calendarField = getCalendarField(spinner);

                spinner.commitEdit();

                if (calendarField != -1) {

                }

                final Object value = (isNext) ? spinner.getNextValue() : spinner.getPreviousValue();

                if (value != null) {

                    spinner.setValue(value);

                    select(spinner);

                }

            } catch (final IllegalArgumentException iae) {

                UIManager.getLookAndFeel().provideErrorFeedback(spinner);

            } catch (final ParseException pe) {

                UIManager.getLookAndFeel().provideErrorFeedback(spinner);

            }

        }

        /**

         * If the spinner's editor is a DateEditor, this selects the field

         * associated with the value that is being incremented.

         */

        private void select(final JSpinner spinnerComponent) {

            final JComponent editor = spinnerComponent.getEditor();

            final JFormattedTextField ftf = dateEditor.getTextField();

            final Format format = dateEditor.getFormat();

            Object value;

            final SpinnerDateModel model = dateEditor.getModel();

            final DateFormat.Field field = DateFormat.Field.ofCalendarField(model.getCalendarField());

            try {

                final AttributedCharacterIterator iterator = format.formatToCharacterIterator(value);

                if (!select(ftf, iterator, field) && field == DateFormat.Field.HOUR0) {

                    select(ftf, iterator, DateFormat.Field.HOUR1);

                }

        }

        /**

         */

        private boolean select(final JFormattedTextField ftf, final AttributedCharacterIterator iterator, final DateFormat.Field field) {

            final int max = ftf.getDocument().getLength();

            iterator.first();

            do {

                final int start = iterator.getRunStart(field);

                final int end = iterator.getRunLimit(field);

                if (start != -1 && end != -1 && start <= max && end <= max) {

                    ftf.select(start, end);

                }

                return true;

            } while (iterator.next() != CharacterIterator.DONE);

            return false;

        }

        /**

         */

        private int getCalendarField(final JSpinner spinnerComponent) {

            final JComponent editor = spinnerComponent.getEditor();

            final JFormattedTextField ftf = dateEditor.getTextField();

            final int start = ftf.getSelectionStart();

            final JFormattedTextField.AbstractFormatter formatter = ftf.getFormatter();

            for (final Field element : fields) {

                int calendarField;

                if (element == DateFormat.Field.HOUR1) {

                    calendarField = Calendar.HOUR;

                } else {

                }

                if (calendarField != -1) {

                    return calendarField;

                }

            }

            return -1;

        }

        @Override

        public void mousePressed(final MouseEvent e) {

            spinner = eventToSpinner(e);

            autoRepeatTimer.start();

            focusSpinnerIfNecessary();

        }

        @Override

        public void mouseReleased(final MouseEvent e) {

            autoRepeatTimer.stop();

            spinner = null;

        }

        @Override

        @Override

        @Override

        /**

         */

        private void focusSpinnerIfNecessary() {

            final Component fo = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();

            Container root = spinner;