WhoGraphActivity-pre-clean

package com.doneit.emiltonia.ui.who.graph

import android.Manifest
import android.content.Intent
import android.content.pm.PackageManager
import android.graphics.*
import android.net.Uri
import android.os.Build
import android.os.Bundle
import android.provider.MediaStore
import android.support.annotation.RequiresApi
import android.support.design.widget.FloatingActionButton
import android.support.v4.app.ActivityCompat
import android.util.Log
import android.view.MotionEvent
import android.view.View
import android.widget.Toast
import com.doneit.emiltonia.Const

import com.doneit.emiltonia.R
import com.doneit.emiltonia.data.entity.PercentileEntity
import com.doneit.emiltonia.data.entity.ScaleEntity
import com.doneit.emiltonia.ui.base.BaseContract
import com.doneit.emiltonia.ui.base.inject.BaseInjectActivity
import com.github.mikephil.charting.charts.LineChart
import com.github.mikephil.charting.components.*
import com.github.mikephil.charting.data.Entry
import com.github.mikephil.charting.data.LineData
import com.github.mikephil.charting.data.LineDataSet
import com.github.mikephil.charting.formatter.IndexAxisValueFormatter
import com.github.mikephil.charting.interfaces.datasets.ILineDataSet
import com.github.mikephil.charting.listener.ChartTouchListener
import com.github.mikephil.charting.listener.OnChartGestureListener
import com.github.mikephil.charting.renderer.XAxisRenderer
import com.github.mikephil.charting.renderer.YAxisRenderer
import com.github.mikephil.charting.utils.MPPointF
import com.github.mikephil.charting.utils.Transformer
import com.github.mikephil.charting.utils.Utils
import com.github.mikephil.charting.utils.ViewPortHandler
import kotlinx.android.synthetic.main.activity_who_graph.*
import timber.log.Timber
import java.text.SimpleDateFormat
import java.util.*

import javax.inject.Inject

class WhoGraphActivity : BaseInjectActivity(), WhoGraphContract.View,
        OnChartGestureListener {

    private var mChart: LineChart? = null

    companion object {
        private const val KEY_EXTRA_BABY_ID = "KEY_EXTRA_BABY_ID"
        private const val DAYS_IN_WEEK = 7
        private var babyGender = Const.Genders.MALE

        private var bitmap: Bitmap? = null
    }

    @Inject
    lateinit var presenter: WhoGraphPresenter

    private var fab: FloatingActionButton? = null

    private var babyId: Int = 0

    private var babyAge = 0
    private var babyName = ""
    private var scales = 0

    private val data = LineData()

    private var percentileP3: MutableList<Double> = arrayListOf()
    private var percentileP15: MutableList<Double> = arrayListOf()
    private var percentileP50: MutableList<Double> = arrayListOf()
    private var percentileP85: MutableList<Double> = arrayListOf()
    private var percentileP97: MutableList<Double> = arrayListOf()

    private val allPercentiles: MutableList<MutableList<Double>> = arrayListOf()
    private val allPercentilesTitles: MutableList<String> = arrayListOf("P3", "P15", "P50", "P85", "P97")
    private val allDashedLinesLength: MutableList<Float> = arrayListOf(10f,10f,20f,10f,10f)
    private val allDashedLinesSpaceLength: MutableList<Float> = arrayListOf(15f,10f,20f,10f,10f)

    private var percentileBabyScales: MutableList<Double> = arrayListOf()

    override fun getPresenter(): BaseContract.Presenter<*>? {
        return presenter
    }

    override fun showPercentilesList(list: List<PercentileEntity>) {
        list.forEach {
            percentileP3.add(it.p3.toDouble()*1000)
            percentileP15.add(it.p15.toDouble()*1000)
            Timber.e("P15 = ${it.p15}")
            percentileP50.add(it.p50.toDouble()*1000)
            percentileP85.add(it.p85.toDouble()*1000)
            percentileP97.add(it.p97.toDouble()*1000)
        }
        allPercentiles.add(percentileP3)
        allPercentiles.add(percentileP15)
        allPercentiles.add(percentileP50)
        allPercentiles.add(percentileP85)
        allPercentiles.add(percentileP97)
        Timber.d("P3 ${percentileP3.size}")
        Timber.d("P15 ${percentileP15.size}")
        Timber.d("P50 ${percentileP50.size}")
        Timber.d("P85 ${percentileP85.size}")
        Timber.d("P97 ${percentileP97.size}")
    }

    @RequiresApi(Build.VERSION_CODES.O)
    override fun showScalesList(list: List<ScaleEntity>) {
        scales = list.size
        Timber.e("scales size = $scales")
        if (list.size > 0) {
            list.forEach {
                Timber.e("ttttt = ${it.weight}")
                var weight = it.weight.toDouble()
                if (weight < 10) {
                    weight *= 1000
                }
                else if (weight >= 10 && weight < 100) {
                    weight *= 100
                }
                percentileBabyScales.add(/*it.weight.toDouble()*1000*/weight)
            }
        }
        Timber.d("percentileBabyScales ${percentileBabyScales.size}")

        Collections.reverse(percentileBabyScales)

        setupChart()
        setupBabyLine()
    }


    @RequiresApi(Build.VERSION_CODES.O)
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_who_graph)

        setSupportActionBar(toolbar)
        supportActionBar?.setDisplayShowTitleEnabled(false)

        toolbarTitle.setText(R.string.who_graph_title)
        toolbar.setNavigationOnClickListener { onBackPressed() }
        toolbar.setNavigationIcon(R.drawable.ic_back)

        babyId = intent.getIntExtra(WhoGraphActivity.KEY_EXTRA_BABY_ID, 0)
        babyGender = intent.getStringExtra("EXTRA_BABY_GENDER")
        babyName = intent.getStringExtra("EXTRA_BABY_NAME")
        babyAge = intent.getIntExtra("EXTRA_BABY_AGE", 0) / DAYS_IN_WEEK

        if (babyGender == Const.Genders.MALE) {
            bitmap = BitmapFactory.decodeResource(resources, R.drawable.ic_birthday_graph_male)
        }
        else {
            bitmap = BitmapFactory.decodeResource(resources, R.drawable.ic_birthday_graph_female)
        }

        tvBabyName.text = babyName

        if (babyGender == Const.Genders.MALE) {
            iv_baby1.setBackgroundResource(R.drawable.bg_dotted_baby_male)
            iv_baby2.setBackgroundResource(R.drawable.bg_dotted_baby_male)
        }
        else {
            iv_baby1.setBackgroundResource(R.drawable.bg_dotted_baby_female)
            iv_baby2.setBackgroundResource(R.drawable.bg_dotted_baby_female)
        }

        presentationComponent.inject(this)
        presenter.attachToView(this)

        presenter.getAllPercentilesByBabyId(babyId)


        fab = findViewById(R.id.fab)
        fab?.setOnClickListener {
            shareWhoGraphRequest()
        }

        mChart = findViewById(R.id.chart1)
        mChart!!.visibility = View.INVISIBLE
        mChart!!.setNoDataText("")
    }

    private fun isStoragePermissionGranted() : Boolean{
        return if (Build.VERSION.SDK_INT >= 23) {
            if (checkSelfPermission(android.Manifest.permission.WRITE_EXTERNAL_STORAGE)
                    == PackageManager.PERMISSION_GRANTED) {
                true
            } else {
                ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.WRITE_EXTERNAL_STORAGE), 1)
                false
            }
        } else { //permission is automatically granted on sdk<23 upon installation
            true
        }
}

    private fun shareWhoGraphRequest() {
        if (isStoragePermissionGranted()) {
            share()
        }
    }

    private fun share() {
        val bitmap = mChart!!.chartBitmap
        val imgName = "Emiltonia_".plus(babyName).plus("_Who_Graph_".plus(getCurrentTimeStamp()))
        val bitmapPath = MediaStore.Images.Media.insertImage(contentResolver, bitmap, imgName, null)
        val bitmapUri = Uri.parse(bitmapPath)
        val intent = Intent()
        intent.action = Intent.ACTION_SEND
        intent.type = "image/*"

        intent.putExtra(Intent.EXTRA_STREAM, bitmapUri)
        val shareTitle = "Share ".plus(babyName).plus(" Who Graph")
        startActivity(Intent.createChooser(intent, shareTitle))
    }

    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)

        if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            share()
        }
    }


    @RequiresApi(Build.VERSION_CODES.O)
    private fun setupChart() {

        mChart!!.onChartGestureListener = this
        mChart!!.setDrawGridBackground(false)

        mChart!!.description.isEnabled = false

        // enable touch gestures
        mChart!!.setTouchEnabled(true)

        // enable scaling and dragging
        mChart!!.isDragEnabled = true
        mChart!!.setScaleEnabled(true)

        // if disabled, scaling can be done on x- and y-axis separately
        mChart!!.setPinchZoom(true)

        // set an alternative background color
        // mChart.setBackgroundColor(Color.GRAY);

        // create a custom MarkerView (extend MarkerView) and specify the layout
        // to use for it
//        val mv = MyMarkerView(this, R.layout.custom_marker_view)
//        mv.setChartView(mChart) // For bounds control
//        mChart!!.marker = mv // Set the marker to the chart

        // x-axis limit line
//        val llXAxis = LimitLine(10f, "Index 10")
//        llXAxis.lineWidth = 4f
//        llXAxis.enableDashedLine(10f, 10f, 0f)
//        llXAxis.labelPosition = LimitLine.LimitLabelPosition.RIGHT_BOTTOM
//        llXAxis.textSize = 10f

//        val xAxis = mChart!!.xAxis
//        xAxis.enableGridDashedLine(10f, 10f, 0f)
        //xAxis.setValueFormatter(new MyCustomXAxisValueFormatter());
        //xAxis.addLimitLine(llXAxis); // add x-axis limit line


        val leftAxis = mChart!!.axisLeft
        leftAxis.setPosition(YAxis.YAxisLabelPosition.OUTSIDE_CHART)
        leftAxis.removeAllLimitLines() // reset all limit lines to avoid overlapping lines
        leftAxis.axisMaximum = 10f
        leftAxis.axisMinimum = 0f
//        leftAxis.yOffset = 20f;
        leftAxis.enableGridDashedLine(30f, 10f, 0f)
        leftAxis.setDrawZeroLine(false)


//        mChart!!.setVisibleXRange(20f)
//        mChart!!.setVisibleYRange(20f, YAxis.AxisDependency.LEFT)
//        mChart!!.centerViewTo(20f, 50f, YAxis.AxisDependency.LEFT)

//        mChart!!.animateX(2500)
//        mChart!!.invalidate();

        // get the legend (only possible after setting data)
        val l = mChart!!.legend
//        l.position = Legend.LegendPosition.LEFT_OF_CHART_INSIDE
        mChart!!.xAxis.setDrawLabels(true)
        mChart!!.legend.setDrawInside(false)
        l.form = Legend.LegendForm.LINE
        mChart!!.legend.isEnabled = false
//        l.setDrawInside(true)
//        l.addDashedLine(width: dashWidth, pattern: dashes[0], color: statisticColor)


        // // dont forget to refresh the drawing
//         mChart!!.invalidate();

        mChart!!.setBackgroundColor(Color.WHITE)

        mChart!!.setBorderColor(Color.TRANSPARENT)
        mChart!!.isDragXEnabled = true
        mChart!!.isDragYEnabled = true //false
        mChart!!.isScaleXEnabled = true
        mChart!!.isScaleYEnabled = true //false
        mChart!!.viewPortHandler.setMaximumScaleX(5f)
        mChart!!.viewPortHandler.setMaximumScaleY(2f)

        val xValueRenderer = XValueRenderer(
                mChart!!.viewPortHandler,
                mChart!!.xAxis,
                mChart!!.rendererXAxis.transformer
        )
        mChart!!.setXAxisRenderer(xValueRenderer)

        val xAxis = mChart!!.xAxis
        xAxis.position = XAxis.XAxisPosition.BOTTOM
        xAxis.gridColor = Color.LTGRAY
        xAxis.setDrawGridLines(true)
        xAxis.enableGridDashedLine(30f, 0f, 0f)
        xAxis.textColor = Color.LTGRAY
        xAxis.valueFormatter = XValueFormatter()
        val light = Typeface.createFromAsset(this.assets, "OpenSans-Regular.ttf")
        xAxis.typeface = light
//        xAxis.labelCount = UIScreen.main.bounds.size.width > 375 ? 5 : 4
        xAxis.labelCount = /*5*/4
        xAxis.textColor = Color.BLACK
        xAxis.yOffset = 10f
        mChart!!.setExtraOffsets(0f,0f,0f,10f)
        //todo find out how manipulate with limits
//        xAxis.axisMinimum = 0f/*self.dataProvider.leftXLimit*/
//        xAxis.axisMaximum = 0f/*self.dataProvider.rightXLimit*/

        mChart!!.axisRight.isEnabled = false

//        mChart!!.setViewPortOffsets(100f,0f,-40f,0f)
//        mChart!!.offsetLeftAndRight(100)
//        mChart!!.setDragOffsetX(50f)


//        val yValueRenderer = YValueRenderer(
//                mChart!!.viewPortHandler,
//                mChart!!.getAxis(YAxis.AxisDependency.LEFT),
//                mChart!!.rendererXAxis.transformer
//        )
//        mChart!!.rendererLeftYAxis = yValueRenderer

        val yAxis = mChart!!.getAxis(YAxis.AxisDependency.LEFT)
        yAxis.setPosition(YAxis.YAxisLabelPosition.INSIDE_CHART)
        yAxis.setDrawTopYLabelEntry(false)
        yAxis.setDrawLimitLinesBehindData(false)
        yAxis.axisMinimum = 0f/*self.dataProvider.lowerYLimit*/
        yAxis.axisMaximum = 10000f/*self.dataProvider.upperYLimit*/
        yAxis.labelCount = ((yAxis.axisMaximum - yAxis.axisMinimum).toInt()) / 1000
        yAxis.gridColor = Color.LTGRAY
        yAxis.setDrawGridLines(true)
        yAxis.enableGridDashedLine(30f, 0f, 0f)
        yAxis.textColor = Color.BLACK
        yAxis.valueFormatter = YValueFormatter()
//        yAxis.xOffset = yAxis.xOffset - 4f/*yLabelRectInset*/
//        yAxis.xOffset -= 40f

        mChart!!.invalidate()
    }


    private fun setupBabyLine() {

        if (scales > 0) {

            val values2 = ArrayList<Entry>()

            for (i in 0 until scales) {
                Timber.e("baby value = ${percentileBabyScales[i].toFloat()}")
                values2.add(Entry(i.toFloat(), percentileBabyScales[i].toFloat()))
            }

            val line = LineDataSet(values2, babyName)

            line.setDrawIcons(false)

            // set the line to be drawn like this "- - - - - -"
            line.enableDashedLine(10f, 0f, 0f)
            line.enableDashedHighlightLine(10f, 0f, 0f)


            if (babyGender == Const.Genders.MALE) {
                line.color = Color.rgb(152, 210, 212)
                line.setCircleColor(Color.rgb(152, 210, 212))
            } else {
                line.color = Color.rgb(221, 160, 199)
                line.setCircleColor(Color.rgb(221, 160, 199))
            }
//        line.setCircleColorHole(line.colors[0])
            line.lineWidth = 3f
            line.circleRadius = 5f
            line.circleHoleRadius = line.circleRadius * 0.8f
            line.axisDependency = YAxis.AxisDependency.LEFT
            line.setDrawValues(true)
//        line.valueTextSize = 10f
            line.setDrawVerticalHighlightIndicator(false)
            line.setDrawHorizontalHighlightIndicator(false)

            line.formLineWidth = 1f
            line.formSize = 15f


//            val data = LineData()

            data.addDataSet(line)
            /*data.addDataSet(setDataP3())
            data.addDataSet(setDataP15())
            data.addDataSet(setDataP50())
            data.addDataSet(setDataP85())
            data.addDataSet(setDataP97())*/
            setDataAll()

            mChart!!.data = data
            mChart!!.description = null
            mChart!!.invalidate()

            fab?.visibility = View.VISIBLE
            mChart!!.visibility = View.VISIBLE
        }
        else {
            Toast.makeText(this@WhoGraphActivity, babyName.plus(" have no scales."), Toast.LENGTH_LONG).show()
        }
    }


    class YValueRenderer(viewPortHandler: ViewPortHandler?, yAxis: YAxis?, trans: Transformer?) : YAxisRenderer(viewPortHandler, yAxis, trans) {


        override fun drawYLabels(c: Canvas?, fixedPosition: Float, positions: FloatArray?, offset: Float) {
            super.drawYLabels(c, fixedPosition, positions, offset)

//            c!!.drawText("MY_TEXT_111", fixedPosition, fixedPosition, mAxisLabelPaint)
        }

        override fun renderAxisLabels(context: Canvas) {

            Timber.e("renderAxisLabels go 1")

            if (mYAxis == null) return

            if (!mYAxis.isEnabled || !mYAxis.isDrawLabelsEnabled) return

            Timber.e("renderAxisLabels go 2")

            val xoffset = mYAxis.xOffset
            val yoffset = Utils.calcTextHeight(mAxisLabelPaint, "A") / 2.5 + mYAxis.yOffset
            val dependency = mYAxis.axisDependency
            val labelPosition = mYAxis.labelPosition
            var xPos = 0f
            val textAlign = mAxisLabelPaint


            if (dependency == YAxis.AxisDependency.LEFT) {
                if (labelPosition == YAxis.YAxisLabelPosition.OUTSIDE_CHART) {
                    textAlign.textAlign = Paint.Align.RIGHT
                    xPos = mViewPortHandler.offsetLeft() - xoffset
                } else {
                    textAlign.textAlign = Paint.Align.LEFT
                    xPos = mViewPortHandler.offsetLeft() + xoffset
                }
            } else {
                if (labelPosition == YAxis.YAxisLabelPosition.OUTSIDE_CHART) {
                    textAlign.textAlign = Paint.Align.LEFT
                    xPos = mViewPortHandler.contentRight() + xoffset
                } else {
                    textAlign.textAlign = Paint.Align.RIGHT
                    xPos = mViewPortHandler.contentRight() - xoffset
                }
            }

            val fixedPosition = xPos
            val positions = transformedPositions
//            val offset = yoffset - yAxis.labelFont.lineHeight
            val offset = yoffset - Utils.calcTextHeight(mAxisLabelPaint, "B")
//            val offset = 0f

            var from = -1
            if (mYAxis.isDrawBottomYLabelEntryEnabled) from = 0
            else from = 1
            var to = -1
            if (mYAxis.isDrawTopYLabelEntryEnabled) to = mYAxis.mEntryCount
            else to = mYAxis.mEntryCount - 1
//            val attributes = [NSAttributedStringKey.font: labelFont]
            val col = /*yLabelBackgroundColor*/Color.LTGRAY

            for (i in from..to step 1) {

                val text = mYAxis.getFormattedLabel(i)
                var point = /*CGPoint*/MPPointF(fixedPosition, ((positions[i] + offset).toFloat()))
//                val textSize = text.size(withAttributes: attributes)
//                val textSize = textAlign.textSize
                val textSize = textAlign.textSize

                if (textAlign == Paint.Align.CENTER) {
                    point.x -= textSize/*.width*/ / 2.0f
                } else if (textAlign == YAxis.AxisDependency.RIGHT) {
                    point.x -= textSize/*.width*/
                }
                else if (textAlign == YAxis.AxisDependency.LEFT) {
                    point.x += textSize
                }

                val rect = RectF(point.x, point.y, 4f, 0f)
                val path = Path()
                path.addRect(rect, Path.Direction.CCW)

//                context.clipOutPath(path)
                val paint = Paint()
//                paint.color = Color.RED
//                paint.style = Paint.Style.FILL
//                context.drawPaint(paint)

                paint.color = Color.BLACK
                paint.textSize = 20f
//                context.drawText("Some Text", 100f, 125f, paint)

//                context.drawColor(Color.RED)
//                context.drawCircle(100f,100f,30f, paint)
//                path.rewind()
                context.drawPath(path, paint)


//                UIGraphicsPushContext(context)
//                col.set()
//                path.fill()
//                UIGraphicsPopContext()

//                mAxisLabelPaint.

                /*val rect = CGRect(point, textSize).insetBy(-yLabelRectInset, 0)
                val path = UIBezierPath.init(rect, yLabelRectInset)

                UIGraphicsPushContext(context)
                col.set()
                path.fill()
                UIGraphicsPopContext()*/
            }

            super.renderAxisLabels(context)
        }
    }

    class XValueRenderer(viewPortHandler: ViewPortHandler?, xAxis: XAxis?, trans: Transformer?) : XAxisRenderer(viewPortHandler, xAxis, trans) {

        override fun drawLabel(context: Canvas, formattedLabel: String, x: Float, y: Float, anchor: MPPointF, angleRadians: Float) {

            if (formattedLabel == "kBirthday") {

                context.drawBitmap(bitmap, x-20, y-50, null)

                setBirthdayColor()

                super.drawLabel(context, formattedLabel, x, y, anchor, angleRadians)
                return
            }
            else {
                mAxisLabelPaint.color = Color.BLACK
            }
            super.drawLabel(context, formattedLabel, x, y, anchor, angleRadians)
        }

        private fun setBirthdayColor() {
            if (babyGender == Const.Genders.MALE) {
                mAxisLabelPaint.color = Color.rgb(152, 210, 212)
            }
            else {
                mAxisLabelPaint.color = Color.rgb(221, 160, 199)
            }
        }
    }


    class XValueFormatter: IndexAxisValueFormatter() {

        override fun getFormattedValue(value: Float, axis: AxisBase?): String {
            if (value == 0f)
                return "kBirthday"
            if (value < 1)
                return ""
            val i = value.toInt()
            return i.toString().plus(" weeks")
        }
    }

    class YValueFormatter: IndexAxisValueFormatter() {

        override fun getFormattedValue(value: Float, axis: AxisBase?): String {
            var stroke = value.toInt().toString()
            if (value == 0f) return ""
            else {
                if (value > 1000f)
                    stroke = stroke.substring(0, 1).plus(" ").plus(stroke.substring(1, stroke.length))
            }
            return stroke.plus(" g")
        }
    }

    private fun getCurrentTimeStamp(): String? {
        return try {
            val dateFormat = SimpleDateFormat("yyyy-MM-dd_HH:mm:ss")
            dateFormat.format(Date())
        } catch (e: Exception) {
            e.printStackTrace()
            null
        }
    }


    private fun setDataP3() : LineDataSet {
        val values2 = ArrayList<Entry>()

        for (i in 0 until scales) {
            values2.add(Entry(i.toFloat(), percentileP3[i].toFloat()))
        }

        val set = LineDataSet(values2, "P3")
        set.setDrawIcons(false)

        set.enableDashedLine(10f, 15f, 0f)
        set.color = Color.GRAY
        set.setCircleColor(Color.GRAY)
        set.lineWidth = 1.5f
        set.circleRadius = 2f
        set.setDrawCircles(false)
        set.setDrawCircleHole(false)
        set.setDrawValues(false)
        set.setDrawFilled(false)
        set.formLineWidth = 1f
        set.formSize = 15f

        return  set
    }

    private fun setDataAll() {

        for ((pos, value) in allPercentiles.withIndex()) {
            val values = ArrayList<Entry>()

            for (i in 0 until scales) {
                values.add(Entry(i.toFloat(), value[i].toFloat()))
            }

            val set = LineDataSet(values, allPercentilesTitles[pos])
            set.setDrawIcons(false)

//            set.enableDashedLine(10f, 15f, 0f)
            set.enableDashedLine(allDashedLinesLength[pos], allDashedLinesSpaceLength[pos], 0f)
            set.color = Color.GRAY
            set.setCircleColor(Color.GRAY)
            set.lineWidth = 1.5f
            set.circleRadius = 2f
            set.setDrawCircles(false)
            set.setDrawCircleHole(false)
            set.setDrawValues(false)
            set.setDrawFilled(false)
            set.formLineWidth = 1f
            set.formSize = 15f

            data.addDataSet(set)
        }
    }

    private fun setDataP15() : LineDataSet {
        val values2 = ArrayList<Entry>()

        for (i in 0 until scales) {
            values2.add(Entry(i.toFloat(), percentileP15[i].toFloat()))
        }

        val set = LineDataSet(values2, "P15")
        set.setDrawIcons(false)

        set.enableDashedLine(10f, 10f, 0f)
        set.color = Color.GRAY
        set.setCircleColor(Color.GRAY)
        set.lineWidth = 1.5f
        set.circleRadius = 2f
        set.setDrawCircles(false)
        set.setDrawCircleHole(false)
        set.setDrawValues(false)
        set.setDrawFilled(false)
        set.formLineWidth = 1f
        set.formSize = 15f

        return set
    }

    private fun setDataP50() : LineDataSet {
        val values2 = ArrayList<Entry>()

        for (i in 0 until scales) {
            values2.add(Entry(i.toFloat(), percentileP50[i].toFloat()))
        }

        val set = LineDataSet(values2, "P50")
        set.setDrawIcons(false)

        set.enableDashedLine(20f, 20f, 0f)
        set.color = Color.GRAY
        set.setCircleColor(Color.GRAY)
        set.lineWidth = 1.5f
        set.circleRadius = 2f
        set.setDrawCircles(false)
        set.setDrawCircleHole(false)
        set.setDrawValues(false)
        set.setDrawFilled(false)
        set.formLineWidth = 1f
        set.formSize = 15f

        return set
    }

    private fun setDataP85() : LineDataSet {
        val values2 = ArrayList<Entry>()

        for (i in 0 until scales) {
            values2.add(Entry(i.toFloat(), percentileP85[i].toFloat()))
        }

        val set = LineDataSet(values2, "P85")
        set.setDrawIcons(false)

        set.enableDashedLine(10f, 10f, 0f)
        set.color = Color.GRAY
        set.setCircleColor(Color.GRAY)
        set.lineWidth = 1.5f
        set.circleRadius = 2f
        set.setDrawCircles(false)
        set.setDrawCircleHole(false)
        set.setDrawValues(false)
        set.setDrawFilled(false)
        set.formLineWidth = 1f
        set.formSize = 15f

        return set
    }

    private fun setDataP97() : LineDataSet {
        val values2 = ArrayList<Entry>()

        for (i in 0 until scales) {
            values2.add(Entry(i.toFloat(), percentileP97[i].toFloat()))
        }

        val set = LineDataSet(values2, "P97")
        set.setDrawIcons(false)

        set.enableDashedLine(10f, 10f, 0f)
        set.color = Color.GRAY
        set.setCircleColor(Color.GRAY)
        set.lineWidth = 1.5f
        set.circleRadius = 2f
        set.setDrawCircles(false)
        set.setDrawCircleHole(false)
        set.setDrawValues(false)
        set.setDrawFilled(false)
        set.formLineWidth = 1f
        set.formSize = 15f

        return set
    }

    override  fun onChartFling(me1: MotionEvent, me2: MotionEvent, velocityX: Float, velocityY: Float) {
        Log.i("Fling", "Chart flinged. VeloX: $velocityX, VeloY: $velocityY")
    }

    override   fun onChartScale(me: MotionEvent, scaleX: Float, scaleY: Float) {
        Log.i("Scale / Zoom", "ScaleX: $scaleX, ScaleY: $scaleY")
        recalculateXLimits()
    }

    override  fun onChartTranslate(me: MotionEvent, dX: Float, dY: Float) {
        Log.i("Translate / Move", "dX: $dX, dY: $dY")
        recalculateXLimits()
    }

    private fun recalculateXLimits() {

        val lineChartView = mChart!!
        val minX = -4.0 / mChart!!.scaleX

        if (lineChartView.lowestVisibleX < minX) {
            lineChartView.moveViewToX(minX.toFloat())
            lineChartView.invalidate()
        }
    }

    override fun onChartGestureEnd(me: MotionEvent?, lastPerformedGesture: ChartTouchListener.ChartGesture?) {
        // no-opt
    }

    override fun onChartSingleTapped(me: MotionEvent?) {
        // no-opt
    }

    override fun onChartGestureStart(me: MotionEvent?, lastPerformedGesture: ChartTouchListener.ChartGesture?) {
        // no-opt
    }

    override fun onChartLongPressed(me: MotionEvent?) {
        // no-opt
    }

    override fun onChartDoubleTapped(me: MotionEvent?) {
        // no-opt
    }
}