/*
 * Copyright (C) 2023 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.insets;

import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
import static android.graphics.Insets.NONE;
import static android.view.Display.DEFAULT_DISPLAY;
import static android.view.WindowInsets.Type.captionBar;
import static android.view.WindowInsets.Type.navigationBars;
import static android.view.WindowInsets.Type.statusBars;
import static android.view.WindowInsets.Type.systemBars;
import static android.view.WindowInsetsAnimation.Callback.DISPATCH_MODE_CONTINUE_ON_SUBTREE;

import static androidx.test.InstrumentationRegistry.getInstrumentation;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assume.assumeFalse;
import static org.junit.Assume.assumeTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.CALLS_REAL_METHODS;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.withSettings;

import android.platform.test.annotations.Presubmit;
import android.server.wm.WindowInsetsAnimationTestBase;
import android.view.View;
import android.view.WindowInsets;
import android.view.WindowInsetsAnimation;
import android.view.WindowInsetsAnimation.Bounds;
import android.view.WindowInsetsAnimation.Callback;

import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;

import java.util.List;

/**
 * Test whether {@link WindowInsetsAnimation.Callback} are properly dispatched to views.
 *
 * <p>Build/Install/Run: atest CtsWindowManagerDeviceInsets:WindowInsetsAnimationTests
 */
@Presubmit
@android.server.wm.annotation.Group2
public class WindowInsetsAnimationTests extends WindowInsetsAnimationTestBase {

    @Before
    public void setup() throws Exception {
        super.setUp();
        mActivity =
                startActivity(TestActivity.class, DEFAULT_DISPLAY, true, WINDOWING_MODE_FULLSCREEN);
        mRootView = mActivity.getWindow().getDecorView();
        assumeTrue(hasWindowInsets(mRootView, systemBars()));
        assumeFalse(isCar() && remoteInsetsControllerControlsSystemBars());
    }

    @Test
    public void testAnimationCallbacksHide() {
        WindowInsets before = mActivity.mLastWindowInsets;

        getInstrumentation()
                .runOnMainSync(() -> mRootView.getWindowInsetsController().hide(systemBars()));

        waitForOrFail("Waiting until animation done", () -> mActivity.mCallback.animationDone);

        commonAnimationAssertions(
                mActivity, before, false /* show */, systemBars() & ~captionBar());
    }

    @Test
    public void testAnimationCallbacksShow() {
        getInstrumentation()
                .runOnMainSync(() -> mRootView.getWindowInsetsController().hide(systemBars()));

        waitForOrFail("Waiting until animation done", () -> mActivity.mCallback.animationDone);
        mActivity.mCallback.animationDone = false;

        WindowInsets before = mActivity.mLastWindowInsets;

        getInstrumentation()
                .runOnMainSync(() -> mRootView.getWindowInsetsController().show(systemBars()));

        waitForOrFail("Waiting until animation done", () -> mActivity.mCallback.animationDone);

        commonAnimationAssertions(mActivity, before, true /* show */, systemBars() & ~captionBar());
    }

    @Test
    public void testAnimationCallbacks_overlapping() {
        assumeTrue(
                "Test requires navBar and statusBar to create overlapping animations.",
                hasWindowInsets(mRootView, navigationBars())
                        && hasWindowInsets(mRootView, statusBars()));

        WindowInsets before = mActivity.mLastWindowInsets;
        MultiAnimCallback callbackInner = new MultiAnimCallback();
        MultiAnimCallback callback =
                mock(
                        MultiAnimCallback.class,
                        withSettings()
                                .spiedInstance(callbackInner)
                                .defaultAnswer(CALLS_REAL_METHODS)
                                .verboseLogging());
        mActivity.mView.setWindowInsetsAnimationCallback(callback);
        callback.startRunnable =
                () ->
                        mRootView.postDelayed(
                                () -> mRootView.getWindowInsetsController().hide(statusBars()), 50);

        getInstrumentation()
                .runOnMainSync(() -> mRootView.getWindowInsetsController().hide(navigationBars()));

        waitForOrFail("Waiting until animation done", () -> callback.animationDone);

        WindowInsets after = mActivity.mLastWindowInsets;

        InOrder inOrder = inOrder(callback, mActivity.mListener);

        inOrder.verify(callback).onPrepare(eq(callback.navBarAnim));

        inOrder.verify(mActivity.mListener)
                .onApplyWindowInsets(
                        any(),
                        argThat(
                                argument ->
                                        NONE.equals(argument.getInsets(navigationBars()))
                                                && !NONE.equals(argument.getInsets(statusBars()))));

        inOrder.verify(callback)
                .onStart(
                        eq(callback.navBarAnim),
                        argThat(
                                argument ->
                                        argument.getLowerBound().equals(NONE)
                                                && argument.getUpperBound()
                                                        .equals(
                                                                before.getInsets(
                                                                        navigationBars()))));

        inOrder.verify(callback).onPrepare(eq(callback.statusBarAnim));
        inOrder.verify(mActivity.mListener)
                .onApplyWindowInsets(any(), eq(mActivity.mLastWindowInsets));

        inOrder.verify(callback)
                .onStart(
                        eq(callback.statusBarAnim),
                        argThat(
                                argument ->
                                        argument.getLowerBound().equals(NONE)
                                                && argument.getUpperBound()
                                                        .equals(before.getInsets(statusBars()))));

        inOrder.verify(callback).onEnd(eq(callback.navBarAnim));
        inOrder.verify(callback).onEnd(eq(callback.statusBarAnim));

        assertAnimationSteps(callback.navAnimSteps, false /* showAnimation */);
        assertAnimationSteps(callback.statusAnimSteps, false /* showAnimation */);

        assertEquals(
                before.getInsets(navigationBars()),
                callback.navAnimSteps.get(0).insets.getInsets(navigationBars()));
        assertEquals(
                after.getInsets(navigationBars()),
                callback.navAnimSteps
                        .get(callback.navAnimSteps.size() - 1)
                        .insets
                        .getInsets(navigationBars()));

        assertEquals(
                before.getInsets(statusBars()),
                callback.statusAnimSteps.get(0).insets.getInsets(statusBars()));
        assertEquals(
                after.getInsets(statusBars()),
                callback.statusAnimSteps
                        .get(callback.statusAnimSteps.size() - 1)
                        .insets
                        .getInsets(statusBars()));
    }

    @Test
    public void testAnimationCallbacks_consumedByDecor() {
        getInstrumentation()
                .runOnMainSync(
                        () -> {
                            mActivity.getWindow().setDecorFitsSystemWindows(true);
                            mRootView.getWindowInsetsController().hide(systemBars());
                        });

        getWmState()
                .waitFor(
                        state -> !state.isWindowVisible("StatusBar"),
                        "Waiting for status bar to be hidden");
        assertFalse(getWmState().isWindowVisible("StatusBar"));

        verifyZeroInteractions(mActivity.mCallback);
    }

    @Test
    public void testAnimationCallbacks_childDoesntGetCallback() {
        WindowInsetsAnimation.Callback childCallback = mock(WindowInsetsAnimation.Callback.class);

        getInstrumentation()
                .runOnMainSync(
                        () -> {
                            mActivity.mChild.setWindowInsetsAnimationCallback(childCallback);
                            mRootView.getWindowInsetsController().hide(systemBars());
                        });

        waitForOrFail("Waiting until animation done", () -> mActivity.mCallback.animationDone);

        verifyZeroInteractions(childCallback);
    }

    @Test
    public void testAnimationCallbacks_childInsetting() {
        // test requires navbar.
        assumeTrue(hasWindowInsets(mRootView, navigationBars()));

        WindowInsets before = mActivity.mLastWindowInsets;
        boolean[] done = new boolean[1];
        WindowInsetsAnimation.Callback childCallback = mock(WindowInsetsAnimation.Callback.class);
        WindowInsetsAnimation.Callback callback =
                new Callback(DISPATCH_MODE_CONTINUE_ON_SUBTREE) {

                    @Override
                    public Bounds onStart(WindowInsetsAnimation animation, Bounds bounds) {
                        return bounds.inset(before.getInsets(navigationBars()));
                    }

                    @Override
                    public WindowInsets onProgress(
                            WindowInsets insets, List<WindowInsetsAnimation> runningAnimations) {
                        return insets.inset(insets.getInsets(navigationBars()));
                    }

                    @Override
                    public void onEnd(WindowInsetsAnimation animation) {
                        done[0] = true;
                    }
                };

        getInstrumentation()
                .runOnMainSync(
                        () -> {
                            mActivity.mView.setWindowInsetsAnimationCallback(callback);
                            mActivity.mChild.setWindowInsetsAnimationCallback(childCallback);
                            mRootView.getWindowInsetsController().hide(systemBars());
                        });

        waitForOrFail("Waiting until animation done", () -> done[0]);

        if (hasWindowInsets(mRootView, statusBars())) {
            verify(childCallback)
                    .onStart(
                            any(),
                            argThat(
                                    bounds ->
                                            bounds.getUpperBound()
                                                    .equals(before.getInsets(statusBars()))));
        }
        if (hasWindowInsets(mRootView, navigationBars())) {
            verify(childCallback, atLeastOnce())
                    .onProgress(
                            argThat(insets -> NONE.equals(insets.getInsets(navigationBars()))),
                            any());
        }
    }

    @Test
    public void testAnimationCallbacks_withLegacyFlags() {
        getInstrumentation()
                .runOnMainSync(
                        () -> {
                            mActivity.getWindow().setDecorFitsSystemWindows(true);
                            mRootView.setSystemUiVisibility(
                                    View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                                            | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                                            | View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
                            mRootView.post(
                                    () -> {
                                        mRootView.getWindowInsetsController().hide(systemBars());
                                    });
                        });

        waitForOrFail("Waiting until animation done", () -> mActivity.mCallback.animationDone);

        mWmState.computeState();
        assertFalse(mWmState.isWindowVisible("StatusBar"));
        verify(mActivity.mCallback).onPrepare(any());
        verify(mActivity.mCallback).onStart(any(), any());
        verify(mActivity.mCallback, atLeastOnce()).onProgress(any(), any());
        verify(mActivity.mCallback).onEnd(any());
    }
}