/*
 * Copyright (c) 2016, 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.
 *
 * 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.
 */
import org.jtregext.GuiTestListener;
import com.sun.swingset3.demos.slider.SliderDemo;
import java.awt.Component;
import java.awt.event.KeyEvent;
import java.util.function.Predicate;

import static org.testng.AssertJUnit.*;
import org.testng.annotations.Test;
import org.netbeans.jemmy.ClassReference;
import org.netbeans.jemmy.ComponentChooser;
import org.netbeans.jemmy.operators.JFrameOperator;
import org.netbeans.jemmy.operators.JSliderOperator;
import org.netbeans.jemmy.accessibility.AccessibleNameChooser;
import static com.sun.swingset3.demos.slider.SliderDemo.*;
import org.testng.annotations.Listeners;

/*
 * @test
 * @key headful
 * @summary Verifies SwingSet3 SliderDemo by moving the sliders through
 *  different means, checking the slider value corresponding to it,
 *  checking maximum and minimum values, checking Snap to tick is working
 *  and checking the presence of ticks and labels.
 *
 * @library /sanity/client/lib/jemmy/src
 * @library /sanity/client/lib/Extensions/src
 * @library /sanity/client/lib/SwingSet3/src
 * @modules java.desktop
 *          java.logging
 * @build org.jemmy2ext.JemmyExt
 * @build com.sun.swingset3.demos.slider.SliderDemo
 * @run testng SliderDemoTest
 */
@Listeners(GuiTestListener.class)
public class SliderDemoTest {

    private static final int PLAIN_SLIDER_MINIMUM = -10;
    private static final int PLAIN_SLIDER_MAXIMUM = 100;
    private static final int HORIZONTAL_MINOR_TICKS_SLIDER_MINIMUM = 0;
    private static final int HORIZONTAL_MINOR_TICKS_SLIDER_MAXIMUM = 11;
    private static final int VERTICAL_MINOR_TICKS_SLIDER_MINIMUM = 0;
    private static final int VERTICAL_MINOR_TICKS_SLIDER_MAXIMUM = 100;

    @Test
    public void test() throws Exception {
        new ClassReference(SliderDemo.class.getCanonicalName()).startApplication();
        JFrameOperator frame = new JFrameOperator(DEMO_TITLE);
        plain(frame, HORIZONTAL_PLAIN_SLIDER);
        majorTicks(frame, HORIZONTAL_MAJOR_TICKS_SLIDER);
        minorTicks(frame, HORIZONTAL_MINOR_TICKS_SLIDER);
        disabled(frame, HORIZONTAL_DISABLED_SLIDER);
        plain(frame, VERTICAL_PLAIN_SLIDER);
        majorTicks(frame, VERTICAL_MAJOR_TICKS_SLIDER);
        minorTicks(frame, VERTICAL_MINOR_TICKS_SLIDER);
        disabled(frame, VERTICAL_DISABLED_SLIDER);
    }

    private void plain(JFrameOperator jfo, String accessibleName) {
        JSliderOperator jso = new JSliderOperator(jfo,
                new AccessibleNameChooser(accessibleName));
        if (accessibleName.equals(HORIZONTAL_PLAIN_SLIDER)) {
            checkKeyboard(jso);
            checkMouse(jso);
        }
        checkMaximum(jso, PLAIN_SLIDER_MAXIMUM);
        checkMinimum(jso, PLAIN_SLIDER_MINIMUM);
        checkMoveForward(jso, 10);
    }

    private void majorTicks(JFrameOperator jfo, String accessibleName) {
        JSliderOperator jso = new JSliderOperator(jfo,
                new AccessibleNameChooser(accessibleName));
        checkMoveForward(jso, 40);
        assertTrue(jso.getPaintTicks());
        assertEquals(100, jso.getMajorTickSpacing());
    }

    private void minorTicks(JFrameOperator jfo, String accessibleName) {
        JSliderOperator jso = new JSliderOperator(jfo,
                new AccessibleNameChooser(accessibleName));
        if (accessibleName.equals(HORIZONTAL_MINOR_TICKS_SLIDER)) {
            checkMaximum(jso, HORIZONTAL_MINOR_TICKS_SLIDER_MAXIMUM);
            checkMinimum(jso, HORIZONTAL_MINOR_TICKS_SLIDER_MINIMUM);
            checkMoveForward(jso, 2);
            checkSnapToTick(jso, 5, 6);
            assertEquals(5, jso.getMajorTickSpacing());
            assertEquals(1, jso.getMinorTickSpacing());
        } else {
            checkMaximum(jso, VERTICAL_MINOR_TICKS_SLIDER_MAXIMUM);
            checkMinimum(jso, VERTICAL_MINOR_TICKS_SLIDER_MINIMUM);
            checkMoveForward(jso, 10);
            assertEquals(20, jso.getMajorTickSpacing());
            assertEquals(5, jso.getMinorTickSpacing());
        }
        assertTrue(jso.getPaintTicks());
        assertTrue(jso.getPaintLabels());
    }

    private void disabled(JFrameOperator jfo, String accessibleName)
            throws InterruptedException {
        JSliderOperator jso = new JSliderOperator(jfo,
                new AccessibleNameChooser(accessibleName));
        int initialvalue;
        initialvalue = jso.getValue();
        jso.clickMouse(jso.getCenterXForClick(), jso.getCenterYForClick(), 10);
        Thread.sleep(500);
        assertFalse(jso.hasFocus());
        assertEquals(initialvalue, jso.getValue());
    }

    private void checkMaximum(JSliderOperator jso, int maxValue) {
        jso.scrollToMaximum();
        waitSliderValue(jso, jSlider -> jSlider.getValue() == maxValue);
    }

    private void checkMinimum(JSliderOperator jso, int minValue) {
        jso.scrollToMinimum();
        waitSliderValue(jso, jSlider -> jSlider.getValue() == minValue);
    }

    private void checkKeyboard(JSliderOperator jso) {
        checkKeyPress(jso, KeyEvent.VK_HOME,
                jSlider -> jSlider.getValue() == jso.getMinimum());

        {
            int expectedValue = jso.getValue() + 1;
            checkKeyPress(jso, KeyEvent.VK_UP,
                    jSlider -> jSlider.getValue() >= expectedValue);
        }
        {
            int expectedValue = jso.getValue() + 1;
            checkKeyPress(jso, KeyEvent.VK_RIGHT,
                    jSlider -> jSlider.getValue() >= expectedValue);
        }
        {
            int expectedValue = jso.getValue() + 11;
            checkKeyPress(jso, KeyEvent.VK_PAGE_UP,
                    jSlider -> jSlider.getValue() >= expectedValue);
        }

        checkKeyPress(jso, KeyEvent.VK_END,
                jSlider -> jSlider.getValue() == jso.getMaximum());

        {
            int expectedValue = jso.getValue() - 1;
            checkKeyPress(jso, KeyEvent.VK_DOWN,
                    jSlider -> jSlider.getValue() <= expectedValue);
        }
        {
            int expectedValue = jso.getValue() - 1;
            checkKeyPress(jso, KeyEvent.VK_LEFT,
                    jSlider -> jSlider.getValue() <= expectedValue);
        }
        {
            int expectedValue = jso.getValue() - 11;
            checkKeyPress(jso, KeyEvent.VK_PAGE_DOWN,
                    jSlider -> jSlider.getValue() <= expectedValue);
        }
    }

    private void checkKeyPress(JSliderOperator jso, int keyCode,
            Predicate<JSliderOperator> predicate) {
        jso.pushKey(keyCode);
        waitSliderValue(jso, predicate);
    }

    private void waitSliderValue(JSliderOperator jso,
            Predicate<JSliderOperator> predicate) {
        jso.waitState(new ComponentChooser() {
            public boolean checkComponent(Component comp) {
                return predicate.test(jso);
            }

            public String getDescription() {
                return "Wait till Slider attains the specified state.";
            }
        });
    }

    private void checkMoveForward(JSliderOperator jso, int value) {
        jso.setValue(jso.getMinimum());
        int finalValue = jso.getValue() + value;
        jso.scrollToValue(finalValue);
        waitSliderValue(jso, jSlider -> jSlider.getValue() == finalValue);
    }

    private void checkSnapToTick(JSliderOperator jso, int expectedLower,
            int expectedHigher) {
        jso.pressMouse(jso.getCenterXForClick(), jso.getCenterYForClick());
        waitSliderValue(jso, jSlider -> jSlider.getValue() == expectedLower
                || jSlider.getValue() == expectedHigher);
        jso.releaseMouse();
    }

    private void checkMouse(JSliderOperator jso) {
        // Check mouse dragging by pressing on the center of Slider and then
        // dragging the mouse till the end of the track.
        // We set the initial value of the slider as 45,
        // which is the value of the slider at the middle.
        jso.setValue((jso.getMaximum() + jso.getMinimum()) / 2);
        jso.pressMouse(jso.getCenterXForClick(), jso.getCenterYForClick());
        jso.dragMouse(jso.getWidth() + 10, jso.getHeight());
        waitSliderValue(jso, jSlider -> jSlider.getValue() == jSlider.getMaximum());
        jso.releaseMouse();

        // Check mouse click by clicking on the center of the track 2 times
        // and waiting till the slider value has changed from its previous
        // value as a result of the clicks.
        jso.clickMouse(jso.getCenterXForClick(), jso.getCenterYForClick(), 2);
        waitSliderValue(jso, jSlider -> jSlider.getValue() != jSlider.getMaximum());
    }
}