/**
 * Copyright (c) 2015-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 */

package com.facebook.react.flat;

import javax.annotation.Nullable;

import android.graphics.Canvas;
import android.graphics.Path;
import android.graphics.RectF;

/* package */ final class DrawView extends AbstractDrawCommand {
  public static final DrawView[] EMPTY_ARRAY = new DrawView[0];
  // the minimum rounded clipping value before we actually do rounded clipping
  /* package */ static final float MINIMUM_ROUNDED_CLIPPING_VALUE = 0.5f;
  private final RectF TMP_RECT = new RectF();

  /* package */ final int reactTag;
  // Indicates whether this DrawView has been previously mounted to a clipping FlatViewGroup.  This
  // lets us know that the bounds haven't changed, as a bounds change would trigger a new DrawView,
  // which will set this to false for the new DrawView.  This is safe, despite the dual access with
  // FlatViewGroup, because the FlatViewGroup copy is only ever modified by the FlatViewGroup.
  // Changing how this boolean is used should be handled with caution, as race conditions are the
  // quickest way to create unreproducible super bugs.
  /* package */ boolean mWasMounted;

  // the clipping radius - if this is greater than MINIMUM_ROUNDED_CLIPPING_VALUE, we clip using
  // a rounded path, otherwise we clip in a rectangular fashion.
  private float mClipRadius;

  // the path to clip against if we're doing path clipping for rounded borders.
  @Nullable private Path mPath;

  // These should only ever be set from within the DrawView, they serve to provide clipping bounds
  // for FlatViewGroups, which have strange clipping when it comes to overflow: visible.  They are
  // left package protected to speed up direct access.  For overflow visible, these are the adjusted
  // bounds while taking overflowing elements into account, other wise they are just the regular
  // bounds of the view.
  /* package */ float mLogicalLeft;
  /* package */ float mLogicalTop;
  /* package */ float mLogicalRight;
  /* package */ float mLogicalBottom;

  public DrawView(int reactTag) {
    this.reactTag = reactTag;
  }

  /**
   * Similar to updateBoundsAndFreeze, but thread safe as the mounting flag is modified on the UI
   * thread.
   *
   * @return A DrawView with the passed bounds and clipping bounds.  If we can use the same
   *     DrawView, it will just be this, otherwise it will be a frozen copy.
   */
  public DrawView collectDrawView(
      float left,
      float top,
      float right,
      float bottom,
      float logicalLeft,
      float logicalTop,
      float logicalRight,
      float logicalBottom,
      float clipLeft,
      float clipTop,
      float clipRight,
      float clipBottom,
      float clipRadius) {
    if (!isFrozen()) {
      // We haven't collected this draw view yet, so we can just set everything.
      setBounds(left, top, right, bottom);
      setClipBounds(clipLeft, clipTop, clipRight, clipBottom);
      setClipRadius(clipRadius);
      setLogicalBounds(logicalLeft, logicalTop, logicalRight, logicalBottom);
      freeze();
      return this;
    }

    boolean boundsMatch = boundsMatch(left, top, right, bottom);
    boolean clipBoundsMatch = clipBoundsMatch(clipLeft, clipTop, clipRight, clipBottom);
    boolean clipRadiusMatch = mClipRadius == clipRadius;
    boolean logicalBoundsMatch =
        logicalBoundsMatch(logicalLeft, logicalTop, logicalRight, logicalBottom);

    // See if we can reuse the draw view.
    if (boundsMatch && clipBoundsMatch && clipRadiusMatch && logicalBoundsMatch) {
      return this;
    }

    DrawView drawView = (DrawView) mutableCopy();

    if (!boundsMatch) {
      drawView.setBounds(left, top, right, bottom);
    }

    if (!clipBoundsMatch) {
      drawView.setClipBounds(clipLeft, clipTop, clipRight, clipBottom);
    }

    if (!logicalBoundsMatch) {
      drawView.setLogicalBounds(logicalLeft, logicalTop, logicalRight, logicalBottom);
    }

    if (!clipRadiusMatch || !boundsMatch) {
      // If the bounds change, we need to update the clip path.
      drawView.setClipRadius(clipRadius);
    }

    // It is very important that we unset this, as our spec is that newly created DrawViews
    // are handled differently by the FlatViewGroup.  This is needed because clone() maintains
    // the previous state.
    drawView.mWasMounted = false;

    drawView.freeze();

    return drawView;
  }

  private boolean logicalBoundsMatch(float left, float top, float right, float bottom) {
    return left == mLogicalLeft && top == mLogicalTop &&
        right == mLogicalRight && bottom == mLogicalBottom;
  }

  private void setLogicalBounds(float left, float top, float right, float bottom) {
    // Do rounding up front and off of the UI thread.
    mLogicalLeft = left;
    mLogicalTop = top;
    mLogicalRight = right;
    mLogicalBottom = bottom;
  }

  @Override
  public void draw(FlatViewGroup parent, Canvas canvas) {
    onPreDraw(parent, canvas);
    if (mNeedsClipping || mClipRadius > MINIMUM_ROUNDED_CLIPPING_VALUE) {
      canvas.save(Canvas.CLIP_SAVE_FLAG);
      applyClipping(canvas);
      parent.drawNextChild(canvas);
      canvas.restore();
    } else {
      parent.drawNextChild(canvas);
    }
  }

  /**
   * Set the clip radius.  Should only be called when the clip radius is first set or when it
   * changes, in order to avoid extra work.
   *
   * @param clipRadius The new clip radius.
   */
  void setClipRadius(float clipRadius) {
    mClipRadius = clipRadius;
    if (clipRadius > MINIMUM_ROUNDED_CLIPPING_VALUE) {
      // update the path that we'll clip based on
      updateClipPath();
    } else {
      mPath = null;
    }
  }

  /**
   * Update the path with which we'll clip this view
   */
  private void updateClipPath() {
    mPath = new Path();

    TMP_RECT.set(
        getLeft(),
        getTop(),
        getRight(),
        getBottom());

    // set the path
    mPath.addRoundRect(
        TMP_RECT,
        mClipRadius,
        mClipRadius,
        Path.Direction.CW);
  }

  @Override
  protected void applyClipping(Canvas canvas) {
    // only clip using a path if our radius is greater than some minimum threshold, because
    // clipPath is more expensive than clipRect.
    if (mClipRadius > MINIMUM_ROUNDED_CLIPPING_VALUE) {
      canvas.clipPath(mPath);
    } else {
      super.applyClipping(canvas);
    }
  }

  @Override
  protected void onDraw(Canvas canvas) {
    // no op as we override draw.
  }

  @Override
  protected void onDebugDraw(FlatViewGroup parent, Canvas canvas) {
    parent.debugDrawNextChild(canvas);
  }

  @Override
  protected void onDebugDrawHighlight(Canvas canvas) {
    if (mPath != null) {
      debugDrawWarningHighlight(canvas, "borderRadius: " + mClipRadius);
    } else if (!boundsMatch(mLogicalLeft, mLogicalTop, mLogicalRight, mLogicalBottom)) {
      StringBuilder warn = new StringBuilder("Overflow: { ");
      String[] names = { "left: ", "top: ", "right: ", "bottom: "};
      int i = 0;
      float[] offsets = new float[4];
      offsets[i++] = getLeft() - mLogicalLeft;
      offsets[i++] = getTop() - mLogicalTop;
      offsets[i++] = mLogicalRight - getRight();
      offsets[i++] = mLogicalBottom - getBottom();

      for (i = 0; i < 4; i++) {
        if (offsets[i] != 0f) {
          warn.append(names[i]);
          warn.append(offsets[i]);
          warn.append(", ");
        }
      }

      warn.append("}");

      debugDrawCautionHighlight(canvas, warn.toString());
    }
  }
}