package com.atlassian.plugin.manager;

import com.atlassian.plugin.manager.StateTracker.State;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.runners.MockitoJUnitRunner;

import static com.atlassian.plugin.manager.StateTracker.State.DELAYED;
import static com.atlassian.plugin.manager.StateTracker.State.NOT_STARTED;
import static com.atlassian.plugin.manager.StateTracker.State.RESUMING;
import static com.atlassian.plugin.manager.StateTracker.State.SHUTDOWN;
import static com.atlassian.plugin.manager.StateTracker.State.SHUTTING_DOWN;
import static com.atlassian.plugin.manager.StateTracker.State.STARTED;
import static com.atlassian.plugin.manager.StateTracker.State.STARTING;
import static com.atlassian.plugin.manager.StateTracker.State.WARM_RESTARTING;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.fail;


@RunWith(MockitoJUnitRunner.class)
public class TestStateTracker {
    private StateTracker stateTracker;

    @Before
    public void setup() {
        stateTracker = new StateTracker();
    }

    @After
    public void tearDown() {
        stateTracker = null;
    }

    @Test
    public void testStandardTransitions() throws Exception {
        assertThat(stateTracker.get(), is(NOT_STARTED));
        // The standardTransitions is one loop of the path StateTracker usually runs through.
        // This is not just State.values() - it omits the start point NOT_STARTED, and also
        // WARM_RESTARTING which is tested independently later.
        final State[] standardTransitions = {STARTING, DELAYED, RESUMING, STARTED, SHUTTING_DOWN, SHUTDOWN, STARTING};
        for (final State state : standardTransitions) {
            stateTracker.setState(state);
            assertThat(stateTracker.get(), is(state));
        }
    }

    private void performStateSequence(final State... desiredStates) {
        for (final State state : desiredStates) {
            stateTracker.setState(state);
        }
    }

    @Test
    public void testIllegalNotStartedTransitions() throws Exception {
        performStateSequence();
        validateIllegalStates(NOT_STARTED, DELAYED, RESUMING, STARTED, WARM_RESTARTING, SHUTDOWN);
    }

    @Test
    public void testIllegalStartingTransitions() throws Exception {
        performStateSequence(STARTING);
        validateIllegalStates(NOT_STARTED, STARTING, RESUMING, STARTED, WARM_RESTARTING, SHUTTING_DOWN, SHUTDOWN);
    }

    @Test
    public void testIllegalDelayedTransitions() throws Exception {
        performStateSequence(STARTING, DELAYED);
        validateIllegalStates(NOT_STARTED, STARTING, DELAYED, STARTED, WARM_RESTARTING, SHUTDOWN);
    }

    @Test
    public void testIllegalResumingTransitions() throws Exception {
        performStateSequence(STARTING, DELAYED, RESUMING);
        validateIllegalStates(NOT_STARTED, STARTING, DELAYED, RESUMING, WARM_RESTARTING, SHUTTING_DOWN, SHUTDOWN);
    }

    @Test
    public void testIllegalStartedTransitions() throws Exception {
        performStateSequence(STARTING, DELAYED, RESUMING, STARTED);
        validateIllegalStates(NOT_STARTED, STARTING, DELAYED, RESUMING, STARTED, SHUTDOWN);
    }

    @Test
    public void testIllegalWarmRestartingTransitions() throws Exception {
        performStateSequence(STARTING, DELAYED, RESUMING, STARTED, WARM_RESTARTING);
        validateIllegalStates(NOT_STARTED, STARTING, DELAYED, RESUMING, WARM_RESTARTING, SHUTTING_DOWN, SHUTDOWN);
    }

    @Test
    public void testIllegalWarmRestartTransitions() throws Exception {
        performStateSequence(STARTING, DELAYED, RESUMING, STARTED, WARM_RESTARTING, STARTED);
        validateIllegalStates(NOT_STARTED, STARTING, DELAYED, RESUMING, STARTED, SHUTDOWN);
    }

    @Test
    public void testIllegalShuttingDownTransitions() throws Exception {
        performStateSequence(STARTING, DELAYED, RESUMING, STARTED, SHUTTING_DOWN);
        validateIllegalStates(NOT_STARTED, STARTING, DELAYED, RESUMING, STARTED, WARM_RESTARTING, SHUTTING_DOWN);
    }

    @Test
    public void testIllegalShutdownTransitions() throws Exception {
        performStateSequence(STARTING, DELAYED, RESUMING, STARTED, SHUTTING_DOWN, SHUTDOWN);
        validateIllegalStates(NOT_STARTED, DELAYED, RESUMING, STARTED, WARM_RESTARTING, SHUTTING_DOWN, SHUTDOWN);
    }

    @Test
    public void canShutdownDirectlyFromEarlyStartup() {
        performStateSequence(STARTING, DELAYED, SHUTTING_DOWN, SHUTDOWN);
    }

    private void validateIllegalStates(final State... illegalStates) {
        final State initialState = stateTracker.get();
        for (final State illegalState : illegalStates) {
            try {
                stateTracker.setState(illegalState);
                fail(initialState + " should not be allowed to transition to: " + illegalState);
            } catch (final IllegalStateException expected) {
                assertThat(stateTracker.get(), is(initialState));
            }
        }
    }
}