/*
 * Copyright (C) 2011 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 com.android.settings.widget;

import android.content.Context;
import android.content.res.Resources;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import android.graphics.Path;
import android.graphics.Path.Direction;
import android.graphics.RadialGradient;
import android.graphics.RectF;
import android.graphics.Shader.TileMode;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;

import com.google.common.collect.Lists;

import java.util.ArrayList;

/**
 * Pie chart with multiple items.
 */
public class PieChartView extends View {
    public static final String TAG = "PieChartView";
    public static final boolean LOGD = false;

    private static final boolean FILL_GRADIENT = false;

    private ArrayList<Slice> mSlices = Lists.newArrayList();

    private int mOriginAngle;
    private Matrix mMatrix = new Matrix();

    private Paint mPaintOutline = new Paint();

    private Path mPathSide = new Path();
    private Path mPathSideOutline = new Path();

    private Path mPathOutline = new Path();

    private int mSideWidth;

    public class Slice {
        public long value;

        public Path path = new Path();
        public Path pathSide = new Path();
        public Path pathOutline = new Path();

        public Paint paint;

        public Slice(long value, int color) {
            this.value = value;
            this.paint = buildFillPaint(color, getResources());
        }
    }

    public PieChartView(Context context) {
        this(context, null);
    }

    public PieChartView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public PieChartView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);

        mPaintOutline.setColor(Color.BLACK);
        mPaintOutline.setStyle(Style.STROKE);
        mPaintOutline.setStrokeWidth(3f * getResources().getDisplayMetrics().density);
        mPaintOutline.setAntiAlias(true);

        mSideWidth = (int) (20 * getResources().getDisplayMetrics().density);

        setWillNotDraw(false);
    }

    private static Paint buildFillPaint(int color, Resources res) {
        final Paint paint = new Paint();

        paint.setColor(color);
        paint.setStyle(Style.FILL_AND_STROKE);
        paint.setAntiAlias(true);

        if (FILL_GRADIENT) {
            final int width = (int) (280 * res.getDisplayMetrics().density);
            paint.setShader(new RadialGradient(0, 0, width, color, darken(color), TileMode.MIRROR));
        }

        return paint;
    }

    public void setOriginAngle(int originAngle) {
        mOriginAngle = originAngle;
    }

    public void addSlice(long value, int color) {
        mSlices.add(new Slice(value, color));
    }

    public void removeAllSlices() {
        mSlices.clear();
    }

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

        mMatrix.reset();
        mMatrix.postScale(0.665f, 0.95f, centerX, centerY);
        mMatrix.postRotate(-40, centerX, centerY);

        generatePath();
    }

    public void generatePath() {
        if (LOGD) Log.d(TAG, "generatePath()");

        long total = 0;
        for (Slice slice : mSlices) {
            slice.path.reset();
            slice.pathSide.reset();
            slice.pathOutline.reset();
            total += slice.value;
        }

        mPathSide.reset();
        mPathSideOutline.reset();
        mPathOutline.reset();

        // bail when not enough stats to render
        if (total == 0) {
            invalidate();
            return;
        }

        final int width = getWidth();
        final int height = getHeight();

        final RectF rect = new RectF(0, 0, width, height);
        final RectF rectSide = new RectF();
        rectSide.set(rect);
        rectSide.offset(-mSideWidth, 0);

        mPathSide.addOval(rectSide, Direction.CW);
        mPathSideOutline.addOval(rectSide, Direction.CW);
        mPathOutline.addOval(rect, Direction.CW);

        int startAngle = mOriginAngle;
        for (Slice slice : mSlices) {
            final int sweepAngle = (int) (slice.value * 360 / total);
            final int endAngle = startAngle + sweepAngle;

            final float startAngleMod = startAngle % 360;
            final float endAngleMod = endAngle % 360;
            final boolean startSideVisible = startAngleMod > 90 && startAngleMod < 270;
            final boolean endSideVisible = endAngleMod > 90 && endAngleMod < 270;

            // draw slice
            slice.path.moveTo(rect.centerX(), rect.centerY());
            slice.path.arcTo(rect, startAngle, sweepAngle);
            slice.path.lineTo(rect.centerX(), rect.centerY());

            if (startSideVisible || endSideVisible) {

                // when start is beyond horizon, push until visible
                final float startAngleSide = startSideVisible ? startAngle : 450;
                final float endAngleSide = endSideVisible ? endAngle : 270;
                final float sweepAngleSide = endAngleSide - startAngleSide;

                // draw slice side
                slice.pathSide.moveTo(rect.centerX(), rect.centerY());
                slice.pathSide.arcTo(rect, startAngleSide, 0);
                slice.pathSide.rLineTo(-mSideWidth, 0);
                slice.pathSide.arcTo(rectSide, startAngleSide, sweepAngleSide);
                slice.pathSide.rLineTo(mSideWidth, 0);
                slice.pathSide.arcTo(rect, endAngleSide, -sweepAngleSide);
            }

            // draw slice outline
            slice.pathOutline.moveTo(rect.centerX(), rect.centerY());
            slice.pathOutline.arcTo(rect, startAngle, 0);
            if (startSideVisible) {
                slice.pathOutline.rLineTo(-mSideWidth, 0);
            }
            slice.pathOutline.moveTo(rect.centerX(), rect.centerY());
            slice.pathOutline.arcTo(rect, startAngle + sweepAngle, 0);
            if (endSideVisible) {
                slice.pathOutline.rLineTo(-mSideWidth, 0);
            }

            startAngle += sweepAngle;
        }

        invalidate();
    }

    @Override
    protected void onDraw(Canvas canvas) {

        canvas.concat(mMatrix);

        for (Slice slice : mSlices) {
            canvas.drawPath(slice.pathSide, slice.paint);
        }
        canvas.drawPath(mPathSideOutline, mPaintOutline);

        for (Slice slice : mSlices) {
            canvas.drawPath(slice.path, slice.paint);
            canvas.drawPath(slice.pathOutline, mPaintOutline);
        }
        canvas.drawPath(mPathOutline, mPaintOutline);
    }

    public static int darken(int color) {
        float[] hsv = new float[3];
        Color.colorToHSV(color, hsv);
        hsv[2] /= 2;
        hsv[1] /= 2;
        return Color.HSVToColor(hsv);
    }

}