/*
 * Copyright (C) 2015 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.constraintlayout.widget;

import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Canvas;
import android.util.AttributeSet;
import android.view.View;

import androidx.annotation.NonNull;

/**
 * Utility class representing a Guideline helper object for
 * {@link ConstraintLayout}.
 * Helper objects are not displayed on device
 * (they are marked as {@code View.GONE}) and are only used
 * for layout purposes. They only work within a
 * {@link ConstraintLayout}.
 *<p>
 * A Guideline can be either horizontal or vertical:
 * <ul>
 *     <li>Vertical Guidelines have a width of zero and the height of their
 *     {@link ConstraintLayout} parent</li>
 *     <li>Horizontal Guidelines have a height of zero and the width of their
 *     {@link ConstraintLayout} parent</li>
 * </ul>
 *<p>
 * Positioning a Guideline is possible in three different ways:
 * <ul>
 *     <li>specifying a fixed distance from the left or the top of a layout
 *     ({@code layout_constraintGuide_begin})</li>
 *     <li>specifying a fixed distance from the right or the bottom of a layout
 *     ({@code layout_constraintGuide_end})</li>
 *     <li>specifying a percentage of the width or the height of a layout
 *     ({@code layout_constraintGuide_percent})</li>
 * </ul>
 * <p>
 * Widgets can then be constrained to a Guideline,
 * allowing multiple widgets to be positioned easily from
 * one Guideline, or allowing reactive layout behavior by using percent positioning.
 * <p>
 * See the list of attributes in
 * {@link androidx.constraintlayout.widget.ConstraintLayout.LayoutParams} to set a Guideline
 * in XML, as well as the corresponding {@link ConstraintSet#setGuidelineBegin},
 * {@link ConstraintSet#setGuidelineEnd}
 * and {@link ConstraintSet#setGuidelinePercent} functions in {@link ConstraintSet}.
 * <p>
 *   Example of a {@code Button} constrained to a vertical {@code Guideline}:
 *   <pre>{@code
 *          <androidx.constraintlayout.widget.ConstraintLayout
 *              xmlns:android="http://schemas.android.com/apk/res/android"
 *              xmlns:app="http://schemas.android.com/apk/res-auto"
 *              xmlns:tools="http://schemas.android.com/tools"
 *              android:layout_width="match_parent"
 *              android:layout_height="match_parent">
 *
 *              <androidx.constraintlayout.widget.Guideline
 *                  android:layout_width="wrap_content"
 *                  android:layout_height="wrap_content"
 *                  android:id="@+id/guideline"
 *                  app:layout_constraintGuide_begin="100dp"
 *                  android:orientation="vertical"/>
 *              <Button
 *                  android:text="Button"
 *                  android:layout_width="wrap_content"
 *                  android:layout_height="wrap_content"
 *                  android:id="@+id/button"
 *                  app:layout_constraintLeft_toLeftOf="@+id/guideline"
 *                  android:layout_marginTop="16dp"
 *                  app:layout_constraintTop_toTopOf="parent" />
 *          </androidx.constraintlayout.widget.ConstraintLayout>
 *        }
 *  </pre>
 * <p/>
 */
public class Guideline extends View {
    private boolean mFilterRedundantCalls = true;
    public Guideline(Context context) {
        super(context);
        super.setVisibility(View.GONE);
    }

    public Guideline(Context context, AttributeSet attrs) {
        super(context, attrs);
        super.setVisibility(View.GONE);
    }

    public Guideline(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        super.setVisibility(View.GONE);
    }

    public Guideline(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr);
        super.setVisibility(View.GONE);
    }

    /**
     *
     */
    @Override
    public void setVisibility(int visibility) {
    }

    /**
     * We are overriding draw and not calling super.draw() here because
     * Helper objects are not displayed on device.
     *
     *
     */
    @SuppressLint("MissingSuperCall")
    @Override
    public void draw(@NonNull Canvas canvas) {

    }

    /**
     *
     */
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        setMeasuredDimension(0, 0);
    }

    /**
     * Set the guideline's distance from the top or left edge.
     *
     * @param margin the distance to the top or left edge
     */
    public void setGuidelineBegin(int margin) {
        ConstraintLayout.LayoutParams params = (ConstraintLayout.LayoutParams) getLayoutParams();
        if (mFilterRedundantCalls && params.guideBegin == margin) {
            return;
        }
        params.guideBegin = margin;
        setLayoutParams(params);
    }

    /**
     * Set a guideline's distance to end.
     *
     * @param margin the margin to the right or bottom side of container
     */
    public void setGuidelineEnd(int margin) {
        ConstraintLayout.LayoutParams params = (ConstraintLayout.LayoutParams) getLayoutParams();
        if (mFilterRedundantCalls && params.guideEnd == margin) {
            return;
        }
        params.guideEnd = margin;
        setLayoutParams(params);
    }

    /**
     * Set a Guideline's percent.
     * @param ratio the ratio between the gap on the left and right 0.0 is top/left 0.5 is middle
     */
    public void setGuidelinePercent(float ratio) {
        ConstraintLayout.LayoutParams params = (ConstraintLayout.LayoutParams) getLayoutParams();
        if (mFilterRedundantCalls && params.guidePercent == ratio) {
            return;
        }
        params.guidePercent = ratio;
        setLayoutParams(params);
    }

    /**
     * filter redundant calls to setGuidelineBegin, setGuidelineEnd & setGuidelinePercent.
     *
     * By default calling setGuidelineStart,setGuideLineEnd and setGuidelinePercent will do nothing
     * if the value is the same as the current value. This can disable that behaviour and call
     * setLayoutParams(..) while will call requestLayout
     *
     * @param filter default true set false to always generate a setLayoutParams
     */
    public void setFilterRedundantCalls(boolean filter) {
        this.mFilterRedundantCalls = filter;
    }
}