MainActivity: generate dynamic menu from last two weeks

Make the UI more flexible and
slightly easier to understand.

app/src/main/java/it/danieleverducci/lunatracker/StatisticsActivity.kt

@@ -181,11 +181,14 @@ class StatisticsActivity : AppCompatActivity() {
         val values = ArrayList<BarEntry>()
         val stack = ArrayList(List(state.endSpan - state.startSpan + 1) { IntArray(24 * 60 * 60 / SLEEP_PATTERN_GRANULARITY) })
 
+        Log.d(TAG, "stack.size: ${stack.size}, array.size: ${stack[0].size}, dayCounter.daysWithData.size: ${state.dayCounter.daysWithData.size}")
+
         fun stackValuePattern(index: Int, spanBegin: Long, spanEnd: Long, begin: Long, end: Long) {
             val beginDays = unixToDays(begin)
             val endDays = unixToDays(end)
             var mid = begin
 
+            //Log.d(TAG, "stackValuePattern: ${beginDays}..${endDays}")
             for (i in beginDays..endDays) {
                 // i is the days/weeks/months since unix epoch
                 val dayBegin = daysToUnix(i)
@@ -198,6 +201,7 @@ class StatisticsActivity : AppCompatActivity() {
                     assert(sleepBegin <= sleepEnd)
                     val iBegin = (sleepBegin - dayBegin) / SLEEP_PATTERN_GRANULARITY
                     val iEnd = iBegin + (sleepEnd - sleepBegin) / SLEEP_PATTERN_GRANULARITY
+                    //Log.d(TAG, "index: $index, iBegin: $iBegin, iEnd: $iEnd, dayBegin: ${Date(dayBegin * 1000)}, dayEnd: ${Date(dayEnd * 1000)}, sleepBegin: ${Date(sleepBegin * 1000)}, sleepEnd: ${Date(sleepEnd * 1000)}")
                     for (j in iBegin..<iEnd) {
                         stack[index][j.toInt()] += 1
                     }
@@ -215,14 +219,17 @@ class StatisticsActivity : AppCompatActivity() {
             val endIndex = unixToSpan(endUnix)
             var mid = startUnix
 
+            //Log.d(TAG, "startUnix: ${Date(startUnix * 1000)}, endUnix: ${Date(endUnix * 1000)}, begIndex: $begIndex, endIndex: $endIndex (index diff: ${endIndex - begIndex})")
             for (i in begIndex..endIndex) {
                 // i is the days/weeks/months since unix epoch
                 val spanBegin = spanToUnix(i)
                 val spanEnd =  spanToUnix(i + 1)
+                //Log.d(TAG, "mid: ${Date(mid * 1000)}, spanBegin: ${Date(spanBegin * 1000)}, spanEnd: ${Date(spanEnd * 1000)}, beginUnix: ${Date(startUnix * 1000)} endUnix: ${Date(endUnix * 1000)}")
                 val sleepBegin = max(mid, spanBegin)
                 val sleepEnd = min(endUnix, spanEnd)
                 val index = i - state.startSpan
                 val duration = sleepEnd - sleepBegin
+                //Log.d(TAG, "[$index] sleepBegin: ${Date(sleepBegin * 1000)}, sleepEnd: ${Date(sleepEnd * 1000)}, ${DateUtils.formatTimeDuration(this, duration)}")
 
                 state.dayCounter.setDaysWithData(sleepBegin, sleepEnd)
                 stackValuePattern(index, spanBegin, spanEnd, sleepBegin, sleepEnd)
@@ -249,6 +256,7 @@ class StatisticsActivity : AppCompatActivity() {
         for ((index, dayArray) in stack.withIndex()) {
             val daysWithData = state.dayCounter.countDaysWithData(spanToUnix(state.startSpan + index), spanToUnix(state.startSpan + index + 1))
 
+            //Log.d(TAG, "index: $index: daysWithData: $daysWithData, dayArray: ${dayArray.joinToString { it.toString() }}")
             val vals = ArrayList<Float>()
 
             var prevIndex = -1 // time slot index
@@ -270,10 +278,14 @@ class StatisticsActivity : AppCompatActivity() {
                 allColors.add(mapColor(prevValue, daysWithData))
             }
 
+            //Log.d(TAG, "Range $index, vals: ${vals.joinToString { it.toInt().toString() }}") //, allColors: ${allColors.joinToString { it.toString() }}")
+
             assert(values.size == index)
             values.add(BarEntry(values.size.toFloat(), vals.toFloatArray()))
         }
 
+        //Log.d(TAG, "daysWithData: ${state.dayCounter.daysWithData.joinToString()}")
+
         barChart.setOnChartValueSelectedListener(object : OnChartValueSelectedListener {
             override fun onValueSelected(e: Entry?, h: Highlight?) {
                 if (e == null || h == null) {
@@ -344,6 +356,8 @@ class StatisticsActivity : AppCompatActivity() {
         set1.isHighlightEnabled = true
         set1.setDrawIcons(false)
 
+        //Log.d(TAG, "showSleepPatternBarGraphSlotted; barChart.xAxis.labelCount: ${barChart.xAxis.labelCount}, barChart.visibleXRange: ${barChart.visibleXRange}, barChart.xAxis.isCenterAxisLabelsEnabled: ${barChart.xAxis.isCenterAxisLabelsEnabled}, barChart.isAutoScaleMinMaxEnabled: ${barChart.isAutoScaleMinMaxEnabled}, barChart.isScaleXEnabled: ${barChart.isScaleXEnabled}, barChart.isScaleYEnabled: ${barChart.isScaleYEnabled}")
+
         val data = BarData(set1)
         data.setValueTextSize(12f)
 
@@ -397,14 +411,17 @@ class StatisticsActivity : AppCompatActivity() {
             val endIndex = unixToSpan(endUnix)
             var mid = startUnix
 
+            //Log.d(TAG, "startUnix: ${Date(startUnix * 1000)}, endUnix: ${Date(endUnix * 1000)}, begIndex: $begIndex, endIndex: $endIndex (index diff: ${endIndex - begIndex})")
             for (i in begIndex..endIndex) {
                 // i is the days/weeks/months since unix epoch
                 val spanBegin = spanToUnix(i)
                 val spanEnd =  spanToUnix(i + 1)
+                //Log.d(TAG, "mid: ${Date(mid * 1000)}, spanBegin: ${Date(spanBegin * 1000)}, spanEnd: ${Date(spanEnd * 1000)}, beginUnix: ${Date(startUnix * 1000)} endUnix: ${Date(endUnix * 1000)}")
                 val sleepBegin = max(mid, spanBegin)
                 val sleepEnd = min(endUnix, spanEnd)
                 val index = i - state.startSpan
                 val duration = sleepEnd - sleepBegin
+                //Log.d(TAG, "[$index] sleepBegin: ${Date(sleepBegin * 1000)}, sleepEnd: ${Date(sleepEnd * 1000)}, ${DateUtils.formatTimeDuration(this, duration)}")
 
                 state.dayCounter.setDaysWithData(sleepBegin, sleepEnd)
                 stackValuePattern(index, spanBegin, spanEnd, sleepBegin, sleepEnd)
@@ -457,10 +474,13 @@ class StatisticsActivity : AppCompatActivity() {
 
             override fun onNothingSelected() {}
         })
+        //Log.d(TAG, "showSleepPatternBarGraphDaily: values.size: ${values.size}, barChart.xAxis.labelCount: ${barChart.xAxis.labelCount}")
 
         val data = BarData(set1)
         data.setValueTextSize(12f)
 
+        //Log.d(TAG, "showSleepPatternBarGraphDaily: new barChart.xAxis.labelCount: ${barChart.xAxis.labelCount}")
+
         val valueCount = min(values.size, 24)
         barChart.setData(data)
         barChart.legend.isEnabled = false
@@ -499,14 +519,18 @@ class StatisticsActivity : AppCompatActivity() {
             val endIndex = unixToSpan(endUnix)
             var mid = startUnix
 
+            //Log.d(TAG, "beginIndex: $begIndex, endIndex: $endIndex, startUnix: ${Date(startUnix * 1000)} ($startUnix), endUnix: ${Date(endUnix * 1000)} ($endUnix)")
+            //Log.d(TAG, "startUnix: ${Date(startUnix * 1000)}, endUnix: ${Date(endUnix * 1000)}, begIndex: $begIndex, endIndex: $endIndex (index diff: ${endIndex - begIndex})")
             for (i in begIndex..endIndex) {
                 // i is the days/weeks/months since unix epoch
                 val spanBegin = spanToUnix(i)
                 val spanEnd =  spanToUnix(i + 1)
+                //Log.d(TAG, "i: $i, mid: ${Date(mid * 1000)}, spanBegin: ${Date(spanBegin * 1000)}, spanEnd: ${Date(spanEnd * 1000)}, beginUnix: ${Date(startUnix * 1000)} endUnix: ${Date(endUnix * 1000)}")
                 val sleepBegin = max(mid, spanBegin)
                 val sleepEnd = min(endUnix, spanEnd)
                 val index = i - state.startSpan
                 val duration = sleepEnd - sleepBegin
+                //Log.d(TAG, "[$index] sleepBegin: ${Date(sleepBegin * 1000)}, sleepEnd: ${Date(sleepEnd * 1000)}, ${DateUtils.formatTimeDuration(this, duration)}")
 
                 state.dayCounter.setDaysWithData(sleepBegin, sleepEnd)
 
@@ -589,6 +613,7 @@ class StatisticsActivity : AppCompatActivity() {
 
         for (index in values.indices) {
             val daysWithData = state.dayCounter.countDaysWithData(spanToUnix(state.startSpan + index), spanToUnix(state.startSpan + index + 1))
+            //Log.d(TAG, "values[$index].y: ${values[index].y}, daysWithData: $daysWithData")
             if (daysWithData == 0) {
                 assert(values[index].y == 0F)
             } else {
@@ -639,6 +664,7 @@ class StatisticsActivity : AppCompatActivity() {
         fun countDaysWithData(beginUnix: Long, endUnix: Long): Int {
             val beginDays = unixToDays(beginUnix)
             val endDays = unixToDays(endUnix)
+            //Log.d(TAG, "countDaysWithData: beginDays: $beginDays, endDays: $endDays, ${Date(beginUnix * 1000)} - ${Date(endUnix * 1000)}")
             var count = 0
             for (i in (beginDays - startDays)..<(endDays - startDays)) {
                 //Log.d(TAG, "countDaysWithData: i: $i, size: ${daysWithData.size}")
@@ -668,6 +694,7 @@ class StatisticsActivity : AppCompatActivity() {
         barChart.notifyDataSetChanged()
         barChart.clear()
         barChart.invalidate()
+        //Log.d(TAG, "resetBarChart; barChart.xAxis.labelCount: ${barChart.xAxis.labelCount}, barChart.visibleXRange: ${barChart.visibleXRange}, barChart.xAxis.isCenterAxisLabelsEnabled: ${barChart.xAxis.isCenterAxisLabelsEnabled}, barChart.isAutoScaleMinMaxEnabled: ${barChart.isAutoScaleMinMaxEnabled}, barChart.isScaleXEnabled: ${barChart.isScaleXEnabled}, barChart.isScaleYEnabled: ${barChart.isScaleYEnabled}")
 
         val type = when (graphTypeSelection) {
             GraphType.BOTTLE_EVENTS,
@@ -702,6 +729,8 @@ class StatisticsActivity : AppCompatActivity() {
         val endDays = unixToDays(spanToUnix(endSpan + 1)) // until end of next span
         val dayCounter = DayCounter(startDays, endDays)
 
+        //Log.d(TAG, "startUnix: ${Date(1000 * startUnix)}, endUnix: ${Date(1000 * endUnix)}, startSpan: ${Date(1000 * spanToUnix(startSpan))}, endSpan: ${Date(1000 * spanToUnix(endSpan))}, startDaysUnix: ${Date(daysToUnix(startDays) * 1000)}. endDaysUnix: ${Date(daysToUnix(endDays) * 1000)}")
+
         // print dates
         barChart.xAxis.valueFormatter = object: ValueFormatter() {
             override fun getFormattedValue(value: Float): String {
@@ -715,6 +744,8 @@ class StatisticsActivity : AppCompatActivity() {
                 val week = dateTime.get(Calendar.WEEK_OF_YEAR)
                 val day = dateTime.get(Calendar.DAY_OF_MONTH)
 
+                //Log.d(TAG, "index: $index, unixSeconds: ${Date(1000 * unixSeconds)}, day: $day, week: $week, month: $month, year: $year")
+
                 // Adjust years if the first week of a year starts in the previous year.
                 val years = if (month == 12 && week == 1) {
                     year + 1
@@ -766,6 +797,8 @@ class StatisticsActivity : AppCompatActivity() {
         val spinnerAdapter =
             ArrayAdapter.createFromResource(this, arrayId, R.layout.statistics_spinner_item)
 
+        //Log.d(TAG, "spinner ${arrayValues.indexOf(currentValue)} (${arrayValues.joinToString { it }})")
+
         spinner.adapter = spinnerAdapter
         spinner.setSelection(arrayValues.indexOf(currentValue))
         spinner.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {