import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.PointF;
import android.support.annotation.Nullable;
import android.support.v4.content.ContextCompat;
import android.util.AttributeSet;
import android.view.View;
import android.view.animation.AccelerateDecelerateInterpolator;
import android.view.animation.Animation;
import android.view.animation.Transformation;

/**
 * Created by xuie on 17-3-2.
 */

public class DropWater extends View {
    private static final String TAG = "DropWater";
    private Context mContext;
    private Path mPath;
    private Paint mPaint;
    private VPoint a = new VPoint();
    private HPoint b = new HPoint();
    private VPoint c = new VPoint();
    private HPoint d = new HPoint();
    private int width;
    private int height;
    private float mInterpolatedTime;
    private int centerX;
    private int centerY;
    private static final float blackMagic = 0.552284749831f;
    private float magic;
    private float radius;


    public DropWater(Context context) {
        super(context);
        mContext = context;
        init();
    }

    public DropWater(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        mContext = context;
        init();
    }

    public DropWater(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    private void init() {
        mPath = new Path();
        mPaint = new Paint();
        mPaint.setColor(ContextCompat.getColor(mContext, android.R.color.holo_red_light));
        mPaint.setStyle(Paint.Style.FILL);
        mPaint.setStrokeWidth(1);
        mPaint.setAntiAlias(true);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        mPath.reset();
        canvas.translate((width - radius * 2) * (mInterpolatedTime - 0.5f), 0);

        if (mInterpolatedTime >= 0 && mInterpolatedTime < 0.2) {
            a.x = centerX - radius;
            a.y = centerY;
            a.top.x = a.x;
            a.top.y = a.y - magic;
            a.bottom.x = a.x;
            a.bottom.y = a.y + magic;

            b.x = centerX;
            b.y = centerY - radius * (1 - getOffset(mInterpolatedTime, 0.2f));
            b.left.x = b.x - magic;
            b.left.y = b.y;
            b.right.x = b.x + magic;
            b.right.y = b.y;

            c.x = centerX + radius + (mInterpolatedTime) / 0.2f * radius;
            c.y = centerY;
            c.top.x = c.x;
            c.top.y = c.y - magic;
            c.bottom.x = c.x;
            c.bottom.y = c.y + magic;

            d.x = centerX;
            d.y = centerY + radius * (1 - getOffset(mInterpolatedTime, 0.2f));
            d.left.x = d.x - magic;
            d.left.y = d.y;
            d.right.x = d.x + magic;
            d.right.y = d.y;
        } else if (mInterpolatedTime >= 0.2 && mInterpolatedTime < 0.5) {
            a.x = centerX - radius - (mInterpolatedTime - 0.2f) / 0.3f * radius * 0.5f;
            a.y = centerY;
            a.top.x = a.x;
            a.top.y = a.y - magic;
            a.bottom.x = a.x;
            a.bottom.y = a.y + magic;

            b.x = centerX;
            b.y = centerY - radius * (1 - getOffset(1, 1));
            b.left.x = b.x - magic;
            b.left.y = b.y;
            b.right.x = b.x + magic;
            b.right.y = b.y;

            c.x = centerX + radius * 2;
            c.y = centerY;
            c.top.x = c.x;
            c.top.y = c.y - magic;
            c.bottom.x = c.x;
            c.bottom.y = c.y + magic;

            d.x = centerX;
            d.y = centerY + radius * (1 - getOffset(1, 1));
            d.left.x = d.x - magic;
            d.left.y = d.y;
            d.right.x = d.x + magic;
            d.right.y = d.y;
        } else if (mInterpolatedTime >= 0.5 && mInterpolatedTime < 0.8) {
            a.x = centerX - radius * 1.5f;
            a.y = centerY;
            a.top.x = a.x;
            a.top.y = a.y - magic;
            a.bottom.x = a.x;
            a.bottom.y = a.y + magic;

            b.x = centerX;
            b.y = centerY - radius * (1 - getOffset(1, 1));
            b.left.x = b.x - magic;
            b.left.y = b.y;
            b.right.x = b.x + magic;
            b.right.y = b.y;

            c.x = centerX + radius * 2 - (mInterpolatedTime - 0.5f) / 0.3f * radius;
            c.y = centerY;
            c.top.x = c.x;
            c.top.y = c.y - magic;
            c.bottom.x = c.x;
            c.bottom.y = c.y + magic;

            d.x = centerX;
            d.y = centerY + radius * (1 - getOffset(1, 1));
            d.left.x = d.x - magic;
            d.left.y = d.y;
            d.right.x = d.x + magic;
            d.right.y = d.y;
        } else if (mInterpolatedTime >= 0.8 && mInterpolatedTime < 0.9) {
            a.x = centerX - radius * 1.5f + (mInterpolatedTime - 0.8f) / 0.1f * radius * 0.5f;
            a.y = centerY;
            a.top.x = a.x;
            a.top.y = a.y - magic;
            a.bottom.x = a.x;
            a.bottom.y = a.y + magic;

            b.x = centerX;
            b.y = centerY - radius * (1 - getOffset(0.1f - (mInterpolatedTime - 0.8f), 0.1f));
            b.left.x = b.x - magic;
            b.left.y = b.y;
            b.right.x = b.x + magic;
            b.right.y = b.y;

            c.x = centerX + radius;
            c.y = centerY;
            c.top.x = c.x;
            c.top.y = c.y - magic;
            c.bottom.x = c.x;
            c.bottom.y = c.y + magic;

            d.x = centerX;
            d.y = centerY + radius * (1 - getOffset(0.1f - (mInterpolatedTime - 0.8f), 0.1f));
            d.left.x = d.x - magic;
            d.left.y = d.y;
            d.right.x = d.x + magic;
            d.right.y = d.y;
        } else if (mInterpolatedTime >= 0.9) {
            a.x = (float) (centerX - radius + radius * 0.2f * Math.sin(
                    Math.toRadians(
                            ((mInterpolatedTime - 0.9f) / 0.1f) * 180
                    )
            )
            );
            a.y = centerY;
            a.top.x = a.x;
            a.top.y = a.y - magic;
            a.bottom.x = a.x;
            a.bottom.y = a.y + magic;

            b.x = centerX;
            b.y = centerY - radius;
            b.left.x = b.x - magic;
            b.left.y = b.y;
            b.right.x = b.x + magic;
            b.right.y = b.y;

            c.x = centerX + radius;
            c.y = centerY;
            c.top.x = c.x;
            c.top.y = c.y - magic;
            c.bottom.x = c.x;
            c.bottom.y = c.y + magic;

            d.x = centerX;
            d.y = centerY + radius;
            d.left.x = d.x - magic;
            d.left.y = d.y;
            d.right.x = d.x + magic;
            d.right.y = d.y;
        }

        mPath.moveTo(a.x, a.y);
        mPath.cubicTo(a.top.x, a.top.y, b.left.x, b.left.y, b.x, b.y);
        mPath.cubicTo(b.right.x, b.right.y, c.top.x, c.top.y, c.x, c.y);
        mPath.cubicTo(c.bottom.x, c.bottom.y, d.right.x, d.right.y, d.x, d.y);
        mPath.cubicTo(d.left.x, d.left.y, a.bottom.x, a.bottom.y, a.x, a.y);
        canvas.drawPath(mPath, mPaint);
    }

    private float getOffset(float present, float base) {
        return present / base * 0.11f;
    }

    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        super.onLayout(changed, left, top, right, bottom);
        width = getWidth();
        height = getHeight();
        centerX = width / 2;
        centerY = height / 2;

        radius = 50;
        magic = blackMagic * radius;
    }

    private class MoveAnimation extends Animation {
        @Override
        protected void applyTransformation(float interpolatedTime, Transformation t) {
            super.applyTransformation(interpolatedTime, t);
            mInterpolatedTime = interpolatedTime;
            invalidate();
        }
    }

    private class VPoint {
        float x;
        float y;
        PointF top = new PointF();
        PointF bottom = new PointF();
    }

    private class HPoint {
        float x;
        float y;
        PointF left = new PointF();
        PointF right = new PointF();
    }

    public void startAnimation() {
        mPath.reset();
        mInterpolatedTime = 0;
        MoveAnimation move = new MoveAnimation();
        move.setDuration(2000);
        move.setInterpolator(new AccelerateDecelerateInterpolator());
        // move.setInterpolator(new AnticipateOvershootInterpolator());
        //move.setRepeatCount(Animation.INFINITE);
        //move.setRepeatMode(Animation.REVERSE);
        startAnimation(move);
    }
}