var helpers = Chart.helpers;
Chart.types.Radar.extend({
    name: "RadarExtended",
       
    initialize: function(data){
    this.PointClass = Chart.Point.extend({
        strokeWidth : this.options.pointDotStrokeWidth,
        radius : this.options.pointDotRadius,
        display: this.options.pointDot,
        hitDetectionRadius : this.options.pointHitDetectionRadius,
        ctx : this.chart.ctx
    });

    this.datasets = [];

    this.buildScale(data);

        //Set up tooltip events on the chart
    if (this.options.showTooltips){
        helpers.bindEvents(this, this.options.tooltipEvents, function(evt){
            var activePointsCollection = (evt.type !== 'mouseout') ? this.getPointsAtEvent(evt) : [];

            this.eachPoints(function(point){
                point.restore(['fillColor', 'strokeColor']);
            });
            helpers.each(activePointsCollection, function(activePoint){
                activePoint.fillColor = activePoint.highlightFill;
                activePoint.strokeColor = activePoint.highlightStroke;
            });

            this.showTooltip(activePointsCollection);
        });
    }

        //Iterate through each of the datasets, and build this into a property of the chart
    helpers.each(data.datasets,function(dataset){

        var datasetObject = {
            label: dataset.label || null,
            fillColor : dataset.fillColor,
            strokeColor : dataset.strokeColor,
            pointColor : dataset.pointColor,
            pointStrokeColor : dataset.pointStrokeColor,
            points : []
        };

        this.datasets.push(datasetObject);

        helpers.each(dataset.data,function(dataPoint,index){
            //Add a new point for each piece of data, passing any required data to draw.
            var pointPosition;
            if (!this.scale.animation){
                pointPosition = this.scale.getPointPosition(index, this.scale.calculateCenterOffset(dataPoint));
            }
            datasetObject.points.push(new this.PointClass({
                value : dataPoint,
                label : data.labels[index],
                datasetLabel: dataset.label,
                x: (this.options.animation) ? this.scale.xCenter : pointPosition.x,
                y: (this.options.animation) ? this.scale.yCenter : pointPosition.y,
                strokeColor : dataset.pointStrokeColor,
                fillColor : dataset.pointColor,
                highlightFill : dataset.pointHighlightFill || dataset.pointColor,
                highlightStroke: dataset.pointHighlightStroke || dataset.pointStrokeColor,
                id: data.ids[index]
            }));
        },this);

    },this);

    this.render();
    }

});

Chart.types.Bar.extend({
    name: "BarExtended",

    initialize: function (data) {

        //Expose options as a scope variable here so we can access it in the ScaleClass
        var options = this.options;

        this.ScaleClass = Chart.Scale.extend({
            offsetGridLines: true,
            calculateBarX: function (datasetCount, datasetIndex, barIndex) {
                //Reusable method for calculating the xPosition of a given bar based on datasetIndex & width of the bar
                var xWidth = this.calculateBaseWidth(),
                    xAbsolute = this.calculateX(barIndex) - (xWidth / 2),
                    barWidth = this.calculateBarWidth(datasetCount);

                return xAbsolute + (barWidth * datasetIndex) + (datasetIndex * options.barDatasetSpacing) + barWidth / 2;
            },
            calculateBaseWidth: function () {
                return (this.calculateX(1) - this.calculateX(0)) - (2 * options.barValueSpacing);
            },
            calculateBarWidth: function (datasetCount) {
                //The padding between datasets is to the right of each bar, providing that there are more than 1 dataset
                var baseWidth = this.calculateBaseWidth() - ((datasetCount - 1) * options.barDatasetSpacing);

                return (baseWidth / datasetCount);
            }
        });

        this.datasets = [];

        //Set up tooltip events on the chart
        if (this.options.showTooltips) {
            helpers.bindEvents(this, this.options.tooltipEvents, function (evt) {
                var activeBars = (evt.type !== 'mouseout') ? this.getBarsAtEvent(evt) : [];

                this.eachBars(function (bar) {
                    bar.restore(['fillColor', 'strokeColor']);
                });
                helpers.each(activeBars, function (activeBar) {
                    activeBar.fillColor = activeBar.highlightFill;
                    activeBar.strokeColor = activeBar.highlightStroke;
                });
                this.showTooltip(activeBars);
            });
        }

        //Declare the extension of the default point, to cater for the options passed in to the constructor
        this.BarClass = Chart.Rectangle.extend({
            strokeWidth: this.options.barStrokeWidth,
            showStroke: this.options.barShowStroke,
            ctx: this.chart.ctx
        });

        //Iterate through each of the datasets, and build this into a property of the chart
        helpers.each(data.datasets, function (dataset, datasetIndex) {

            var datasetObject = {
                label: dataset.label || null,
                fillColor: dataset.fillColor,
                strokeColor: dataset.strokeColor,
                bars: []
            };

            this.datasets.push(datasetObject);

            helpers.each(dataset.data, function (dataPoint, index) {
                //Add a new point for each piece of data, passing any required data to draw.
                datasetObject.bars.push(new this.BarClass({
                    value: dataPoint,
                    label: data.labels[index],
                    datasetLabel: dataset.label,
                    strokeColor: dataset.strokeColor,
                    fillColor: dataset.fillColor,
                    highlightFill: dataset.highlightFill || dataset.fillColor,
                    highlightStroke: dataset.highlightStroke || dataset.strokeColor,
                    id: data.ids[index]
                }));
            }, this);

        }, this);

        this.buildScale(data.labels);

        this.BarClass.prototype.base = this.scale.endPoint;

        this.eachBars(function (bar, index, datasetIndex) {
            helpers.extend(bar, {
                width: this.scale.calculateBarWidth(this.datasets.length),
                x: this.scale.calculateBarX(this.datasets.length, datasetIndex, index),
                y: this.scale.endPoint
            });
            bar.save();
        }, this);

        this.render();
    }

});

Chart.types.PolarArea.extend({
    name: "PolarAreaExtended",

    initialize: function (data) {
        this.segments = [];
        //Declare segment class as a chart instance specific class, so it can share props for this instance
        this.SegmentArc = Chart.Arc.extend({
            showStroke: this.options.segmentShowStroke,
            strokeWidth: this.options.segmentStrokeWidth,
            strokeColor: this.options.segmentStrokeColor,
            ctx: this.chart.ctx,
            innerRadius: 0,
            x: this.chart.width / 2,
            y: this.chart.height / 2
        });
        this.scale = new Chart.RadialScale({
            display: this.options.showScale,
            fontStyle: this.options.scaleFontStyle,
            fontSize: this.options.scaleFontSize,
            fontFamily: this.options.scaleFontFamily,
            fontColor: this.options.scaleFontColor,
            showLabels: this.options.scaleShowLabels,
            showLabelBackdrop: this.options.scaleShowLabelBackdrop,
            backdropColor: this.options.scaleBackdropColor,
            backdropPaddingY: this.options.scaleBackdropPaddingY,
            backdropPaddingX: this.options.scaleBackdropPaddingX,
            lineWidth: (this.options.scaleShowLine) ? this.options.scaleLineWidth : 0,
            lineColor: this.options.scaleLineColor,
            lineArc: true,
            width: this.chart.width,
            height: this.chart.height,
            xCenter: this.chart.width / 2,
            yCenter: this.chart.height / 2,
            ctx: this.chart.ctx,
            templateString: this.options.scaleLabel,
            valuesCount: data.length
        });

        this.updateScaleRange(data);

        this.scale.update();

        helpers.each(data, function (segment, index) {
            this.addData(segment, index, true);
        }, this);

        //Set up tooltip events on the chart
        if (this.options.showTooltips) {
            helpers.bindEvents(this, this.options.tooltipEvents, function (evt) {
                var activeSegments = (evt.type !== 'mouseout') ? this.getSegmentsAtEvent(evt) : [];
                helpers.each(this.segments, function (segment) {
                    segment.restore(["fillColor"]);
                });
                helpers.each(activeSegments, function (activeSegment) {
                    activeSegment.fillColor = activeSegment.highlightColor;
                });
                this.showTooltip(activeSegments);
            });
        }

        this.render();
    }

});