package  MyJar;

import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.AnimatorSet;
import android.animation.TypeEvaluator;
import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.ColorFilter;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.PointF;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.drawable.Drawable;
import android.support.annotation.IntDef;
import android.support.v4.view.animation.FastOutLinearInInterpolator;
import android.support.v4.view.animation.FastOutSlowInInterpolator;
import android.util.DisplayMetrics;
import android.view.animation.AccelerateInterpolator;
import android.view.animation.DecelerateInterpolator;
import android.view.animation.Interpolator;
import android.view.animation.LinearInterpolator;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;



public class ElectricFanLoadingRenderer extends LoadingRenderer {
    private static final Interpolator LINEAR_INTERPOLATOR = new LinearInterpolator();
    private static final Interpolator MATERIAL_INTERPOLATOR = new FastOutSlowInInterpolator();
    private static final Interpolator DECELERATE_INTERPOLATOR = new DecelerateInterpolator();
    private static final Interpolator ACCELERATE_INTERPOLATOR = new AccelerateInterpolator();
    private static final Interpolator FASTOUTLINEARIN_INTERPOLATOR = new FastOutLinearInInterpolator();

    private static final Interpolator[] INTERPOLATORS = new Interpolator[]{LINEAR_INTERPOLATOR,
            DECELERATE_INTERPOLATOR, ACCELERATE_INTERPOLATOR, FASTOUTLINEARIN_INTERPOLATOR, MATERIAL_INTERPOLATOR};
    private static final List<LeafHolder> mLeafHolders = new ArrayList<>();
    private static final Random mRandom = new Random();
    private final Animator.AnimatorListener mAnimatorListener = new AnimatorListenerAdapter() {
        @Override
        public void onAnimationRepeat(Animator animator) {
            super.onAnimationRepeat(animator);
            reset();
        }
    };

    public static final int MODE_NORMAL = 0;
    public static final int MODE_LEAF_COUNT = 1;

    @IntDef({MODE_NORMAL, MODE_LEAF_COUNT})
    @Retention(RetentionPolicy.SOURCE)
    public @interface MODE {
    }

    private static final String PERCENTAGE_100 = "100%";

    private static final long ANIMATION_DURATION = 7333;

    private static final int LEAF_COUNT = 28;
    private static final int DEGREE_180 = 180;
    private static final int DEGREE_360 = 360;
    private static final int FULL_GROUP_ROTATION = (int) (5.25f * DEGREE_360);

    private static final int DEFAULT_PROGRESS_COLOR = 0xfffca72e;
    private static final int DEFAULT_PROGRESS_BGCOLOR = 0xfffcd49f;
    private static final int DEFAULT_ELECTRIC_FAN_BGCOLOR = 0xfffccc59;
    private static final int DEFAULT_ELECTRIC_FAN_OUTLINE_COLOR = Color.WHITE;

    private static final float DEFAULT_WIDTH = 182.0f;
    private static final float DEFAULT_HEIGHT = 65.0f;
    private static final float DEFAULT_TEXT_SIZE = 11.0f;
    private static final float DEFAULT_STROKE_WIDTH = 2.0f;
    private static final float DEFAULT_STROKE_INTERVAL = .2f;
    private static final float DEFAULT_CENTER_RADIUS = 16.0f;
    private static final float DEFAULT_PROGRESS_CENTER_RADIUS = 11.0f;

    private static final float DEFAULT_LEAF_FLY_DURATION_FACTOR = 0.1f;

    private static final float LEAF_CREATE_DURATION_INTERVAL = 1.0f / LEAF_COUNT;
    private static final float DECELERATE_DURATION_PERCENTAGE = 0.4f;
    private static final float ACCELERATE_DURATION_PERCENTAGE = 0.6f;

    private final Paint mPaint = new Paint();
    private final RectF mTempBounds = new RectF();
    private final RectF mCurrentProgressBounds = new RectF();

    private float mTextSize;
    private float mStrokeXInset;
    private float mStrokeYInset;
    private float mProgressCenterRadius;

    private float mScale;
    private float mRotation;
    private float mProgress;

    private float mNextLeafCreateThreshold;

    private int mProgressColor;
    private int mProgressBgColor;
    private int mElectricFanBgColor;
    private int mElectricFanOutlineColor;

    private float mStrokeWidth;
    private float mCenterRadius;

    @MODE
    private int mMode;
    private int mCurrentLeafCount;

    private Drawable mLeafDrawable;
    private Drawable mLoadingDrawable;
    private Drawable mElectricFanDrawable;

    public ElectricFanLoadingRenderer(Context context,int ic_leaf,int ic_loading,int ic_eletric_fan) {
        super(context);
        init(context, ic_leaf, ic_loading, ic_eletric_fan);
        setupPaint();
        addRenderListener(mAnimatorListener);
    }

    private void init(Context context,int ic_leaf,int ic_loading,int ic_eletric_fan) {
        mMode = MODE_NORMAL;

        mWidth = DensityUtil.dip2px(context, DEFAULT_WIDTH);
        mHeight = DensityUtil.dip2px(context, DEFAULT_HEIGHT);
        mTextSize = DensityUtil.dip2px(context, DEFAULT_TEXT_SIZE);
        mStrokeWidth = DensityUtil.dip2px(context, DEFAULT_STROKE_WIDTH);
        mCenterRadius = DensityUtil.dip2px(context, DEFAULT_CENTER_RADIUS);
        mProgressCenterRadius = DensityUtil.dip2px(context, DEFAULT_PROGRESS_CENTER_RADIUS);

        mProgressColor = DEFAULT_PROGRESS_COLOR;
        mProgressBgColor = DEFAULT_PROGRESS_BGCOLOR;
        mElectricFanBgColor = DEFAULT_ELECTRIC_FAN_BGCOLOR;
        mElectricFanOutlineColor = DEFAULT_ELECTRIC_FAN_OUTLINE_COLOR;

        mLeafDrawable = context.getResources().getDrawable(ic_leaf);
        mLoadingDrawable = context.getResources().getDrawable(ic_loading);
        mElectricFanDrawable = context.getResources().getDrawable(ic_eletric_fan);

        mDuration = ANIMATION_DURATION;
        setInsets((int) mWidth, (int) mHeight);
    }

    private void setupPaint() {
        mPaint.setAntiAlias(true);
        mPaint.setStrokeWidth(mStrokeWidth);
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setStrokeCap(Paint.Cap.ROUND);
    }

    @Override
    protected void draw(Canvas canvas, Rect bounds) {
        int saveCount = canvas.save();

        RectF arcBounds = mTempBounds;
        arcBounds.set(bounds);
        arcBounds.inset(mStrokeXInset, mStrokeYInset);

        mCurrentProgressBounds.set(arcBounds.left, arcBounds.bottom - 2 * mCenterRadius,
                arcBounds.right, arcBounds.bottom);

        //draw loading drawable
        mLoadingDrawable.setBounds((int) arcBounds.centerX() - mLoadingDrawable.getIntrinsicWidth() / 2,
                0,
                (int) arcBounds.centerX() + mLoadingDrawable.getIntrinsicWidth() / 2,
                mLoadingDrawable.getIntrinsicHeight());
        mLoadingDrawable.draw(canvas);

        //draw progress background
        float progressInset = mCenterRadius - mProgressCenterRadius;
        RectF progressRect = new RectF(mCurrentProgressBounds);
        //sub DEFAULT_STROKE_INTERVAL, otherwise will have a interval between progress background and progress outline
        progressRect.inset(progressInset - DEFAULT_STROKE_INTERVAL, progressInset - DEFAULT_STROKE_INTERVAL);
        mPaint.setColor(mProgressBgColor);
        mPaint.setStyle(Paint.Style.FILL);
        canvas.drawRoundRect(progressRect, mProgressCenterRadius, mProgressCenterRadius, mPaint);

        //draw progress
        mPaint.setColor(mProgressColor);
        mPaint.setStyle(Paint.Style.FILL);
        canvas.drawPath(createProgressPath(mProgress, mProgressCenterRadius, progressRect), mPaint);

        //draw leaves
        for (int i = 0; i < mLeafHolders.size(); i++) {
            int leafSaveCount = canvas.save();
            LeafHolder leafHolder = mLeafHolders.get(i);
            Rect leafBounds = leafHolder.mLeafRect;

            canvas.rotate(leafHolder.mLeafRotation, leafBounds.centerX(), leafBounds.centerY());
            mLeafDrawable.setBounds(leafBounds);
            mLeafDrawable.draw(canvas);

            canvas.restoreToCount(leafSaveCount);
        }

        //draw progress background outline,
        //after drawing the leaves and then draw the outline of the progress background can
        //prevent the leaves from flying to the outside
        RectF progressOutlineRect = new RectF(mCurrentProgressBounds);
        float progressOutlineStrokeInset = (mCenterRadius - mProgressCenterRadius) / 2.0f;
        progressOutlineRect.inset(progressOutlineStrokeInset, progressOutlineStrokeInset);
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setColor(mProgressBgColor);
        mPaint.setStrokeWidth(mCenterRadius - mProgressCenterRadius);
        canvas.drawRoundRect(progressOutlineRect, mCenterRadius, mCenterRadius, mPaint);

        //draw electric fan outline
        float electricFanCenterX = arcBounds.right - mCenterRadius;
        float electricFanCenterY = arcBounds.bottom - mCenterRadius;

        mPaint.setColor(mElectricFanOutlineColor);
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setStrokeWidth(mStrokeWidth);
        canvas.drawCircle(arcBounds.right - mCenterRadius, arcBounds.bottom - mCenterRadius,
                mCenterRadius - mStrokeWidth / 2.0f, mPaint);

        //draw electric background
        mPaint.setColor(mElectricFanBgColor);
        mPaint.setStyle(Paint.Style.FILL);
        canvas.drawCircle(arcBounds.right - mCenterRadius, arcBounds.bottom - mCenterRadius,
                mCenterRadius - mStrokeWidth + DEFAULT_STROKE_INTERVAL, mPaint);

        //draw electric fan
        int rotateSaveCount = canvas.save();
        canvas.rotate(mRotation, electricFanCenterX, electricFanCenterY);
        mElectricFanDrawable.setBounds((int) (electricFanCenterX - mElectricFanDrawable.getIntrinsicWidth() / 2 * mScale),
                (int) (electricFanCenterY - mElectricFanDrawable.getIntrinsicHeight() / 2 * mScale),
                (int) (electricFanCenterX + mElectricFanDrawable.getIntrinsicWidth() / 2 * mScale),
                (int) (electricFanCenterY + mElectricFanDrawable.getIntrinsicHeight() / 2 * mScale));
        mElectricFanDrawable.draw(canvas);
        canvas.restoreToCount(rotateSaveCount);

        //draw 100% text
        if (mScale < 1.0f) {
            mPaint.setTextSize(mTextSize * (1 - mScale));
            mPaint.setColor(mElectricFanOutlineColor);
            Rect textRect = new Rect();
            mPaint.getTextBounds(PERCENTAGE_100, 0, PERCENTAGE_100.length(), textRect);
            canvas.drawText(PERCENTAGE_100, electricFanCenterX - textRect.width() / 2.0f,
                    electricFanCenterY + textRect.height() / 2.0f, mPaint);
        }

        canvas.restoreToCount(saveCount);
    }

    private Path createProgressPath(float progress, float circleRadius, RectF progressRect) {
        RectF arcProgressRect = new RectF(progressRect.left, progressRect.top, progressRect.left + circleRadius * 2, progressRect.bottom);
        RectF rectProgressRect = null;

        float progressWidth = progress * progressRect.width();
        float progressModeWidth = mMode == MODE_LEAF_COUNT ?
                (float) mCurrentLeafCount / (float) LEAF_COUNT * progressRect.width() : progress * progressRect.width();

        float swipeAngle = DEGREE_180;
        //the left half circle of the progressbar
        if (progressModeWidth < circleRadius) {
            swipeAngle = progressModeWidth / circleRadius * DEGREE_180;
        }

        //the center rect of the progressbar
        if (progressModeWidth < progressRect.width() - circleRadius && progressModeWidth >= circleRadius) {
            rectProgressRect = new RectF(progressRect.left + circleRadius, progressRect.top, progressRect.left + progressModeWidth, progressRect.bottom);
        }

        //the right half circle of the progressbar
        if (progressWidth >= progressRect.width() - circleRadius) {
            rectProgressRect = new RectF(progressRect.left + circleRadius, progressRect.top, progressRect.right - circleRadius, progressRect.bottom);
            mScale = (progressRect.width() - progressWidth) / circleRadius;
        }

        //the left of the right half circle
        if (progressWidth < progressRect.width() - circleRadius) {
            mRotation = (progressWidth / (progressRect.width() - circleRadius)) * FULL_GROUP_ROTATION % DEGREE_360;

            RectF leafRect = new RectF(progressRect.left + progressWidth, progressRect.top, progressRect.right - circleRadius, progressRect.bottom);
            addLeaf(progress, leafRect);
        }

        Path path = new Path();
        path.addArc(arcProgressRect, DEGREE_180 - swipeAngle / 2, swipeAngle);

        if (rectProgressRect != null) {
            path.addRect(rectProgressRect, Path.Direction.CW);
        }

        return path;
    }

    @Override
    protected void computeRender(float renderProgress) {
        if (renderProgress < DECELERATE_DURATION_PERCENTAGE) {
            mProgress = DECELERATE_INTERPOLATOR.getInterpolation(renderProgress / DECELERATE_DURATION_PERCENTAGE) * DECELERATE_DURATION_PERCENTAGE;
        } else {
            mProgress = ACCELERATE_INTERPOLATOR.getInterpolation((renderProgress - DECELERATE_DURATION_PERCENTAGE) / ACCELERATE_DURATION_PERCENTAGE) * ACCELERATE_DURATION_PERCENTAGE + DECELERATE_DURATION_PERCENTAGE;
        }
    }

    @Override
    protected void setAlpha(int alpha) {
        mPaint.setAlpha(alpha);

    }

    @Override
    protected void setColorFilter(ColorFilter cf) {
        mPaint.setColorFilter(cf);

    }

    @Override
    protected void reset() {
        mScale = 1.0f;
        mCurrentLeafCount = 0;
        mNextLeafCreateThreshold = 0.0f;
        mLeafHolders.clear();
    }

    protected void setInsets(int width, int height) {
        final float minEdge = (float) Math.min(width, height);
        float insetXs;
        if (mCenterRadius <= 0 || minEdge < 0) {
            insetXs = (float) Math.ceil(mCenterRadius / 2.0f);
        } else {
            insetXs = mCenterRadius;
        }
        mStrokeYInset = (float) Math.ceil(mCenterRadius / 2.0f);
        mStrokeXInset = insetXs;
    }

    private void addLeaf(float progress, RectF leafFlyRect) {
        if (progress < mNextLeafCreateThreshold) {
            return;
        }
        mNextLeafCreateThreshold += LEAF_CREATE_DURATION_INTERVAL;

        LeafHolder leafHolder = new LeafHolder();
        mLeafHolders.add(leafHolder);
        Animator leafAnimator = getAnimator(leafHolder, leafFlyRect, progress);
        leafAnimator.addListener(new AnimEndListener(leafHolder));
        leafAnimator.start();
    }

    private Animator getAnimator(LeafHolder target, RectF leafFlyRect, float progress) {
        ValueAnimator bezierValueAnimator = getBezierValueAnimator(target, leafFlyRect, progress);

        AnimatorSet finalSet = new AnimatorSet();
        finalSet.playSequentially(bezierValueAnimator);
        finalSet.setInterpolator(INTERPOLATORS[mRandom.nextInt(INTERPOLATORS.length)]);
        finalSet.setTarget(target);
        return finalSet;
    }

    private ValueAnimator getBezierValueAnimator(LeafHolder target, RectF leafFlyRect, float progress) {
        BezierEvaluator evaluator = new BezierEvaluator(getPoint1(leafFlyRect), getPoint2(leafFlyRect));

        int leafFlyStartY = (int) (mCurrentProgressBounds.bottom - mLeafDrawable.getIntrinsicHeight());
        int leafFlyRange = (int) (mCurrentProgressBounds.height() - mLeafDrawable.getIntrinsicHeight());

        int startPointY = leafFlyStartY - mRandom.nextInt(leafFlyRange);
        int endPointY = leafFlyStartY - mRandom.nextInt(leafFlyRange);

        ValueAnimator animator = ValueAnimator.ofObject(evaluator,
                new PointF((int) (leafFlyRect.right - mLeafDrawable.getIntrinsicWidth()), startPointY),
                new PointF(leafFlyRect.left, endPointY));
        animator.addUpdateListener(new BezierListener(target));
        animator.setTarget(target);

        animator.setDuration((long) ((mRandom.nextInt(300) + mDuration * DEFAULT_LEAF_FLY_DURATION_FACTOR) * (1.0f - progress)));

        return animator;
    }

    //get the pointF which belong to the right half side
    private PointF getPoint1(RectF leafFlyRect) {
        PointF point = new PointF();
        point.x = leafFlyRect.right - mRandom.nextInt((int) (leafFlyRect.width() / 2));
        point.y = (int) (leafFlyRect.bottom - mRandom.nextInt((int) leafFlyRect.height()));
        return point;
    }

    //get the pointF which belong to the left half side
    private PointF getPoint2(RectF leafFlyRect) {
        PointF point = new PointF();
        point.x = leafFlyRect.left + mRandom.nextInt((int) (leafFlyRect.width() / 2));
        point.y = (int) (leafFlyRect.bottom - mRandom.nextInt((int) leafFlyRect.height()));
        return point;
    }

    private class BezierEvaluator implements TypeEvaluator<PointF> {

        private PointF point1;
        private PointF point2;

        public BezierEvaluator(PointF point1, PointF point2) {
            this.point1 = point1;
            this.point2 = point2;
        }

        //Third-order Bezier curve formula: B(t) = point0 * (1-t)^3 + 3 * point1 * t * (1-t)^2 + 3 * point2 * t^2 * (1-t) + point3 * t^3
        @Override
        public PointF evaluate(float fraction, PointF point0, PointF point3) {

            float t = fraction;
            float tLeft = 1.0f - t;

            float x = (float) (point0.x * Math.pow(tLeft, 3) + 3 * point1.x * t * Math.pow(tLeft, 2) + 3 * point2.x * Math.pow(t, 2) * tLeft + point3.x * Math.pow(t, 3));
            float y = (float) (point0.y * Math.pow(tLeft, 3) + 3 * point1.y * t * Math.pow(tLeft, 2) + 3 * point2.y * Math.pow(t, 2) * tLeft + point3.y * Math.pow(t, 3));

            return new PointF(x, y);
        }
    }

    private class BezierListener implements ValueAnimator.AnimatorUpdateListener {

        private LeafHolder target;

        public BezierListener(LeafHolder target) {
            this.target = target;
        }

        @Override
        public void onAnimationUpdate(ValueAnimator animation) {
            PointF point = (PointF) animation.getAnimatedValue();
            target.mLeafRect.set((int) point.x, (int) point.y,
                    (int) (point.x + mLeafDrawable.getIntrinsicWidth()), (int) (point.y + mLeafDrawable.getIntrinsicHeight()));
            target.mLeafRotation = target.mMaxRotation * animation.getAnimatedFraction();
        }
    }

    private class AnimEndListener extends AnimatorListenerAdapter {
        private LeafHolder target;

        public AnimEndListener(LeafHolder target) {
            this.target = target;
        }

        @Override
        public void onAnimationEnd(Animator animation) {
            super.onAnimationEnd(animation);
            mLeafHolders.remove(target);
            mCurrentLeafCount++;
        }
    }

    private class LeafHolder {
        public Rect mLeafRect = new Rect();
        public float mLeafRotation = 0.0f;

        public float mMaxRotation = mRandom.nextInt(120);
    }

}