import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.PathMeasure;
import android.graphics.RectF;
import android.support.annotation.Nullable;
import android.util.AttributeSet;
import android.view.View;
import android.view.animation.BounceInterpolator;
import android.view.animation.DecelerateInterpolator;
import android.view.animation.LinearInterpolator;

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

public class ShortCandle extends View {
    private static final String TAG = "ShortCandle";
    private Paint mLinePaint;
    private Paint mCirclePaint;
    private Paint mFillPaint;
    private Paint mFillBgPaint;
    private Paint mAngryEyePaint;
    private Paint mFirePaint;
    private Paint mLightPaint;
    private Path mPath;
    private int mWidth;
    private int mHeight;
    private RectF rectF;
    private float floatTime;
    private int angryColor = Color.parseColor("#c57fbb");
    private int normalColor = Color.parseColor("#ffffff");
    private boolean firstStage;
    private boolean secondStage;
    private boolean thirdStage;
    private boolean fourStage;

    private PathMeasure mPathMeasure;
    private float[] position = new float[2];

    public ShortCandle(Context context) {
        super(context);
        init();
    }

    public ShortCandle(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        init();
    }

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

    private void init() {
        mLinePaint = new Paint();
        mLinePaint.setStrokeWidth(8);
        mLinePaint.setColor(Color.parseColor("#643a60"));
        mLinePaint.setStyle(Paint.Style.STROKE);
        mLinePaint.setStrokeCap(Paint.Cap.ROUND);
        mLinePaint.setAntiAlias(true);
        mCirclePaint = new Paint();
        mCirclePaint.setStrokeWidth(8);
        mCirclePaint.setColor(Color.parseColor("#643a60"));
        mCirclePaint.setStyle(Paint.Style.FILL_AND_STROKE);
        mCirclePaint.setStrokeCap(Paint.Cap.ROUND);
        mCirclePaint.setAntiAlias(true);
        mFillPaint = new Paint();
        mFillPaint.setStrokeWidth(8);
        mFillPaint.setColor(normalColor);
        mFillPaint.setStyle(Paint.Style.FILL);
        mFillPaint.setStrokeCap(Paint.Cap.ROUND);
        mFillPaint.setAntiAlias(true);
        mFillBgPaint = new Paint();
        mFillBgPaint.setStrokeWidth(8);
        mFillBgPaint.setColor(Color.parseColor("#a5b0d9"));
        mFillBgPaint.setStyle(Paint.Style.FILL);
        mFillBgPaint.setStrokeCap(Paint.Cap.ROUND);
        mFillBgPaint.setAntiAlias(true);
        mAngryEyePaint = new Paint();
        mAngryEyePaint.setStrokeWidth(5);
        mAngryEyePaint.setColor(Color.RED);
        mAngryEyePaint.setStyle(Paint.Style.STROKE);
        mAngryEyePaint.setStrokeCap(Paint.Cap.ROUND);
        mAngryEyePaint.setAntiAlias(true);
        mFirePaint = new Paint();
        mFirePaint.setStrokeWidth(5);
        mFirePaint.setColor(Color.RED);
        mFirePaint.setStyle(Paint.Style.FILL);
        mFirePaint.setAntiAlias(true);
        mLightPaint = new Paint();
        mLightPaint.setStrokeWidth(12);
        mLightPaint.setColor(Color.parseColor("#bbffffff"));
        mLightPaint.setStyle(Paint.Style.STROKE);
        mLightPaint.setAntiAlias(true);

        mPath = new Path();
        mPathMeasure = new PathMeasure(mPath, true);

        rectF = new RectF();
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        drawBackground(canvas);
        drawLandLine(canvas);
        drawGirlCandle(canvas);
        drawBoyCandle(canvas);
    }

    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        super.onLayout(changed, left, top, right, bottom);
        mWidth = getWidth();
        mHeight = getHeight();
    }


    private void drawBackground(Canvas canvas) {
        canvas.drawColor(Color.parseColor("#f7edab"));
    }

    private void drawLandLine(Canvas canvas) {
        float px = mWidth / 4;
        float py = mHeight / 3;
        canvas.drawLine(px, py * 2, px * 3, py * 2, mLinePaint);
    }

    private void drawGirlCandle(Canvas canvas) {
        float widthOffset = (float) (4 * Math.sin(Math.toRadians(90 * floatTime)));
        float width = 120;
        float left = mWidth / 3 - widthOffset;
        float top = mHeight / 3 + floatTime * mHeight / 10;
        if (thirdStage || fourStage) {
            top = mHeight / 3;
        }
        float right = left + width + widthOffset;
        float bottom = mHeight / 3 * 2;
        float height = bottom - top;

        double angle = Math.toRadians(floatTime * 360);
        double sin = Math.sin(angle);

        // 画填充
        rectF.set(left, top, right, bottom);
        if (thirdStage || fourStage) {
            mFillPaint.setColor(normalColor);
        } else {
            int r = Color.red(normalColor) - (int) ((Color.red(normalColor) - Color.red(angryColor)) * floatTime);
            int g = Color.green(normalColor) - (int) ((Color.green(normalColor) - Color.green(angryColor)) * floatTime);
            int b = Color.blue(normalColor) - (int) ((Color.blue(normalColor) - Color.blue(angryColor)) * floatTime);
            mFillPaint.setColor(Color.argb(255, r, g, b));
        }
        canvas.drawRoundRect(rectF, 4, 4, mFillPaint);

        rectF.set(right - 10, top, right, bottom);
        canvas.drawRoundRect(rectF, 4, 4, mFillBgPaint);

        // 画身材
        rectF.set(left, top, right, bottom);
//        canvas.drawRect(rectF, mLinePaint);
        canvas.drawRoundRect(rectF, 4, 4, mLinePaint);

        // 火芯旋转
        if (secondStage) {
            canvas.drawLine((left + right) / 2, top, (float) ((left + right) / 2 - sin * 30), (float) (top - Math.cos(angle) * 30), mLinePaint);
        } else {
            canvas.drawLine((left + right) / 2, top, (left + right) / 2, top - 30, mLinePaint);
        }

        // 光圈部分绘制
        if (thirdStage) {
            float w = 0;
            float cx = (left + right) / 2;
            float cy = top - height / 4;
            if (floatTime > 0f && floatTime < 0.3f) {
                w = height / 3 + floatTime * 120;
                float dx = cx - w + 15;
                float dy = cy - floatTime * 100;
                mPath.reset();
                mPath.moveTo(dx, dy);
                mPath.lineTo(dx + 20, dy - 20);
                mPath.lineTo(dx + 40, dy);
                mPath.lineTo(dx + 20, dy + 20);
                mPath.close();
                canvas.drawPath(mPath, mFirePaint);
                float ex = cx + w - 45;
                float ey = cy - 15 - floatTime * 100;
                mPath.reset();
                mPath.moveTo(ex, ey);
                mPath.lineTo(ex + 20, ey - 20);
                mPath.lineTo(ex + 40, ey);
                mPath.lineTo(ex + 20, ey + 20);
                mPath.close();
                canvas.drawPath(mPath, mFirePaint);
            } else if (floatTime > 0.3f && floatTime < 0.6f) {
                w = height / 3 + (floatTime - 0.3f) * 120;
                mPath.reset();
                float dx = cx - w + 15;
                float dy = cy - (floatTime - 0.3f) * 100;
                mPath.moveTo(dx, dy);
                mPath.lineTo(dx + 20, dy - 20);
                mPath.lineTo(dx + 40, dy);
                mPath.lineTo(dx + 20, dy + 20);
                mPath.close();
                canvas.drawPath(mPath, mFirePaint);
                float ex = cx + w - 45;
                float ey = cy - 15 - (floatTime - 0.3f) * 100;
                mPath.reset();
                mPath.moveTo(ex, ey);
                mPath.lineTo(ex + 20, ey - 20);
                mPath.lineTo(ex + 40, ey);
                mPath.lineTo(ex + 20, ey + 20);
                mPath.close();
                canvas.drawPath(mPath, mFirePaint);
            } else if (floatTime > 0.6f && floatTime < 0.9f) {
                w = height / 3 + (floatTime - 0.6f) * 120;
            }
            canvas.drawCircle(cx, cy, w, mLightPaint);
        }

        // 画火
        if ((secondStage && floatTime < 0.25) || thirdStage || (fourStage && floatTime < 0.4)) {
            float startX = (left + right) / 2;
            float startY = top - 84;
            float endX = startX;
            float endY = top - 20;
            mPath.reset();
            mPath.moveTo(startX, startY);
            mPath.quadTo(endX + 36, endY - 14, endX, endY);
            float varX = startX;
            float varY = startY + floatTime * 100;
            if (thirdStage || floatTime < 0.1 || (fourStage && floatTime < 0.4)) {
                mPath.quadTo(endX - 36, endY - 14, startX, startY);
            } else {
                mPath.quadTo(endX - 16, endY - 4, endX - 26, endY - 22);
                mPath.quadTo(varX, varY, startX, startY);
            }
            mPath.close();
            canvas.drawPath(mPath, mFirePaint);
        }

        // 吹我，i'll go to die
        if (fourStage && floatTime > 0.4) {
            double a = Math.toRadians(floatTime * 90);
            double c = Math.cos(a);
            double s = Math.sin(a);
            float cx = (float) (left - 100 - s * 100);
            float cy = top - 40;
            canvas.drawLine(cx, cy, (float) (cx + c * 240), cy, mLinePaint);
            if (floatTime < 0.95) {
                canvas.drawCircle((float) (left + width / 2 - s * 30), (float) (top - 50 - s * 22), 15 * (floatTime - 0.4f), mLinePaint);
            }
        }

        // eye
        if (firstStage && floatTime > 0.0f) {
            canvas.translate((float) sin * 3, 0);
            canvas.drawLine(left + width * 1 / 4 - 5, top + height * 1 / 3 - 6, left + width * 1 / 4 + 5, top + height * 1 / 3, mAngryEyePaint);
            canvas.drawLine(left + width * 1 / 4 - 5, top + height * 1 / 3 + 6, left + width * 1 / 4 + 5, top + height * 1 / 3, mAngryEyePaint);

            canvas.drawLine(left + width * 3 / 4 + 5, top + height * 1 / 3 - 6, left + width * 3 / 4 - 5, top + height * 1 / 3, mAngryEyePaint);
            canvas.drawLine(left + width * 3 / 4 + 5, top + height * 1 / 3 + 6, left + width * 3 / 4 - 5, top + height * 1 / 3, mAngryEyePaint);
        } else {
            canvas.drawCircle(left + width * 1 / 4, top + height * 1 / 3, 5, mCirclePaint);
            canvas.drawCircle(left + width * 3 / 4, top + height * 1 / 3, 5, mCirclePaint);
        }

    }

    private void drawBoyCandle(Canvas canvas) {
        float width = 120;
        float left = mWidth / 2;
        float top = mHeight / 9;
        float right = left + width;
        float bottom = mHeight / 3 * 2;
        float height = bottom - top;

        rectF.set(left, top, right, bottom);
        mFillPaint.setColor(Color.parseColor("#ffffff"));
        canvas.drawRoundRect(rectF, 4, 4, mFillPaint);

        rectF.set(right - 10, top, right, bottom);
        canvas.drawRoundRect(rectF, 4, 4, mFillBgPaint);

        rectF.set(left, top, right, bottom);
//        canvas.drawRect(rectF, mLinePaint);
        canvas.drawRoundRect(rectF, 4, 4, mLinePaint);
        canvas.drawLine((left + right) / 2, top, (left + right) / 2, top - 40, mLinePaint);

        float lx = left + width * 1 / 3;
        float ly = top + height * 1 / 6;
        float rx = left + width * 2 / 3;
        float ry = top + height * 1 / 6;
        mPath.reset();
        mPath.moveTo(lx, ly);
        mPath.lineTo(lx - 30, ly - 20);
        mPath.quadTo(lx - 35, ly + 5, lx, ly);
        mPath.close();
        mPathMeasure.setPath(mPath, true);
        if (fourStage) {
            canvas.drawCircle(position[0], position[1], 5, mCirclePaint);
            canvas.drawCircle(position[0] + rx - lx, position[1], 5, mCirclePaint);
        } else {
            canvas.drawCircle(lx, ly, 5, mCirclePaint);
            canvas.drawCircle(rx, ry, 5, mCirclePaint);
        }

        // draw mouth
        float mx = (lx + rx) / 2;
        float my = top + height * 1 / 3;
        if (fourStage && floatTime < 0.98f) {
            double a = Math.toRadians(floatTime * 180);
            double s = Math.sin(a);
            canvas.drawCircle(mx - floatTime * 32f, my - floatTime * 24f, (float) (s * 16), mCirclePaint);
        }
    }

    private void switchStage(int s) {
        switch (s) {
            case 1:
                firstStage = true;
                secondStage = false;
                thirdStage = false;
                fourStage = false;
                break;
            case 2:
                firstStage = false;
                secondStage = true;
                thirdStage = false;
                fourStage = false;
                break;
            case 3:
                firstStage = false;
                secondStage = false;
                thirdStage = true;
                fourStage = false;
                break;
            case 4:
                firstStage = false;
                secondStage = false;
                thirdStage = false;
                fourStage = true;
                break;
        }
    }

    public void startAnimation() {
        switchStage(1);
        firstStageAnimation();
    }

    private void firstStageAnimation() {
        ValueAnimator firstAnimator = ValueAnimator.ofFloat(0, 1);
        firstAnimator.setDuration(1000);
        firstAnimator.setInterpolator(new LinearInterpolator());
        firstAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                floatTime = (float) animation.getAnimatedValue();
                postInvalidate();
            }
        });
        firstAnimator.start();
        firstAnimator.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                super.onAnimationEnd(animation);
                switchStage(2);
                secondStageAnimation();
            }
        });
    }

    private void secondStageAnimation() {
        ValueAnimator secondAnimator = ValueAnimator.ofFloat(1, 0);
        secondAnimator.setDuration(1000);
        secondAnimator.setInterpolator(new BounceInterpolator());
        secondAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                floatTime = (float) animation.getAnimatedValue();
                postInvalidate();
            }
        });
        secondAnimator.start();
        secondAnimator.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                super.onAnimationEnd(animation);
                switchStage(3);
                thirdStageAnimation();
            }
        });
    }

    private void thirdStageAnimation() {
        ValueAnimator thirdAnimator = ValueAnimator.ofFloat(0, 1);
        thirdAnimator.setDuration(1500);
        thirdAnimator.setInterpolator(new LinearInterpolator());
        thirdAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                floatTime = (float) animation.getAnimatedValue();
                postInvalidate();
            }
        });
        thirdAnimator.start();
        thirdAnimator.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                super.onAnimationEnd(animation);
                switchStage(4);
                fourStageAnimation();
            }
        });
    }

    private void fourStageAnimation() {
//        ValueAnimator fourAnimator = ValueAnimator.ofFloat(0, 1);
//        fourAnimator.setDuration(1000);
//        fourAnimator.setInterpolator(new LinearInterpolator());
//        fourAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
//            @Override
//            public void onAnimationUpdate(ValueAnimator animation) {
//                floatTime = (float) animation.getAnimatedValue();
//                invalidate();
//            }
//        });
//        fourAnimator.start();

        ValueAnimator valueAnimator = ValueAnimator.ofFloat(0, mPathMeasure.getLength());
        valueAnimator.setDuration(1000);
        valueAnimator.setInterpolator(new DecelerateInterpolator());
        valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                float value = (Float) animation.getAnimatedValue();
                mPathMeasure.getPosTan(value, position, null);
                floatTime = value * 1.0f / mPathMeasure.getLength();
                postInvalidate();
            }
        });
        valueAnimator.start();
    }

}