/*
 * Copyright 2020 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.window;

import android.graphics.Rect;

import androidx.annotation.IntDef;
import androidx.annotation.NonNull;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

/**
 * Description of a physical feature on the display.
 *
 * <p>A display feature is a distinctive physical attribute located within the display panel of
 * the device. It can intrude into the application window space and create a visual distortion,
 * visual or touch discontinuity, make some area invisible or create a logical divider or separation
 * in the screen space.
 *
 * @see #TYPE_FOLD
 * @see #TYPE_HINGE
 */
public final class DisplayFeature {
    private final Rect mBounds;
    @Type
    private int mType;

    DisplayFeature(@NonNull Rect bounds, @Type int type) {
        mBounds = new Rect(bounds);
        mType = type;
    }

    /**
     * Get bounding rectangle of the physical display feature in the coordinate space of the window.
     * The rectangle provides information about the location of the feature in the window and its
     * size.
     */
    @NonNull
    public Rect getBounds() {
        return mBounds;
    }

    /**
     * Get type of the physical display feature.
     */
    @Type
    public int getType() {
        return mType;
    }

    /**
     * A fold in the flexible screen without a physical gap.
     */
    public static final int TYPE_FOLD = 1;

    /**
     * A physical separation with a hinge that allows two display panels to fold.
     */
    public static final int TYPE_HINGE = 2;

    @Retention(RetentionPolicy.SOURCE)
    @IntDef({
            TYPE_FOLD,
            TYPE_HINGE,
    })
    @interface Type{}

    private String typeToString(@Type int type) {
        switch (type) {
            case TYPE_FOLD:
                return "FOLD";
            case TYPE_HINGE:
                return "HINGE";
            default:
                return "Unknown feature type (" + type + ")";
        }
    }

    @NonNull
    @Override
    public String toString() {
        return "DisplayFeature{ bounds=" + mBounds + ", type=" + typeToString(mType) + " }";
    }

    /**
     * Builder for {@link DisplayFeature} objects.
     */
    public static class Builder {
        private Rect mBounds = new Rect();
        @Type
        private int mType = TYPE_FOLD;

        /**
         * Creates an initially empty builder.
         */
        public Builder() {
        }

        /**
         * Set the bounds for the {@link DisplayFeature} instance.
         */
        @NonNull
        public Builder setBounds(@NonNull Rect bounds) {
            mBounds = bounds;
            return this;
        }

        /**
         * Set the type for the {@link DisplayFeature} instance.
         */
        @NonNull
        public Builder setType(@Type int type) {
            mType = type;
            return this;
        }

        /**
         * Creates a {@link DisplayFeature} instance with the specified fields.
         * @return A DisplayFeature instance.
         */
        @NonNull
        public DisplayFeature build() {
            return new DisplayFeature(mBounds, mType);
        }
    }
}