/*
 * Copyright (C) 2021 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 com.android.wm.shell.pip.tv;

import static android.view.KeyEvent.KEYCODE_DPAD_DOWN;
import static android.view.KeyEvent.KEYCODE_DPAD_LEFT;
import static android.view.KeyEvent.KEYCODE_DPAD_RIGHT;
import static android.view.KeyEvent.KEYCODE_DPAD_UP;

import static com.android.wm.shell.pip.tv.TvPipBoundsState.ORIENTATION_HORIZONTAL;
import static com.android.wm.shell.pip.tv.TvPipBoundsState.ORIENTATION_UNDETERMINED;
import static com.android.wm.shell.pip.tv.TvPipBoundsState.ORIENTATION_VERTICAL;

import android.content.Context;
import android.content.res.Resources;
import android.graphics.Insets;
import android.graphics.Rect;
import android.util.ArraySet;
import android.util.Size;
import android.view.Gravity;

import androidx.annotation.NonNull;

import com.android.internal.protolog.common.ProtoLog;
import com.android.wm.shell.R;
import com.android.wm.shell.common.DisplayLayout;
import com.android.wm.shell.pip.PipBoundsAlgorithm;
import com.android.wm.shell.pip.PipKeepClearAlgorithm;
import com.android.wm.shell.pip.PipSnapAlgorithm;
import com.android.wm.shell.pip.tv.TvPipKeepClearAlgorithm.Placement;
import com.android.wm.shell.protolog.ShellProtoLogGroup;

import java.util.Set;

/**
 * Contains pip bounds calculations that are specific to TV.
 */
public class TvPipBoundsAlgorithm extends PipBoundsAlgorithm {

    private static final String TAG = TvPipBoundsAlgorithm.class.getSimpleName();
    private static final boolean DEBUG = TvPipController.DEBUG;

    private final @NonNull TvPipBoundsState mTvPipBoundsState;

    private int mFixedExpandedHeightInPx;
    private int mFixedExpandedWidthInPx;

    private final TvPipKeepClearAlgorithm mKeepClearAlgorithm;

    public TvPipBoundsAlgorithm(Context context,
            @NonNull TvPipBoundsState tvPipBoundsState,
            @NonNull PipSnapAlgorithm pipSnapAlgorithm) {
        super(context, tvPipBoundsState, pipSnapAlgorithm,
                new PipKeepClearAlgorithm() {});
        this.mTvPipBoundsState = tvPipBoundsState;
        this.mKeepClearAlgorithm = new TvPipKeepClearAlgorithm();
        reloadResources(context);
    }

    private void reloadResources(Context context) {
        final Resources res = context.getResources();
        mFixedExpandedHeightInPx = res.getDimensionPixelSize(
                com.android.internal.R.dimen.config_pictureInPictureExpandedHorizontalHeight);
        mFixedExpandedWidthInPx = res.getDimensionPixelSize(
                com.android.internal.R.dimen.config_pictureInPictureExpandedVerticalWidth);
        mKeepClearAlgorithm.setPipAreaPadding(
                res.getDimensionPixelSize(R.dimen.pip_keep_clear_area_padding));
        mKeepClearAlgorithm.setMaxRestrictedDistanceFraction(
                res.getFraction(R.fraction.config_pipMaxRestrictedMoveDistance, 1, 1));
    }

    @Override
    public void onConfigurationChanged(Context context) {
        super.onConfigurationChanged(context);
        reloadResources(context);
    }

    /** Returns the destination bounds to place the PIP window on entry. */
    @Override
    public Rect getEntryDestinationBounds() {
        if (DEBUG) {
            ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                    "%s: getEntryDestinationBounds()", TAG);
        }
        updateExpandedPipSize();
        final boolean isPipExpanded = mTvPipBoundsState.isTvExpandedPipSupported()
                && mTvPipBoundsState.getDesiredTvExpandedAspectRatio() != 0
                && !mTvPipBoundsState.isTvPipManuallyCollapsed();
        if (isPipExpanded) {
            updateGravityOnExpandToggled(Gravity.NO_GRAVITY, true);
        }
        mTvPipBoundsState.setTvPipExpanded(isPipExpanded);
        return adjustBoundsForTemporaryDecor(getTvPipPlacement().getBounds());
    }

    /** Returns the current bounds adjusted to the new aspect ratio, if valid. */
    @Override
    public Rect getAdjustedDestinationBounds(Rect currentBounds, float newAspectRatio) {
        if (DEBUG) {
            ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                    "%s: getAdjustedDestinationBounds: %f", TAG, newAspectRatio);
        }
        return adjustBoundsForTemporaryDecor(getTvPipPlacement().getBounds());
    }

    Rect adjustBoundsForTemporaryDecor(Rect bounds) {
        Rect boundsWithDecor = new Rect(bounds);
        Insets decorInset = mTvPipBoundsState.getPipMenuTemporaryDecorInsets();
        Insets pipDecorReverseInsets = Insets.subtract(Insets.NONE, decorInset);
        boundsWithDecor.inset(decorInset);
        Gravity.apply(mTvPipBoundsState.getTvPipGravity(),
                boundsWithDecor.width(), boundsWithDecor.height(), bounds, boundsWithDecor);

        // remove temporary decoration again
        boundsWithDecor.inset(pipDecorReverseInsets);
        return boundsWithDecor;
    }

    /**
     * Calculates the PiP bounds.
     */
    @NonNull
    public Placement getTvPipPlacement() {
        final Size pipSize = getPipSize();
        final Rect displayBounds = mTvPipBoundsState.getDisplayBounds();
        final Size screenSize = new Size(displayBounds.width(), displayBounds.height());
        final Rect insetBounds = new Rect();
        getInsetBounds(insetBounds);

        Set<Rect> restrictedKeepClearAreas = mTvPipBoundsState.getRestrictedKeepClearAreas();
        Set<Rect> unrestrictedKeepClearAreas = mTvPipBoundsState.getUnrestrictedKeepClearAreas();

        if (mTvPipBoundsState.isImeShowing()) {
            if (DEBUG) {
                ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                        "%s: IME showing, height: %d",
                        TAG, mTvPipBoundsState.getImeHeight());
            }

            final Rect imeBounds = new Rect(
                    0,
                    insetBounds.bottom - mTvPipBoundsState.getImeHeight(),
                    insetBounds.right,
                    insetBounds.bottom);

            unrestrictedKeepClearAreas = new ArraySet<>(unrestrictedKeepClearAreas);
            unrestrictedKeepClearAreas.add(imeBounds);
        }

        mKeepClearAlgorithm.setGravity(mTvPipBoundsState.getTvPipGravity());
        mKeepClearAlgorithm.setScreenSize(screenSize);
        mKeepClearAlgorithm.setMovementBounds(insetBounds);
        mKeepClearAlgorithm.setStashOffset(mTvPipBoundsState.getStashOffset());
        mKeepClearAlgorithm.setPipPermanentDecorInsets(
                mTvPipBoundsState.getPipMenuPermanentDecorInsets());

        final Placement placement = mKeepClearAlgorithm.calculatePipPosition(
                pipSize,
                restrictedKeepClearAreas,
                unrestrictedKeepClearAreas);

        if (DEBUG) {
            ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                    "%s: screenSize: %s", TAG, screenSize);
            ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                    "%s: stashOffset: %d", TAG, mTvPipBoundsState.getStashOffset());
            ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                    "%s: insetBounds: %s", TAG, insetBounds.toShortString());
            ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                    "%s: pipSize: %s", TAG, pipSize);
            ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                    "%s: gravity: %s", TAG, Gravity.toString(mTvPipBoundsState.getTvPipGravity()));
            ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                    "%s: restrictedKeepClearAreas: %s", TAG, restrictedKeepClearAreas);
            ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                    "%s: unrestrictedKeepClearAreas: %s", TAG, unrestrictedKeepClearAreas);
            ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                    "%s: placement: %s", TAG, placement);
        }

        return placement;
    }

    /**
     * @return previous gravity if it is to be saved, or {@link Gravity#NO_GRAVITY} if not.
     */
    int updateGravityOnExpandToggled(int previousGravity, boolean expanding) {
        if (DEBUG) {
            ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                    "%s: updateGravityOnExpandToggled(), expanding: %b"
                    + ", mOrientation: %d, previous gravity: %s",
                    TAG, expanding, mTvPipBoundsState.getTvFixedPipOrientation(),
                    Gravity.toString(previousGravity));
        }

        if (!mTvPipBoundsState.isTvExpandedPipSupported()) {
            return Gravity.NO_GRAVITY;
        }

        if (expanding && mTvPipBoundsState.getTvFixedPipOrientation() == ORIENTATION_UNDETERMINED) {
            float expandedRatio = mTvPipBoundsState.getDesiredTvExpandedAspectRatio();
            if (expandedRatio == 0) {
                return Gravity.NO_GRAVITY;
            }
            if (expandedRatio < 1) {
                mTvPipBoundsState.setTvFixedPipOrientation(ORIENTATION_VERTICAL);
            } else {
                mTvPipBoundsState.setTvFixedPipOrientation(ORIENTATION_HORIZONTAL);
            }
        }

        int gravityToSave = Gravity.NO_GRAVITY;
        int currentGravity = mTvPipBoundsState.getTvPipGravity();
        int updatedGravity;

        if (expanding) {
            // save collapsed gravity
            gravityToSave = mTvPipBoundsState.getTvPipGravity();

            if (mTvPipBoundsState.getTvFixedPipOrientation() == ORIENTATION_HORIZONTAL) {
                updatedGravity =
                        Gravity.CENTER_HORIZONTAL | (currentGravity
                                & Gravity.VERTICAL_GRAVITY_MASK);
            } else {
                updatedGravity =
                        Gravity.CENTER_VERTICAL | (currentGravity
                                & Gravity.HORIZONTAL_GRAVITY_MASK);
            }
        } else {
            if (previousGravity != Gravity.NO_GRAVITY) {
                // The pip hasn't been moved since expanding,
                // go back to previous collapsed position.
                updatedGravity = previousGravity;
            } else {
                if (mTvPipBoundsState.getTvFixedPipOrientation() == ORIENTATION_HORIZONTAL) {
                    updatedGravity =
                            Gravity.RIGHT | (currentGravity & Gravity.VERTICAL_GRAVITY_MASK);
                } else {
                    updatedGravity =
                            Gravity.BOTTOM | (currentGravity & Gravity.HORIZONTAL_GRAVITY_MASK);
                }
            }
        }
        mTvPipBoundsState.setTvPipGravity(updatedGravity);
        if (DEBUG) {
            ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                    "%s: new gravity: %s", TAG, Gravity.toString(updatedGravity));
        }

        return gravityToSave;
    }

    /**
     * @return true if gravity changed
     */
    boolean updateGravity(int keycode) {
        if (DEBUG) {
            ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                    "%s: updateGravity, keycode: %d", TAG, keycode);
        }

        // Check if position change is valid
        if (mTvPipBoundsState.isTvPipExpanded()) {
            int mOrientation = mTvPipBoundsState.getTvFixedPipOrientation();
            if (mOrientation == ORIENTATION_VERTICAL
                    && (keycode == KEYCODE_DPAD_UP || keycode == KEYCODE_DPAD_DOWN)
                    || mOrientation == ORIENTATION_HORIZONTAL
                    && (keycode == KEYCODE_DPAD_RIGHT || keycode == KEYCODE_DPAD_LEFT)) {
                return false;
            }
        }

        int currentGravity = mTvPipBoundsState.getTvPipGravity();
        int updatedGravity;
        // First axis
        switch (keycode) {
            case KEYCODE_DPAD_UP:
                updatedGravity = Gravity.TOP;
                break;
            case KEYCODE_DPAD_DOWN:
                updatedGravity = Gravity.BOTTOM;
                break;
            case KEYCODE_DPAD_LEFT:
                updatedGravity = Gravity.LEFT;
                break;
            case KEYCODE_DPAD_RIGHT:
                updatedGravity = Gravity.RIGHT;
                break;
            default:
                updatedGravity = currentGravity;
        }

        // Second axis
        switch (keycode) {
            case KEYCODE_DPAD_UP:
            case KEYCODE_DPAD_DOWN:
                if (mTvPipBoundsState.isTvPipExpanded()) {
                    updatedGravity |= Gravity.CENTER_HORIZONTAL;
                } else {
                    updatedGravity |= (currentGravity & Gravity.HORIZONTAL_GRAVITY_MASK);
                }
                break;
            case KEYCODE_DPAD_LEFT:
            case KEYCODE_DPAD_RIGHT:
                if (mTvPipBoundsState.isTvPipExpanded()) {
                    updatedGravity |= Gravity.CENTER_VERTICAL;
                } else {
                    updatedGravity |= (currentGravity & Gravity.VERTICAL_GRAVITY_MASK);
                }
                break;
            default:
                break;
        }

        if (updatedGravity != currentGravity) {
            mTvPipBoundsState.setTvPipGravity(updatedGravity);
            if (DEBUG) {
                ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                        "%s: new gravity: %s", TAG, Gravity.toString(updatedGravity));
            }
            return true;
        }
        return false;
    }

    private Size getPipSize() {
        final boolean isExpanded =
                mTvPipBoundsState.isTvExpandedPipSupported() && mTvPipBoundsState.isTvPipExpanded()
                        && mTvPipBoundsState.getDesiredTvExpandedAspectRatio() != 0;
        if (isExpanded) {
            return mTvPipBoundsState.getTvExpandedSize();
        } else {
            final Rect normalBounds = getNormalBounds();
            return new Size(normalBounds.width(), normalBounds.height());
        }
    }

    /**
     * Updates {@link TvPipBoundsState#getTvExpandedSize()} based on
     * {@link TvPipBoundsState#getDesiredTvExpandedAspectRatio()}, the screen size.
     */
    void updateExpandedPipSize() {
        final DisplayLayout displayLayout = mTvPipBoundsState.getDisplayLayout();
        final float expandedRatio =
                mTvPipBoundsState.getDesiredTvExpandedAspectRatio(); // width / height
        final Insets pipDecorations = mTvPipBoundsState.getPipMenuPermanentDecorInsets();

        final Size expandedSize;
        if (expandedRatio == 0) {
            ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                       "%s: updateExpandedPipSize(): Expanded mode aspect ratio"
                               + " of 0 not supported", TAG);
            return;
        } else if (expandedRatio < 1) {
            // vertical
            if (mTvPipBoundsState.getTvFixedPipOrientation() == ORIENTATION_HORIZONTAL) {
                expandedSize = mTvPipBoundsState.getTvExpandedSize();
            } else {
                int maxHeight = displayLayout.height() - (2 * mScreenEdgeInsets.y)
                        - pipDecorations.top - pipDecorations.bottom;
                float aspectRatioHeight = mFixedExpandedWidthInPx / expandedRatio;

                if (maxHeight > aspectRatioHeight) {
                    if (DEBUG) {
                        ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                                "%s: Accommodate aspect ratio", TAG);
                    }
                    expandedSize = new Size(mFixedExpandedWidthInPx, (int) aspectRatioHeight);
                } else {
                    if (DEBUG) {
                        ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                                "%s: Aspect ratio is too extreme, use max size", TAG);
                    }
                    expandedSize = new Size(mFixedExpandedWidthInPx, maxHeight);
                }
            }
        } else {
            // horizontal
            if (mTvPipBoundsState.getTvFixedPipOrientation() == ORIENTATION_VERTICAL) {
                expandedSize = mTvPipBoundsState.getTvExpandedSize();
            } else {
                int maxWidth = displayLayout.width() - (2 * mScreenEdgeInsets.x)
                        - pipDecorations.left - pipDecorations.right;
                float aspectRatioWidth = mFixedExpandedHeightInPx * expandedRatio;
                if (maxWidth > aspectRatioWidth) {
                    if (DEBUG) {
                        ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                                "%s: Accommodate aspect ratio", TAG);
                    }
                    expandedSize = new Size((int) aspectRatioWidth, mFixedExpandedHeightInPx);
                } else {
                    if (DEBUG) {
                        ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                                "%s: Aspect ratio is too extreme, use max size", TAG);
                    }
                    expandedSize = new Size(maxWidth, mFixedExpandedHeightInPx);
                }
            }
        }

        mTvPipBoundsState.setTvExpandedSize(expandedSize);
        if (DEBUG) {
            ProtoLog.d(ShellProtoLogGroup.WM_SHELL_PICTURE_IN_PICTURE,
                       "%s: updateExpandedPipSize(): expanded size, width: %d, height: %d",
                    TAG, expandedSize.getWidth(), expandedSize.getHeight());
        }
    }
}