/*
 * Copyright (C) 2017 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 android.server.wm;

import static android.app.WindowConfiguration.ACTIVITY_TYPE_ASSISTANT;
import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD;
import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
import static android.server.wm.CliIntentExtra.extraString;
import static android.server.wm.ComponentNameUtils.getActivityName;
import static android.server.wm.UiDeviceUtils.pressHomeButton;
import static android.server.wm.WindowManagerState.STATE_RESUMED;
import static android.server.wm.app.Components.ANIMATION_TEST_ACTIVITY;
import static android.server.wm.app.Components.ASSISTANT_ACTIVITY;
import static android.server.wm.app.Components.ASSISTANT_VOICE_INTERACTION_SERVICE;
import static android.server.wm.app.Components.AssistantActivity.EXTRA_ASSISTANT_DISPLAY_ID;
import static android.server.wm.app.Components.AssistantActivity.EXTRA_ASSISTANT_ENTER_PIP;
import static android.server.wm.app.Components.AssistantActivity.EXTRA_ASSISTANT_FINISH_SELF;
import static android.server.wm.app.Components.AssistantActivity.EXTRA_ASSISTANT_LAUNCH_NEW_TASK;
import static android.server.wm.app.Components.DOCKED_ACTIVITY;
import static android.server.wm.app.Components.LAUNCH_ASSISTANT_ACTIVITY_FROM_SESSION;
import static android.server.wm.app.Components.LAUNCH_ASSISTANT_ACTIVITY_INTO_STACK;
import static android.server.wm.app.Components.LaunchAssistantActivityIntoAssistantStack.EXTRA_ASSISTANT_IS_TRANSLUCENT;
import static android.server.wm.app.Components.PIP_ACTIVITY;
import static android.server.wm.app.Components.PipActivity.EXTRA_ENTER_PIP;
import static android.server.wm.app.Components.TEST_ACTIVITY;
import static android.server.wm.app.Components.TRANSLUCENT_ASSISTANT_ACTIVITY;
import static android.server.wm.app.Components.TestActivity.TEST_ACTIVITY_ACTION_FINISH_SELF;
import static android.view.Display.DEFAULT_DISPLAY;

import static org.hamcrest.Matchers.hasSize;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assume.assumeTrue;

import android.content.ComponentName;
import android.platform.test.annotations.Presubmit;
import android.provider.Settings;
import android.server.wm.settings.SettingsSession;

import org.junit.Ignore;
import org.junit.Test;

/**
 * Build/Install/Run:
 *     atest CtsWindowManagerDeviceTestCases:AssistantStackTests
 */
@Presubmit
public class AssistantStackTests extends ActivityManagerTestBase {

    private int mAssistantDisplayId = DEFAULT_DISPLAY;
    private int mDefaultWindowingMode;

    public void setUp() throws Exception {
        super.setUp();
        try (final AssistantSession assistantSession = new AssistantSession()) {
            assistantSession.setVoiceInteractionService(ASSISTANT_VOICE_INTERACTION_SERVICE);
            launchActivityNoWait(LAUNCH_ASSISTANT_ACTIVITY_INTO_STACK);
            waitForValidStateWithActivityType(ASSISTANT_ACTIVITY, ACTIVITY_TYPE_ASSISTANT);
            WindowManagerState.Task assistantStack =
                    mWmState.getRootTaskByActivityType(ACTIVITY_TYPE_ASSISTANT);
            mAssistantDisplayId = assistantStack.mDisplayId;
            mDefaultWindowingMode = getDefaultDisplayWindowingMode();
        }
    }

    @Test
    public void testLaunchingAssistantActivityIntoAssistantStack() throws Exception {
        // Enable the assistant and launch an assistant activity
        try (final AssistantSession assistantSession = new AssistantSession()) {
            assistantSession.setVoiceInteractionService(ASSISTANT_VOICE_INTERACTION_SERVICE);

            launchActivityNoWait(LAUNCH_ASSISTANT_ACTIVITY_FROM_SESSION);
            waitForValidStateWithActivityType(ASSISTANT_ACTIVITY, ACTIVITY_TYPE_ASSISTANT);

            // Ensure that the activity launched in the fullscreen assistant stack
            assertAssistantStackExists();
            // In a multi-window environment the assistant might not be fullscreen
            assumeTrue(mDefaultWindowingMode == WINDOWING_MODE_FULLSCREEN);
            assertTrue("Expected assistant stack to be fullscreen",
                    mWmState.getRootTaskByActivityType(
                            ACTIVITY_TYPE_ASSISTANT).isFullscreen());
        }
    }

    @Test
    public void testAssistantStackZOrder() throws Exception {
        assumeTrue(assistantRunsOnPrimaryDisplay());
        assumeTrue(supportsPip());
        assumeTrue(supportsSplitScreenMultiWindow());

        // Launch a pinned stack task
        launchActivity(PIP_ACTIVITY, extraString(EXTRA_ENTER_PIP, "true"));
        waitForValidStateWithActivityTypeAndWindowingMode(
                PIP_ACTIVITY, ACTIVITY_TYPE_STANDARD, WINDOWING_MODE_PINNED);
        mWmState.assertContainsStack("Must contain pinned stack.",
                WINDOWING_MODE_PINNED, ACTIVITY_TYPE_STANDARD);

        // Dock a task
        launchActivitiesInSplitScreen(
                getLaunchActivityBuilder().setTargetActivity(DOCKED_ACTIVITY),
                getLaunchActivityBuilder().setTargetActivity(TEST_ACTIVITY));

        // Enable the assistant and launch an assistant activity, ensure it is on top
        try (final AssistantSession assistantSession = new AssistantSession()) {
            assistantSession.setVoiceInteractionService(ASSISTANT_VOICE_INTERACTION_SERVICE);

            launchActivityNoWait(LAUNCH_ASSISTANT_ACTIVITY_FROM_SESSION);
            waitForValidStateWithActivityType(ASSISTANT_ACTIVITY, ACTIVITY_TYPE_ASSISTANT);
            assertAssistantStackExists();

            mWmState.assertFrontStack("Pinned stack should be on top.",
                    WINDOWING_MODE_PINNED, ACTIVITY_TYPE_STANDARD);
            mWmState.assertFocusedRootTask("Assistant stack should be focused.",
                    WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_ASSISTANT);
        }
    }

    @Test
    public void testAssistantStackLaunchNewTask() throws Exception {
        assertAssistantStackCanLaunchAndReturnFromNewTask(mDefaultWindowingMode);
    }

    @Test
    @Ignore("b/77272253#comment10")
    public void testAssistantStackLaunchNewTaskWithDockedStack() throws Exception {
        assumeTrue(assistantRunsOnPrimaryDisplay());
        assumeTrue(supportsSplitScreenMultiWindow());

        // Dock a task
        launchActivitiesInSplitScreen(
                getLaunchActivityBuilder().setTargetActivity(DOCKED_ACTIVITY),
                getLaunchActivityBuilder().setTargetActivity(TEST_ACTIVITY));

        //assertAssistantStackCanLaunchAndReturnFromNewTask(WINDOWING_MODE_SPLIT_SCREEN_SECONDARY);
    }

    private void assertAssistantStackCanLaunchAndReturnFromNewTask(int expectedWindowingMode)
            throws Exception {
        // Enable the assistant and launch an assistant activity which will launch a new task
        try (final AssistantSession assistantSession = new AssistantSession()) {
            assistantSession.setVoiceInteractionService(ASSISTANT_VOICE_INTERACTION_SERVICE);

            launchActivityOnDisplayNoWait(LAUNCH_ASSISTANT_ACTIVITY_INTO_STACK, mAssistantDisplayId,
                    extraString(EXTRA_ASSISTANT_LAUNCH_NEW_TASK, getActivityName(TEST_ACTIVITY)),
                    extraString(EXTRA_ASSISTANT_DISPLAY_ID, Integer.toString(mAssistantDisplayId)));
            // Ensure that the fullscreen stack is on top and the test activity is now visible
            waitForValidStateWithActivityTypeAndWindowingMode(
                    TEST_ACTIVITY, ACTIVITY_TYPE_STANDARD, expectedWindowingMode);
        }

        if (isAssistantOnTopOfDream()) {
            // If the assistant is configured to be always-on-top, then the new task should have
            // been started behind it and the assistant stack should still be on top.
            mWmState.assertFocusedActivity(
                    "AssistantActivity should be focused", ASSISTANT_ACTIVITY);
            mWmState.assertFrontStackActivityType(
                    "Assistant stack should be on top.", ACTIVITY_TYPE_ASSISTANT);
            mWmState.assertFocusedRootTask("Assistant stack should be focused.",
                    WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_ASSISTANT);
        } else {
            mWmState.assertFocusedActivity("TestActivity should be resumed", TEST_ACTIVITY);
            mWmState.assertFrontStack("TestActivity stack should be on top.",
                    expectedWindowingMode, ACTIVITY_TYPE_STANDARD);
            mWmState.assertFocusedRootTask("TestActivity stack should be focused.",
                    expectedWindowingMode, ACTIVITY_TYPE_STANDARD);
        }

        // Now, tell it to finish itself and ensure that the assistant stack is brought back forward
        mBroadcastActionTrigger.doAction(TEST_ACTIVITY_ACTION_FINISH_SELF);
        mWmState.waitForFocusedStack(WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_ASSISTANT);
        mWmState.assertFrontStackActivityType(
                "Assistant stack should be on top.", ACTIVITY_TYPE_ASSISTANT);
        mWmState.assertFocusedRootTask("Assistant stack should be focused.",
                WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_ASSISTANT);
    }

    @Test
    public void testAssistantStackFinishToPreviousApp() throws Exception {
        // If the Assistant is configured to be always-on-top, then the assistant activity
        // started in setUp() will not allow any other activities to start. Therefore we should
        // remove it before launching a fullscreen activity.
        if (isAssistantOnTopOfDream()) {
            removeRootTasksWithActivityTypes(ACTIVITY_TYPE_ASSISTANT);
        }

        // Launch an assistant activity on top of an existing fullscreen activity, and ensure that
        // the fullscreen activity is still visible and on top after the assistant activity finishes
        launchActivityOnDisplay(TEST_ACTIVITY, WINDOWING_MODE_FULLSCREEN, mAssistantDisplayId);
        try (final AssistantSession assistantSession = new AssistantSession()) {
            assistantSession.setVoiceInteractionService(ASSISTANT_VOICE_INTERACTION_SERVICE);

            launchActivityNoWait(LAUNCH_ASSISTANT_ACTIVITY_INTO_STACK,
                    extraString(EXTRA_ASSISTANT_FINISH_SELF, "true"));
            mWmState.waitFor((amState) -> !amState.containsActivity(ASSISTANT_ACTIVITY),
                    getActivityName(ASSISTANT_ACTIVITY) + " finished");
        }
        waitForValidStateWithActivityTypeAndWindowingMode(
                TEST_ACTIVITY, ACTIVITY_TYPE_STANDARD, mDefaultWindowingMode);
        waitAndAssertTopResumedActivity(TEST_ACTIVITY, mAssistantDisplayId,
                "TestActivity should be resumed");
        mWmState.assertFocusedActivity("TestActivity should be focused", TEST_ACTIVITY);
        mWmState.assertFrontStack("Fullscreen stack should be on top.",
                mDefaultWindowingMode, ACTIVITY_TYPE_STANDARD);
        mWmState.assertFocusedRootTask("Fullscreen stack should be focused.",
                mDefaultWindowingMode, ACTIVITY_TYPE_STANDARD);
    }

    @Test
    public void testDisallowEnterPiPFromAssistantStack() throws Exception {
        try (final AssistantSession assistantSession = new AssistantSession()) {
            assistantSession.setVoiceInteractionService(ASSISTANT_VOICE_INTERACTION_SERVICE);

            launchActivityNoWait(LAUNCH_ASSISTANT_ACTIVITY_INTO_STACK,
                    extraString(EXTRA_ASSISTANT_ENTER_PIP, "true"));
        }
        waitForValidStateWithActivityType(ASSISTANT_ACTIVITY, ACTIVITY_TYPE_ASSISTANT);
        mWmState.assertDoesNotContainStack("Must not contain pinned stack.",
                WINDOWING_MODE_PINNED, ACTIVITY_TYPE_STANDARD);
    }

    @Test
    public void testTranslucentAssistantActivityStackVisibility() throws Exception {
        try (final AssistantSession assistantSession = new AssistantSession()) {
            assistantSession.setVoiceInteractionService(ASSISTANT_VOICE_INTERACTION_SERVICE);

            // Go home, launch the assistant and check to see that home is visible
            removeRootTasksInWindowingModes(WINDOWING_MODE_FULLSCREEN);
            pressHomeButton();
            resumeAppSwitches();
            launchActivityNoWait(LAUNCH_ASSISTANT_ACTIVITY_INTO_STACK,
                    extraString(EXTRA_ASSISTANT_IS_TRANSLUCENT, "true"));
            waitForValidStateWithActivityType(
                    TRANSLUCENT_ASSISTANT_ACTIVITY, ACTIVITY_TYPE_ASSISTANT);
            assertAssistantStackExists();
            mWmState.waitForHomeActivityVisible();
            if (hasHomeScreen()) {
                mWmState.assertHomeActivityVisible(true);
            }

            // Launch a fullscreen app and then launch the assistant and check to see that it is
            // also visible
            removeRootTasksWithActivityTypes(ACTIVITY_TYPE_ASSISTANT);
            launchActivityOnDisplay(TEST_ACTIVITY, WINDOWING_MODE_FULLSCREEN, mAssistantDisplayId);
            launchActivityNoWait(LAUNCH_ASSISTANT_ACTIVITY_INTO_STACK,
                    extraString(EXTRA_ASSISTANT_IS_TRANSLUCENT, "true"));
            waitForValidStateWithActivityType(
                    TRANSLUCENT_ASSISTANT_ACTIVITY, ACTIVITY_TYPE_ASSISTANT);
            assertAssistantStackExists();
            mWmState.assertVisibility(TEST_ACTIVITY, true);

            // Go home, launch assistant, launch app into fullscreen with activity present, and go
            // back.Ensure home is visible.
            removeRootTasksWithActivityTypes(ACTIVITY_TYPE_ASSISTANT);
            pressHomeButton();
            resumeAppSwitches();
            launchActivityNoWait(LAUNCH_ASSISTANT_ACTIVITY_INTO_STACK,
                    extraString(EXTRA_ASSISTANT_IS_TRANSLUCENT, "true"),
                    extraString(EXTRA_ASSISTANT_LAUNCH_NEW_TASK, getActivityName(TEST_ACTIVITY)));
            waitForValidStateWithActivityTypeAndWindowingMode(
                    TEST_ACTIVITY, ACTIVITY_TYPE_STANDARD, mDefaultWindowingMode);

            final ComponentName homeActivity = mWmState.getHomeActivityName();
            int windowingMode = mWmState.getFocusedRootTaskWindowingMode();
            // In a multi-window environment the home activity might not be fully covered
            assumeTrue(windowingMode == WINDOWING_MODE_FULLSCREEN);
            mWmState.waitAndAssertVisibilityGone(homeActivity);
            mBroadcastActionTrigger.doAction(TEST_ACTIVITY_ACTION_FINISH_SELF);
            mWmState.waitForFocusedStack(WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_ASSISTANT);
            assertAssistantStackExists();
            mWmState.waitForHomeActivityVisible();
            if (hasHomeScreen()) {
                mWmState.assertHomeActivityVisible(true);
            }

            // Launch a fullscreen and docked app and then launch the assistant and check to see
            // that it
            // is also visible
            if (supportsSplitScreenMultiWindow() &&  assistantRunsOnPrimaryDisplay()) {
                removeRootTasksWithActivityTypes(ACTIVITY_TYPE_ASSISTANT);
                launchActivitiesInSplitScreen(
                        getLaunchActivityBuilder().setTargetActivity(DOCKED_ACTIVITY),
                        getLaunchActivityBuilder().setTargetActivity(TEST_ACTIVITY));
                launchActivityNoWait(LAUNCH_ASSISTANT_ACTIVITY_INTO_STACK,
                        extraString(EXTRA_ASSISTANT_IS_TRANSLUCENT, "true"));
                waitForValidStateWithActivityType(
                        TRANSLUCENT_ASSISTANT_ACTIVITY, ACTIVITY_TYPE_ASSISTANT);
                assertAssistantStackExists();
                mWmState.assertVisibility(DOCKED_ACTIVITY, true);
                mWmState.assertVisibility(TEST_ACTIVITY, true);
            }
        }
    }

    @Test
    public void testLaunchIntoSameTask() throws Exception {
        try (final AssistantSession assistantSession = new AssistantSession()) {
            assistantSession.setVoiceInteractionService(ASSISTANT_VOICE_INTERACTION_SERVICE);

            // Launch the assistant
            launchActivityOnDisplayNoWait(LAUNCH_ASSISTANT_ACTIVITY_FROM_SESSION,
                    mAssistantDisplayId);
            waitForValidStateWithActivityType(ASSISTANT_ACTIVITY, ACTIVITY_TYPE_ASSISTANT);
            assertAssistantStackExists();
            mWmState.assertVisibility(ASSISTANT_ACTIVITY, true);
            mWmState.assertFocusedRootTask("Expected assistant stack focused",
                    WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_ASSISTANT);
            final WindowManagerState amState = mWmState;
            assertThat(amState.getRootTaskByActivityType(ACTIVITY_TYPE_ASSISTANT).getTasks(),
                    hasSize(1));
            final int taskId = mWmState.getTaskByActivity(ASSISTANT_ACTIVITY)
                    .mTaskId;

            // Launch a new fullscreen activity
            // Using Animation Test Activity because it is opaque on all devices.
            launchActivityOnDisplay(ANIMATION_TEST_ACTIVITY, WINDOWING_MODE_FULLSCREEN, mAssistantDisplayId);
            // Wait for animation finished.
            mWmState.waitForActivityState(ANIMATION_TEST_ACTIVITY, STATE_RESUMED);

            if (isAssistantOnTopOfDream()) {
                mWmState.assertVisibility(ASSISTANT_ACTIVITY, true);
            } else {
                mWmState.waitAndAssertVisibilityGone(ASSISTANT_ACTIVITY);
            }

            // Launch the assistant again and ensure that it goes into the same task
            launchActivityOnDisplayNoWait(LAUNCH_ASSISTANT_ACTIVITY_FROM_SESSION,
                    mAssistantDisplayId);
            waitForValidStateWithActivityType(ASSISTANT_ACTIVITY, ACTIVITY_TYPE_ASSISTANT);
            assertAssistantStackExists();
            mWmState.assertVisibility(ASSISTANT_ACTIVITY, true);
            mWmState.assertFocusedRootTask("Expected assistant stack focused",
                    WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_ASSISTANT);
            assertThat(amState.getRootTaskByActivityType(ACTIVITY_TYPE_ASSISTANT).getTasks(),
                    hasSize(1));
            assertEquals(taskId,
                    mWmState.getTaskByActivity(ASSISTANT_ACTIVITY).mTaskId);

        }
    }

    @Test
    public void testPinnedStackWithAssistant() throws Exception {
        assumeTrue(supportsPip());
        assumeTrue(supportsSplitScreenMultiWindow());

        try (final AssistantSession assistantSession = new AssistantSession()) {
            assistantSession.setVoiceInteractionService(ASSISTANT_VOICE_INTERACTION_SERVICE);

            // Launch a fullscreen activity and a PIP activity, then launch the assistant, and
            // ensure that the test activity is still visible
            launchActivity(TEST_ACTIVITY, WINDOWING_MODE_FULLSCREEN);
            launchActivity(PIP_ACTIVITY, extraString(EXTRA_ENTER_PIP, "true"));
            launchActivityNoWait(LAUNCH_ASSISTANT_ACTIVITY_INTO_STACK,
                    extraString(EXTRA_ASSISTANT_IS_TRANSLUCENT, String.valueOf(true)));
            waitForValidStateWithActivityType(
                    TRANSLUCENT_ASSISTANT_ACTIVITY, ACTIVITY_TYPE_ASSISTANT);
            assertAssistantStackExists();
            mWmState.assertVisibility(TRANSLUCENT_ASSISTANT_ACTIVITY, true);
            mWmState.assertVisibility(PIP_ACTIVITY, true);
            mWmState.assertVisibility(TEST_ACTIVITY, true);

        }
    }

    private void waitForValidStateWithActivityType(ComponentName activityName, int activityType)
            throws Exception {
        mWmState.waitForValidState(new WaitForValidActivityState.Builder(activityName)
                .setActivityType(activityType)
                .build());
    }

    private void waitForValidStateWithActivityTypeAndWindowingMode(ComponentName activityName,
            int activityType, int windowingMode) throws Exception {
        mWmState.waitForValidState(new WaitForValidActivityState.Builder(activityName)
                .setActivityType(activityType)
                .setWindowingMode(windowingMode)
                .build());
    }

    /**
     * Asserts that the assistant stack exists.
     */
    private void assertAssistantStackExists() throws Exception {
        mWmState.assertContainsStack("Must contain assistant stack.",
                WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_ASSISTANT);
    }

    // Any 2D Activity in VR mode is run on a special VR virtual display, so check if the Assistant
    // is going to run on the same display as other tasks.
    protected boolean assistantRunsOnPrimaryDisplay() {
        return mAssistantDisplayId == DEFAULT_DISPLAY;
    }

    /**
     * @return Windowing Mode from the default display
     */
    private int getDefaultDisplayWindowingMode() {
        mWmState.computeState();
        return mWmState.getDisplay(DEFAULT_DISPLAY).getWindowingMode();
    }

    /** Helper class to save, set, and restore
     * {@link Settings.Secure#VOICE_INTERACTION_SERVICE} system preference.
     */
    private static class AssistantSession extends SettingsSession<String> {
        AssistantSession() {
            super(Settings.Secure.getUriFor(Settings.Secure.VOICE_INTERACTION_SERVICE),
                    Settings.Secure::getString, Settings.Secure::putString);
        }

        void setVoiceInteractionService(ComponentName assistantName) throws Exception {
            super.set(getActivityName(assistantName));
        }
    }
}