val renderer = GradientBarChartRenderer(chart)
renderer.barPaintOverrider = { index, rect, paint ->
    var colors = weekdayColors
    if (data[index].isWeekend) {
        colors = weekendBarColors
    }
    paint.shader = LinearGradient(rect.left, rect.top, rect.left, rect.bottom, colors.toIntArray(), null, Shader.TileMode.CLAMP)
}

internal class GradientBarChartRenderer(chart: BarChart) : BarChartRenderer(chart, chart.animator, chart.viewPortHandler) {

        private val mBarShadowRectBuffer = RectF()

        var barPaintOverrider: ((Int, RectF, Paint) -> Unit)? = null

        override fun drawDataSet(c: Canvas, dataSet: IBarDataSet, index: Int) {
            val trans = mChart.getTransformer(dataSet.getAxisDependency())

            mBarBorderPaint.color = dataSet.getBarBorderColor()
            mBarBorderPaint.strokeWidth = Utils.convertDpToPixel(dataSet.getBarBorderWidth())

            val drawBorder = dataSet.getBarBorderWidth() > 0f

            val phaseX = mAnimator.phaseX
            val phaseY = mAnimator.phaseY

            // draw the bar shadow before the values
            if (mChart.isDrawBarShadowEnabled) {
                mShadowPaint.color = dataSet.getBarShadowColor()

                val barData = mChart.barData

                val barWidth = barData.barWidth
                val barWidthHalf = barWidth / 2.0f
                var x: Float

                var i = 0
                val count = Math.min(Math.ceil((dataSet.getEntryCount().toFloat() * phaseX).toDouble()).toInt(), dataSet.getEntryCount())
                while (i < count) {

                    val e = dataSet.getEntryForIndex(i)

                    x = e.x

                    mBarShadowRectBuffer.left = x - barWidthHalf
                    mBarShadowRectBuffer.right = x + barWidthHalf

                    trans.rectValueToPixel(mBarShadowRectBuffer)

                    if (!mViewPortHandler.isInBoundsLeft(mBarShadowRectBuffer.right)) {
                        i++
                        continue
                    }

                    if (!mViewPortHandler.isInBoundsRight(mBarShadowRectBuffer.left))
                        break

                    mBarShadowRectBuffer.top = mViewPortHandler.contentTop()
                    mBarShadowRectBuffer.bottom = mViewPortHandler.contentBottom()

                    c.drawRect(mBarShadowRectBuffer, mShadowPaint)
                    i++
                }
            }

            // initialize the buffer
            val buffer = mBarBuffers[index]
            buffer.setPhases(phaseX, phaseY)
            buffer.setDataSet(index)
            buffer.setInverted(mChart.isInverted(dataSet.getAxisDependency()))
            buffer.setBarWidth(mChart.barData.barWidth)

            buffer.feed(dataSet)

            trans.pointValuesToPixel(buffer.buffer)

            val isSingleColor = dataSet.getColors().size == 1

            if (isSingleColor) {
                mRenderPaint.color = dataSet.getColor()
            }

            var j = 0
            while (j < buffer.size()) {

                if (!mViewPortHandler.isInBoundsLeft(buffer.buffer[j + 2])) {
                    j += 4
                    continue
                }

                if (!mViewPortHandler.isInBoundsRight(buffer.buffer[j]))
                    break

                if (!isSingleColor) {
                    // Set the color for the currently drawn value. If the index
                    // is out of bounds, reuse colors.
                    mRenderPaint.color = dataSet.getColor(j / 4)
                }
                val rect = RectF(buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2],
                        buffer.buffer[j + 3])
                if (barPaintOverrider != null) {
                    barPaintOverrider?.invoke(j / 4, rect, mRenderPaint)
                }
                c.drawRect(rect, mRenderPaint)

                if (drawBorder) {
                    c.drawRect(buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2],
                            buffer.buffer[j + 3], mBarBorderPaint)
                }
                j += 4
            }
        }
    }