/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package androidx.leanback.app.wizard;

import static org.junit.Assert.assertTrue;

import android.content.Context;
import android.content.Intent;
import android.content.res.Resources;
import android.support.test.InstrumentationRegistry;
import android.support.test.filters.LargeTest;
import android.support.test.rule.ActivityTestRule;
import android.support.test.runner.AndroidJUnit4;
import android.view.KeyEvent;

import androidx.leanback.app.GuidedStepFragment;
import androidx.leanback.test.R;
import androidx.leanback.widget.GuidanceStylist;
import androidx.leanback.widget.GuidedAction;

import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

@LargeTest
@RunWith(AndroidJUnit4.class)
public class GuidedStepAttributesTest {
    static final long TRANSITION_LENGTH = 1000;

    static final String TAG = "GuidedStepAttributesTest";

    @Rule
    public ActivityTestRule<GuidedStepAttributesTestActivity> activityTestRule =
            new ActivityTestRule<>(GuidedStepAttributesTestActivity.class, false, false);

    GuidedStepAttributesTestActivity mActivity;

    private void initActivity(Intent intent) {
        mActivity = activityTestRule.launchActivity(intent);
        try {
            Thread.sleep(2000);
        } catch(InterruptedException e) {
            e.printStackTrace();
        }
    }

    Context mContext;
    @Before
    public void setUp() {
        mContext = InstrumentationRegistry.getInstrumentation().getTargetContext();;
    }

    public static void sendKey(int keyCode) {
        InstrumentationRegistry.getInstrumentation().sendKeyDownUpSync(keyCode);
    }

    @Test
    public void testFocusDisabledOnActions() throws Throwable {

        Intent intent = new Intent();
        Resources res = mContext.getResources();

        final int NUM_SEARCH_ACTIONS = 10;
        final List<Integer> ACTIONS_WITH_DISABLED_FOCUS = new ArrayList<>(
                Arrays.asList(1, 3, 4, 5, 8));
        final int ACTION_ID_SEARCH = 1;
        List<Integer> EXPECTED_ACTIONS_ID_AFTER_EACH_SELECT = new ArrayList<>();

        // we will traverse actions from top to bottom and then back to the top
        for(int i = 0; i < NUM_SEARCH_ACTIONS; i++) {
            if (!ACTIONS_WITH_DISABLED_FOCUS.contains(i))
                EXPECTED_ACTIONS_ID_AFTER_EACH_SELECT.add(i);
        }
        for(int i = EXPECTED_ACTIONS_ID_AFTER_EACH_SELECT.size(); i-- != 0;) {
            EXPECTED_ACTIONS_ID_AFTER_EACH_SELECT.add(EXPECTED_ACTIONS_ID_AFTER_EACH_SELECT.get(i));
        }


        String title = "Guided Actions Focusable Test";
        String breadcrumb = "Focusable Test Demo";
        String description = "";
        GuidanceStylist.Guidance guidance = new GuidanceStylist.Guidance(title, description,
                breadcrumb, null);

        List<GuidedAction> actionList = new ArrayList<>();
        for (int i = 0; i < NUM_SEARCH_ACTIONS; i++ ) {
            actionList.add(new GuidedAction.Builder(mContext)
                    .id(ACTION_ID_SEARCH)
                    .title(res.getString(R.string.search) + "" + i)
                    .description(res.getString(R.string.search_description) + i)
                    .build()
            );
        }
        for(int action_id : ACTIONS_WITH_DISABLED_FOCUS )
            actionList.get(action_id).setFocusable(false);

        GuidedStepAttributesTestFragment.GUIDANCE = guidance;
        GuidedStepAttributesTestFragment.ACTION_LIST = actionList;

        initActivity(intent);

        int lastSelectedActionId = -1;
        int selectIndex = 0;
        GuidedStepFragment mFragment = (GuidedStepFragment) mActivity.getGuidedStepTestFragment();
        int prevSelectedActionPosition = -1;
        int nextSelectedActionPosition = mFragment.getSelectedActionPosition();
        while ( nextSelectedActionPosition != prevSelectedActionPosition ) {
            lastSelectedActionId = mFragment.getSelectedActionPosition();
            assertTrue(res.getString(R.string.focusable_test_error_message,
                    actionList.get(lastSelectedActionId).getTitle()),
                    lastSelectedActionId == EXPECTED_ACTIONS_ID_AFTER_EACH_SELECT.get(selectIndex));
            selectIndex++;
            sendKey(KeyEvent.KEYCODE_DPAD_DOWN);
            prevSelectedActionPosition = nextSelectedActionPosition;
            nextSelectedActionPosition = mFragment.getSelectedActionPosition();
            Thread.sleep(TRANSITION_LENGTH);
        }

        prevSelectedActionPosition = -1;
        while ( nextSelectedActionPosition != prevSelectedActionPosition ) {
            lastSelectedActionId = mFragment.getSelectedActionPosition();
            assertTrue(res.getString(R.string.focusable_test_error_message,
                    actionList.get(lastSelectedActionId).getTitle()),
                    lastSelectedActionId == EXPECTED_ACTIONS_ID_AFTER_EACH_SELECT.get(selectIndex));
            selectIndex++;
            sendKey(KeyEvent.KEYCODE_DPAD_UP);
            prevSelectedActionPosition = nextSelectedActionPosition;
            nextSelectedActionPosition = mFragment.getSelectedActionPosition();
            Thread.sleep(TRANSITION_LENGTH);
        }

    }

    // Note: do not remove final or sRevertCallback gets null from 2nd test on!
     static final GuidedStepAttributesTestFragment.Callback sRevertCallback = new
            GuidedStepAttributesTestFragment.Callback() {
        @Override
        public void onActionClicked(GuidedStepFragment fragment, long id) {
            List<GuidedAction> allActions = fragment.getActions();
            for(int i = 1; i < allActions.size(); i++) {
                GuidedAction action = allActions.get(i);
                action.setEnabled(!action.isEnabled());
                fragment.notifyActionChanged(fragment.findActionPositionById(action.getId()));
            }
        }
    };

    /**
     * Creates a number of enabled and disable actions and tests whether the flag is correctly set
     * by clicking on each individual action and checking whether the click event is triggered.
     * @throws Throwable
     */
    @Test
    public void testDisabledActions() throws Throwable {

        Intent intent = new Intent();
        Resources res = mContext.getResources();

        final int NUM_SEARCH_ACTIONS = 10;
        final List<Integer> DISABLED_ACTIONS = new ArrayList<>(
                Arrays.asList(1, 3, 5, 7));
        final int ACTION_ID_REVERT_BUTTON = 0;
        final int ACTION_ID_SEARCH_BEGIN = ACTION_ID_REVERT_BUTTON + 1;
        int ACTION_ID_SEARCH_END = ACTION_ID_SEARCH_BEGIN;

        // sequence of clicked actions simulated in the test
        List<Integer> CLICK_SEQUENCE = new ArrayList<>();

        // Expected Clicked sequence can be different from focused ones since some of the actions
        // are disabled hence not clickable
        List<Integer> EXPECTED_FOCUSED_SEQUENCE = new ArrayList<>();
        List<Integer> EXPECTED_CLICKED_SEQUENCE = new ArrayList<>();
        // Expected actions state according to list of DISABLED_ACTIONS: false for disabled actions
        List<Boolean> EXPECTED_ACTIONS_STATE = new ArrayList<>(
                Arrays.asList(new Boolean[NUM_SEARCH_ACTIONS])
        );
        Collections.fill(EXPECTED_ACTIONS_STATE, Boolean.TRUE);

        for(int i = 0; i < NUM_SEARCH_ACTIONS; i++) {
            CLICK_SEQUENCE.add(i + 1);
        }
        for(int clickedActionId : CLICK_SEQUENCE) {
            EXPECTED_FOCUSED_SEQUENCE.add(clickedActionId);
            if (!DISABLED_ACTIONS.contains(clickedActionId - 1))
                EXPECTED_CLICKED_SEQUENCE.add(clickedActionId);
            else
                EXPECTED_CLICKED_SEQUENCE.add(-1);
        }

        String title = "Guided Actions Enabled Test";
        String breadcrumb = "Enabled Test Demo";
        String description = "";
        GuidanceStylist.Guidance guidance = new GuidanceStylist.Guidance(title, description,
                breadcrumb, null);

        List<GuidedAction> actionList = new ArrayList<>();
        actionList.add(new GuidedAction.Builder(mContext)
                .id(ACTION_ID_REVERT_BUTTON)
                .title(res.getString(R.string.invert_title))
                .description(res.getString(R.string.revert_description))
                .build()
        );

        for (int i = 0; i < NUM_SEARCH_ACTIONS; i++ ) {
            actionList.add(new GuidedAction.Builder(mContext)
                    .id(ACTION_ID_SEARCH_END++)
                    .title(res.getString(R.string.search) + "" + i)
                    .description(res.getString(R.string.search_description) + i)
                    .build()
            );
        }
        for(int action_id : DISABLED_ACTIONS ) {
            if ( action_id >= 0 && action_id < NUM_SEARCH_ACTIONS ) {
                actionList.get(action_id + 1).setEnabled(false);
                EXPECTED_ACTIONS_STATE.set(action_id, Boolean.FALSE);
            }
        }

        GuidedStepAttributesTestFragment.clear();
        GuidedStepAttributesTestFragment.GUIDANCE = guidance;
        GuidedStepAttributesTestFragment.ACTION_LIST = actionList;
        GuidedStepAttributesTestFragment.setActionClickCallback(ACTION_ID_REVERT_BUTTON,
                sRevertCallback);

        initActivity(intent);

        examineEnabledAndDisabledActions(actionList, CLICK_SEQUENCE, EXPECTED_FOCUSED_SEQUENCE,
                EXPECTED_CLICKED_SEQUENCE);
    }

    /**
     * Toggles Enabled flags in oll the actions of the prior test, and tests whether they are
     * correctly reverted.
     */
    @Test
    public void testToggleEnabledFlags() throws Throwable {

        Intent intent = new Intent();
        Resources res = mContext.getResources();

        final int NUM_SEARCH_ACTIONS = 10;
        final List<Integer> DISABLED_ACTIONS = new ArrayList<>(
                Arrays.asList(1, 3, 5, 7));
        final int ACTION_ID_REVERT_BUTTON = 0;
        final int ACTION_ID_SEARCH_BEGIN = ACTION_ID_REVERT_BUTTON + 1;
        int ACTION_ID_SEARCH_END = ACTION_ID_SEARCH_BEGIN;

        // sequence of clicked actions simulated in the test
        List<Integer> CLICK_SEQUENCE = new ArrayList<>();

        // Expected Clicked sequence can be different from focused ones since some of the actions
        // are disabled hence not clickable
        List<Integer> EXPECTED_FOCUSED_SEQUENCE = new ArrayList<>();
        List<Integer> EXPECTED_CLICKED_SEQUENCE = new ArrayList<>();
        // Expected actions state according to list of DISABLED_ACTIONS: false for disabled actions
        List<Boolean> EXPECTED_ACTIONS_STATE = new ArrayList<>(
                Arrays.asList(new Boolean[NUM_SEARCH_ACTIONS])
        );
        Collections.fill(EXPECTED_ACTIONS_STATE, Boolean.FALSE);

        for(int i = 0; i < NUM_SEARCH_ACTIONS; i++) {
            CLICK_SEQUENCE.add(i + 1);
        }
        for(int clickedActionId : CLICK_SEQUENCE) {
            EXPECTED_FOCUSED_SEQUENCE.add(clickedActionId);
            if (DISABLED_ACTIONS.contains(clickedActionId - 1))
                EXPECTED_CLICKED_SEQUENCE.add(clickedActionId);
            else
                EXPECTED_CLICKED_SEQUENCE.add(-1);
        }

        String title = "Guided Actions Enabled Test";
        String breadcrumb = "Toggle Enabled Flag Test Demo";
        String description = "";
        GuidanceStylist.Guidance guidance = new GuidanceStylist.Guidance(title, description,
                breadcrumb, null);

        List<GuidedAction> actionList = new ArrayList<>();
        actionList.add(new GuidedAction.Builder(mContext)
                .id(ACTION_ID_REVERT_BUTTON)
                .title(res.getString(R.string.invert_title))
                .description(res.getString(R.string.revert_description))
                .build()
        );

        for (int i = 0; i < NUM_SEARCH_ACTIONS; i++ ) {
            actionList.add(new GuidedAction.Builder(mContext)
                    .id(ACTION_ID_SEARCH_END++)
                    .title(res.getString(R.string.search) + "" + i)
                    .description(res.getString(R.string.search_description) + i)
                    .build()
            );
        }
        for(int action_id : DISABLED_ACTIONS ) {
            if ( action_id >= 0 && action_id < NUM_SEARCH_ACTIONS ) {
                actionList.get(action_id + 1).setEnabled(false);
                EXPECTED_ACTIONS_STATE.set(action_id, Boolean.TRUE);
            }
        }

        GuidedStepAttributesTestFragment.clear();
        GuidedStepAttributesTestFragment.GUIDANCE = guidance;
        GuidedStepAttributesTestFragment.ACTION_LIST = actionList;
        GuidedStepAttributesTestFragment.setActionClickCallback(ACTION_ID_REVERT_BUTTON,
                sRevertCallback);

        initActivity(intent);

        final GuidedStepFragment mFragment = (GuidedStepFragment)
                mActivity.getGuidedStepTestFragment();

        mActivity.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                mFragment.setSelectedActionPosition(0);
            }
        });
        Thread.sleep(TRANSITION_LENGTH);
        sendKey(KeyEvent.KEYCODE_DPAD_CENTER);
        Thread.sleep(TRANSITION_LENGTH);
        examineEnabledAndDisabledActions(actionList, CLICK_SEQUENCE, EXPECTED_FOCUSED_SEQUENCE,
                EXPECTED_CLICKED_SEQUENCE);
    }

    private void examineEnabledAndDisabledActions(
            List<GuidedAction> actionList, List<Integer> CLICK_SEQUENCE,
                                List<Integer> EXPECTED_FOCUSED_SEQUENCE,
                                List<Integer> EXPECTED_CLICKED_SEQUENCE)
            throws Throwable {

        final GuidedStepFragment mFragment = (GuidedStepFragment)
                mActivity.getGuidedStepTestFragment();

        for(int i = 0; i < CLICK_SEQUENCE.size(); i++) {
            GuidedStepAttributesTestFragment.LAST_SELECTED_ACTION_ID =
                    GuidedStepAttributesTestFragment.LAST_CLICKED_ACTION_ID = -1;
            final int id = CLICK_SEQUENCE.get(i);
            mActivity.runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    mFragment.setSelectedActionPosition(id);
                }
            });
            Thread.sleep(TRANSITION_LENGTH);

            sendKey(KeyEvent.KEYCODE_DPAD_CENTER);
            Thread.sleep(TRANSITION_LENGTH);

            assertTrue(mContext.getResources().getString(
                    R.string.enabled_test_wrong_focus_error_message),
                    GuidedStepAttributesTestFragment.LAST_SELECTED_ACTION_ID
                            == EXPECTED_FOCUSED_SEQUENCE.get(i)
            );
            assertTrue(mContext.getResources().getString(
                    R.string.enabled_test_wrong_click_error_message),
                    GuidedStepAttributesTestFragment.LAST_CLICKED_ACTION_ID
                            == EXPECTED_CLICKED_SEQUENCE.get(i)
            );
            assertTrue(mContext.getResources().getString(
                    R.string.enabled_test_wrong_flag_error_message),
                    (GuidedStepAttributesTestFragment.LAST_CLICKED_ACTION_ID == -1)
                            ? !actionList.get(id).isEnabled()
                            : actionList.get(id).isEnabled()
            );
        }
    }

    @Test
    public void testCheckedActions() throws Throwable {

        Intent intent = new Intent();
        Resources res = mContext.getResources();

        final int NUM_RADIO_ACTIONS = 3;
        final int NUM_CHECK_BOX_ACTIONS = 3;
        final int INITIALLY_CHECKED_RADIO_ACTION = 0;
        final List<Integer> INITIALLY_CHECKED_CHECKBOX_ACTIONS = new ArrayList<>(
                Arrays.asList(1, 2)
        );

        List<Integer> CLICK_SEQUENCE = new ArrayList<>();
        for(int i = 0; i < NUM_RADIO_ACTIONS + NUM_CHECK_BOX_ACTIONS; i++) {
            CLICK_SEQUENCE.add(i);
        }

        List<Boolean> EXPECTED_ACTIONS_STATE_AFTER_EACH_CLICK = new ArrayList<>(
                Arrays.asList(new Boolean[CLICK_SEQUENCE.size()])
        );
        Collections.fill(EXPECTED_ACTIONS_STATE_AFTER_EACH_CLICK, Boolean.FALSE);

        // initial state of actions before any clicks happen
        EXPECTED_ACTIONS_STATE_AFTER_EACH_CLICK.set(INITIALLY_CHECKED_RADIO_ACTION, true);
        for(int checkedCheckBox : INITIALLY_CHECKED_CHECKBOX_ACTIONS) {
            EXPECTED_ACTIONS_STATE_AFTER_EACH_CLICK.set(NUM_RADIO_ACTIONS + checkedCheckBox, true);
        }

        String title = "Guided Actions Checked Test";
        String breadcrumb = "Checked Test Demo";
        String description = "";
        GuidanceStylist.Guidance guidance = new GuidanceStylist.Guidance(title, description,
                breadcrumb, null);

        List<GuidedAction> actionList = new ArrayList<>();
        actionList.add(new GuidedAction.Builder(mContext)
                .title(res.getString(R.string.radio_actions_info_title))
                .description(res.getString(R.string.radio_actions_info_desc))
                .infoOnly(true)
                .enabled(true)
                .focusable(false)
                .build()
        );

        int firstRadioActionIndex = actionList.size();
        for(int i = 0; i < NUM_RADIO_ACTIONS; i++) {
            actionList.add(new GuidedAction.Builder(mContext)
                    .title(res.getString(R.string.checkbox_title) + i)
                    .description(res.getString(R.string.checkbox_desc) + i)
                    .checkSetId(GuidedAction.DEFAULT_CHECK_SET_ID)
                    .build()
            );
            if (i == INITIALLY_CHECKED_RADIO_ACTION)
                actionList.get(firstRadioActionIndex + i).setChecked(true);
        }

        actionList.add(new GuidedAction.Builder(mContext)
                .title(res.getString(R.string.checkbox_actions_info_title))
                .description(res.getString(R.string.checkbox_actions_info_desc))
                .infoOnly(true)
                .enabled(true)
                .focusable(false)
                .build()
        );
        int firstCheckBoxActionIndex = actionList.size();
        for(int i = 0; i < NUM_CHECK_BOX_ACTIONS; i++) {
            actionList.add(new GuidedAction.Builder(mContext)
                    .title(res.getString(R.string.checkbox_title) + i)
                    .description(res.getString(R.string.checkbox_desc) + i)
                    .checkSetId(GuidedAction.CHECKBOX_CHECK_SET_ID)
                    .build()
            );
        }
        for(int i = 0; i < INITIALLY_CHECKED_CHECKBOX_ACTIONS.size(); i++ ) {
            actionList.get(firstCheckBoxActionIndex + INITIALLY_CHECKED_CHECKBOX_ACTIONS.get(i))
                    .setChecked(true);
        }

        GuidedStepAttributesTestFragment.GUIDANCE = guidance;
        GuidedStepAttributesTestFragment.ACTION_LIST = actionList;
        initActivity(intent);

        examineCheckedAndUncheckedActions(actionList, EXPECTED_ACTIONS_STATE_AFTER_EACH_CLICK,
                NUM_RADIO_ACTIONS, NUM_CHECK_BOX_ACTIONS);
    }

    private void updateExpectedActionsStateAfterClick(
            List<Boolean> EXPECTED_ACTIONS_STATE_AFTER_EACH_CLICK, int NUM_RADIO_ACTIONS,
            int NUM_CHECK_BOX_ACTIONS, int clickedActionIndex) {

        if (clickedActionIndex < NUM_RADIO_ACTIONS) {
            for(int i = 0; i < NUM_RADIO_ACTIONS; i++)
                EXPECTED_ACTIONS_STATE_AFTER_EACH_CLICK.set(i, false);
            EXPECTED_ACTIONS_STATE_AFTER_EACH_CLICK.set(clickedActionIndex, true);
        }
        else if (clickedActionIndex < NUM_RADIO_ACTIONS + NUM_CHECK_BOX_ACTIONS) {
            EXPECTED_ACTIONS_STATE_AFTER_EACH_CLICK.set(clickedActionIndex,
                    !EXPECTED_ACTIONS_STATE_AFTER_EACH_CLICK.get(clickedActionIndex));
        }
    }

    private void verifyIfActionsStateIsCorrect(List<GuidedAction> actionList,
            List<Boolean> EXPECTED_ACTIONS_STATE_AFTER_EACH_CLICK) {

        int actionIndex = 0;
        for(GuidedAction checkAction : actionList) {
            if (checkAction.infoOnly())
                continue;
            assertTrue("Action " + actionIndex + " is " + (!checkAction.isChecked() ? "un-" : "")
                    + "checked while it shouldn't be!", checkAction.isChecked()
                            == EXPECTED_ACTIONS_STATE_AFTER_EACH_CLICK.get(actionIndex));
            actionIndex++;
        }
    }

    private void examineCheckedAndUncheckedActions(List<GuidedAction> actionList,
                                List<Boolean> EXPECTED_ACTIONS_STATE_AFTER_EACH_CLICK,
                                int NUM_RADIO_ACTIONS,
                                int NUM_CHECK_BOX_ACTIONS) throws Throwable {

        final GuidedStepFragment guidedStepCheckedFragment = (GuidedStepFragment)
                mActivity.getGuidedStepTestFragment();
        final int firstRadioActionIndex = 1;
        final int firstCheckBoxActionIndex = firstRadioActionIndex + NUM_RADIO_ACTIONS + 1;
        for(int actionId = 0; actionId < NUM_RADIO_ACTIONS; actionId++) {
            final int id = actionId;
            mActivity.runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    guidedStepCheckedFragment
                            .setSelectedActionPosition(firstRadioActionIndex + id);
                }
            });
            Thread.sleep(TRANSITION_LENGTH);

            sendKey(KeyEvent.KEYCODE_DPAD_CENTER);
            Thread.sleep(TRANSITION_LENGTH);
            updateExpectedActionsStateAfterClick(EXPECTED_ACTIONS_STATE_AFTER_EACH_CLICK,
                    NUM_RADIO_ACTIONS, NUM_CHECK_BOX_ACTIONS, actionId);
            verifyIfActionsStateIsCorrect(actionList, EXPECTED_ACTIONS_STATE_AFTER_EACH_CLICK);
        }

        for(int actionId = 0; actionId < NUM_CHECK_BOX_ACTIONS; actionId++) {
            final int id = actionId;
            mActivity.runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    guidedStepCheckedFragment
                            .setSelectedActionPosition(firstCheckBoxActionIndex + id);
                }
            });
            Thread.sleep(TRANSITION_LENGTH);

            sendKey(KeyEvent.KEYCODE_DPAD_CENTER);
            Thread.sleep(TRANSITION_LENGTH);
            updateExpectedActionsStateAfterClick(EXPECTED_ACTIONS_STATE_AFTER_EACH_CLICK,
                    NUM_RADIO_ACTIONS, NUM_CHECK_BOX_ACTIONS, NUM_RADIO_ACTIONS + actionId);
            verifyIfActionsStateIsCorrect(actionList, EXPECTED_ACTIONS_STATE_AFTER_EACH_CLICK);
        }
    }

    @Test
    public void testActionWithTwoSubActions() throws Throwable {
        ExpectedSubActionResult result = setUpActionsForSubActionsTest();

        final int actionPos = 0;
        final GuidedAction selectedAction = result.actionList.get(actionPos);
        List<Integer> expectedFocusedSeq = result.expectedFocusedSeq.get(actionPos);
        List<Integer> expectedClickedSeq = result.expectedClickedSeq.get(actionPos);

        traverseSubActionsAndVerifyFocusAndClickEvents(selectedAction, actionPos, expectedFocusedSeq,
                expectedClickedSeq);
    }

    @Test
    public void testActionWithOneSubAction() throws Throwable {
        ExpectedSubActionResult result = setUpActionsForSubActionsTest();

        final int actionPos = 1;
        final GuidedAction selectedAction = result.actionList.get(actionPos);
        List<Integer> expectedFocusedSeq = result.expectedFocusedSeq.get(actionPos);
        List<Integer> expectedClickedSeq = result.expectedClickedSeq.get(actionPos);

        traverseSubActionsAndVerifyFocusAndClickEvents(selectedAction, actionPos, expectedFocusedSeq,
                expectedClickedSeq);
    }

    @Test
    public void testActionWithZeroSubActions() throws Throwable {
        ExpectedSubActionResult result = setUpActionsForSubActionsTest();

        final int actionPos = 2;
        final GuidedAction selectedAction = result.actionList.get(actionPos);
        List<Integer> expectedFocusedSeq = result.expectedFocusedSeq.get(actionPos);
        List<Integer> expectedClickedSeq = result.expectedClickedSeq.get(actionPos);

        traverseSubActionsAndVerifyFocusAndClickEvents(selectedAction, actionPos, expectedFocusedSeq,
                expectedClickedSeq);
    }

    @Test
    public void testActionWithThreeSubActions() throws Throwable {
        ExpectedSubActionResult result = setUpActionsForSubActionsTest();

        final int actionPos = 3;
        final GuidedAction selectedAction = result.actionList.get(actionPos);
        List<Integer> expectedFocusedSeq = result.expectedFocusedSeq.get(actionPos);
        List<Integer> expectedClickedSeq = result.expectedClickedSeq.get(actionPos);

        traverseSubActionsAndVerifyFocusAndClickEvents(selectedAction, actionPos, expectedFocusedSeq,
                expectedClickedSeq);
    }

    /**
     * Traverses the list of sub actions of a gudied action. It also verifies the correct action
     * or sub action is focused or clicked as the traversal is performed.
     * @param selectedAction The action of interest
     * @param actionPos The position of selectedAction within the array of guidedactions
     * @param expectedFocusedSeq The actual actions IDs used as a reference to verify focused actions
     * @param expectedClickedSeq The actual action IDs used as a reference to verify clicked actions
     * @throws Throwable
     */
    private void traverseSubActionsAndVerifyFocusAndClickEvents(GuidedAction selectedAction,
                                                                int actionPos,
                                                                List<Integer> expectedFocusedSeq,
                                                                List<Integer> expectedClickedSeq)
            throws Throwable{

        final GuidedStepFragment mFragment =
                (GuidedStepFragment) mActivity.getGuidedStepTestFragment();
        int focusStep = 0, clickStep = 0;
        GuidedStepAttributesTestFragment.LAST_SELECTED_ACTION_ID =
                GuidedStepAttributesTestFragment.LAST_CLICKED_ACTION_ID = -1;


        final int pos = actionPos;
        mActivity.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                mFragment.setSelectedActionPosition(pos);
            }
        });
        Thread.sleep(TRANSITION_LENGTH);

        if (mFragment.getSelectedActionPosition() != actionPos) {
            assertTrue(mContext.getResources().getString(
                    R.string.subaction_test_wrong_focus_error_message),
                    GuidedStepAttributesTestFragment.LAST_SELECTED_ACTION_ID
                            == expectedFocusedSeq.get(focusStep++)
            );
        } else {
            // If the currently focused position is the same as the position of the action of interest,
            // then GuidedStepFragment won't received onGuidedActionFocused callback. Since the first
            // element in the expectedFocusSeq is always the id of this action, we need to move focusStep
            // one step forward.
            focusStep++;
        }
        if (selectedAction.hasSubActions()) {
            // Following for loop clicks on a specific action and scrolls & clicks through
            // all its subactions
            for (int j = 0; j < selectedAction.getSubActions().size(); j++) {
                sendKey(KeyEvent.KEYCODE_DPAD_CENTER);
                Thread.sleep(TRANSITION_LENGTH);
                assertTrue(mContext.getResources().getString(
                        R.string.subaction_test_wrong_focus_error_message),
                        GuidedStepAttributesTestFragment.LAST_SELECTED_ACTION_ID
                                == expectedFocusedSeq.get(focusStep++)
                );
                assertTrue(mContext.getResources().getString(
                        R.string.subaction_test_wrong_click_error_message),
                        GuidedStepAttributesTestFragment.LAST_CLICKED_ACTION_ID
                                == expectedClickedSeq.get(clickStep++)
                );

                for (int k = 0; k < j; k++) {
                    sendKey(KeyEvent.KEYCODE_DPAD_DOWN);
                    Thread.sleep(TRANSITION_LENGTH);
                    assertTrue(mContext.getResources().getString(
                            R.string.subaction_test_wrong_focus_error_message),
                            GuidedStepAttributesTestFragment.LAST_SELECTED_ACTION_ID
                                    == expectedFocusedSeq.get(focusStep++)
                    );
                }
                sendKey(KeyEvent.KEYCODE_DPAD_CENTER);
                Thread.sleep(TRANSITION_LENGTH);

                assertTrue(mContext.getResources().getString(
                        R.string.subaction_test_wrong_focus_error_message),
                        GuidedStepAttributesTestFragment.LAST_SELECTED_ACTION_ID
                                == expectedFocusedSeq.get(focusStep++)
                );
                assertTrue(mContext.getResources().getString(
                        R.string.subaction_test_wrong_click_error_message),
                        GuidedStepAttributesTestFragment.LAST_CLICKED_ACTION_ID
                                == expectedClickedSeq.get(clickStep++)
                );
            }
        } else {
            sendKey(KeyEvent.KEYCODE_DPAD_CENTER);
            Thread.sleep(TRANSITION_LENGTH);
            assertTrue(mContext.getResources().getString(
                    R.string.subaction_test_wrong_focus_error_message),
                    GuidedStepAttributesTestFragment.LAST_SELECTED_ACTION_ID
                            == expectedFocusedSeq.get(focusStep++)
            );
            assertTrue(mContext.getResources().getString(
                    R.string.subaction_test_wrong_click_error_message),
                    GuidedStepAttributesTestFragment.LAST_CLICKED_ACTION_ID
                            == expectedClickedSeq.get(clickStep++)
            );
        }
    }

    static class ExpectedSubActionResult {
        List<List<Integer>> expectedFocusedSeq; // Expected sequence of action (or subaction) ids to receive focus events;
        // Each entry corresponds to an action item in the guidedactions pane
        List<List<Integer>> expectedClickedSeq; // Expected sequence of action (or subaction) ids to receive click events;
        // Each entry corresponds to an action item in the guidedactions pane
        List<GuidedAction> actionList;          // List of GuidedActions in the guidedactions pane
    }

    /**
     * Populates a sample list of actions and subactions in the guidedactions pane.
     * @return  An object holding the expected sequence of action and subactions IDs that receive
     * focus and click events as well as the list of GuidedActions.
     */
    private ExpectedSubActionResult setUpActionsForSubActionsTest() {
        Intent intent = new Intent();
        Resources res = mContext.getResources();

        ExpectedSubActionResult result = new ExpectedSubActionResult();
        result.expectedFocusedSeq = new ArrayList<>();
        result.expectedClickedSeq = new ArrayList<>();

        final int NUM_REGULAR_ACTIONS = 4;
        final int[] NUM_SUBACTIONS_PER_ACTION = {2, 1, 0, 3};
        final int[] REGULAR_ACTIONS_INDEX =  new int[NUM_REGULAR_ACTIONS];
        final int[] BEGIN_SUBACTION_INDEX_PER_ACTION = new int[NUM_REGULAR_ACTIONS];
        final int[] END_SUBACTION_INDEX_PER_ACTION = new int[NUM_REGULAR_ACTIONS];
        // Actions and SubActions are assigned unique sequential IDs
        int lastIndex = 0;
        for(int i = 0; i < NUM_REGULAR_ACTIONS; i++) {
            REGULAR_ACTIONS_INDEX[i] = lastIndex;
            lastIndex++;
            BEGIN_SUBACTION_INDEX_PER_ACTION[i] = lastIndex;
            END_SUBACTION_INDEX_PER_ACTION[i] = (lastIndex += NUM_SUBACTIONS_PER_ACTION[i]);
        }

        for (int i = 0; i < NUM_REGULAR_ACTIONS; i++) {
            List<Integer> expectedFocusSeqForEachAction = new ArrayList<>();
            List<Integer> expectedClickedSeqForEachAction = new ArrayList<>();
            expectedFocusSeqForEachAction.add(REGULAR_ACTIONS_INDEX[i]);

            if (NUM_SUBACTIONS_PER_ACTION[i] > 0) {
                for (int j = BEGIN_SUBACTION_INDEX_PER_ACTION[i];
                        j < END_SUBACTION_INDEX_PER_ACTION[i]; j++) {
                    expectedClickedSeqForEachAction.add(REGULAR_ACTIONS_INDEX[i]);
                    for (int k = BEGIN_SUBACTION_INDEX_PER_ACTION[i]; k <= j; k++) {
                        expectedFocusSeqForEachAction.add(k);
                    }
                    expectedClickedSeqForEachAction.add(j);
                    expectedFocusSeqForEachAction.add(REGULAR_ACTIONS_INDEX[i]);
                }
            } else {
                expectedClickedSeqForEachAction.add(REGULAR_ACTIONS_INDEX[i]);
                expectedFocusSeqForEachAction.add(REGULAR_ACTIONS_INDEX[i]);
            }
            result.expectedFocusedSeq.add(expectedFocusSeqForEachAction);
            result.expectedClickedSeq.add(expectedClickedSeqForEachAction);
        }

        String title = "Guided SubActions Test";
        String breadcrumb = "SubActions Test Demo";
        String description = "";
        GuidanceStylist.Guidance guidance = new GuidanceStylist.Guidance(title, description,
                breadcrumb, null);

        List<GuidedAction> actionList = new ArrayList<>();

        lastIndex = 0;
        for (int i = 0; i < NUM_REGULAR_ACTIONS; i++ ) {
            GuidedAction action = new GuidedAction.Builder(mContext)
                    .id(lastIndex++)
                    .title(res.getString(R.string.dropdown_action_title, i))
                    .description(res.getString(R.string.dropdown_action_desc, i))
                    .build();
            if (NUM_SUBACTIONS_PER_ACTION[i] > 0) {
                List<GuidedAction> subActions = new ArrayList<>();
                action.setSubActions(subActions);
                for(int j = 0; j < NUM_SUBACTIONS_PER_ACTION[i]; j++) {
                    subActions.add(new GuidedAction.Builder(mContext)
                            .id(lastIndex++)
                            .title(res.getString(R.string.subaction_title, j))
                            .description("")
                            .build()
                    );
                }
            }
            actionList.add(action);
        }
        result.actionList = actionList;

        GuidedStepAttributesTestFragment.clear();
        GuidedStepAttributesTestFragment.GUIDANCE = guidance;
        GuidedStepAttributesTestFragment.ACTION_LIST = actionList;

        initActivity(intent);
        return result;
    }
}