Work on aggregation type for evo graphs

app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt

@@ -7,7 +7,6 @@ import net.pokeranalytics.android.model.comparison.combined
 import net.pokeranalytics.android.model.filter.QueryCondition
 import net.pokeranalytics.android.model.filter.name
 import net.pokeranalytics.android.model.realm.ComputableResult
-import net.pokeranalytics.android.model.realm.Filter
 import net.pokeranalytics.android.model.realm.SessionSet
 import timber.log.Timber
 import java.util.*
@@ -20,7 +19,11 @@ class Calculator {
 	/**
 	 * The options used for calculations or display
 	 */
-	class Options {
+	class Options(
+		display: Display = Display.TABLE,
+		evolutionValues: EvolutionValues = EvolutionValues.NONE,
+		stats: List<Stat> = listOf()
+	) {
 
 		/**
 		 * The way the stats are going to be displayed
@@ -42,9 +45,9 @@ class Calculator {
 			TIMED
 		}
 
-		var display: Display = Display.TABLE
+		var display: Display = display
-		var evolutionValues: EvolutionValues = EvolutionValues.NONE
+		var evolutionValues: EvolutionValues = evolutionValues
-		var displayedStats: List<Stat> = listOf()
+		var displayedStats: List<Stat> = stats
 
 		/**
 		 * This function determines whether the standard deviation should be computed
@@ -64,7 +67,36 @@ class Calculator {
 
 	companion object {
 
-		fun computeStatsWithComparators(realm: Realm, comparators: List<Comparator> = listOf(), conditions: List<QueryCondition> = listOf(), options: Options): Report {
+		fun computeStatsWithEvolutionByAggregationType(
+			realm: Realm,
+			group: ComputableGroup,
+			aggregationType: AggregationType
+		): Report {
+
+			val options = Options(evolutionValues = Options.EvolutionValues.STANDARD)
+			if (aggregationType == AggregationType.DURATION) {
+				options.evolutionValues = Options.EvolutionValues.TIMED
+			}
+
+			return when (aggregationType) {
+				AggregationType.SESSION, AggregationType.DURATION -> this.computeGroups(realm, listOf(group), options)
+				AggregationType.MONTH -> {
+					val comparators: List<Comparator> = listOf(Comparator.YEAR, Comparator.MONTH_OF_YEAR)
+					this.computeStatsWithComparators(realm, comparators, group.conditions, options)
+				}
+				AggregationType.YEAR -> {
+					val comparators: List<Comparator> = listOf(Comparator.YEAR)
+					this.computeStatsWithComparators(realm, comparators, group.conditions, options)
+				}
+			}
+		}
+
+		fun computeStatsWithComparators(
+			realm: Realm,
+			comparators: List<Comparator> = listOf(),
+			conditions: List<QueryCondition> = listOf(),
+			options: Options
+		): Report {
 
 			val computableGroups: MutableList<ComputableGroup> = mutableListOf()
 			comparators.combined().forEach { comparatorConditions ->
@@ -86,18 +118,6 @@ class Calculator {
 			return this.computeGroups(realm, computableGroups, options)
 		}
 
-		fun computeStatsWithFilters(realm: Realm, filters: List<Filter>, options: Options): Report {
-
-			val computableGroups: MutableList<ComputableGroup> = mutableListOf()
-			filters.forEach { filter ->
-
-				val group = ComputableGroup(filter.name, filter.filterConditions.map { it.queryCondition })
-				computableGroups.add(group)
-
-			}
-			return Calculator.computeGroups(realm, computableGroups, options)
-		}
-
 		/**
 		 * Computes all stats for list of Session sessionGroup
 		 */
@@ -257,7 +277,12 @@ class Calculator {
 							Options.EvolutionValues.TIMED -> {
 								results.addEvolutionValue(tSum, tHourlyDuration, NETRESULT, sessionSet)
 								results.addEvolutionValue(tHourlyRate, tHourlyDuration, HOURLY_RATE, sessionSet)
-								results.addEvolutionValue(tIndex.toDouble(), tHourlyDuration, NUMBER_OF_SETS, sessionSet)
+								results.addEvolutionValue(
+									tIndex.toDouble(),
+									tHourlyDuration,
+									NUMBER_OF_SETS,
+									sessionSet
+								)
 								results.addEvolutionValue(
 									sessionSet.netDuration.toDouble(),
 									tHourlyDuration,
@@ -273,7 +298,12 @@ class Calculator {
 								results.addEvolutionValue(tHourlyRateBB, tHourlyDuration, HOURLY_RATE_BB, sessionSet)
 
 								Stat.netBBPer100Hands(gBBSum, gTotalHands)?.let { netBB100 ->
-									results.addEvolutionValue(netBB100, tHourlyDuration, NET_BB_PER_100_HANDS, sessionSet)
+									results.addEvolutionValue(
+										netBB100,
+										tHourlyDuration,
+										NET_BB_PER_100_HANDS,
+										sessionSet
+									)
 								}
 							}
 						}

app/src/main/java/net/pokeranalytics/android/ui/fragment/GraphFragment.kt

@@ -13,7 +13,9 @@ import com.github.mikephil.charting.highlight.Highlight
 import com.github.mikephil.charting.listener.OnChartValueSelectedListener
 import com.google.android.material.chip.Chip
 import com.google.android.material.chip.ChipGroup
+import io.realm.Realm
 import kotlinx.android.synthetic.main.fragment_evograph.*
+import kotlinx.coroutines.*
 import net.pokeranalytics.android.R
 import net.pokeranalytics.android.calculus.*
 import net.pokeranalytics.android.ui.activity.components.PokerAnalyticsActivity
@@ -23,25 +25,32 @@ import net.pokeranalytics.android.ui.fragment.components.PokerAnalyticsFragment
 import net.pokeranalytics.android.ui.graph.PALineDataSet
 import net.pokeranalytics.android.ui.graph.setStyle
 import net.pokeranalytics.android.ui.view.LegendView
+import timber.log.Timber
 import java.text.DateFormat
+import java.util.*
+import kotlin.coroutines.CoroutineContext
 
 class GraphParameters(var stat: Stat, var report: Report) {
 
 }
 
-class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener {
+class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener, CoroutineScope {
 
 	private lateinit var parentActivity: PokerAnalyticsActivity
 
 	private var stat: Stat = Stat.NETRESULT
-	private var reports: Map<AggregationType, Report> = hashMapOf()
+	private var reports: MutableMap<AggregationType, Report> = hashMapOf()
-	private var entries: List<Entry> = ArrayList()
+
+	private var selectedReport: Report? = null
 
 	lateinit var legendView: LegendView
 	lateinit var chartView: BarLineChartBase<*>
 
 	private var aggregationTypes: List<AggregationType> = listOf()
 
+	override val coroutineContext: CoroutineContext
+		get() = Dispatchers.Main
+
 	companion object {
 
 	}
@@ -50,10 +59,8 @@ class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener {
 		this.stat = stat
 
 		this.aggregationTypes = stat.aggregationTypes
-//		this.report = report
+		this.reports[this.aggregationTypes.first()] = report
-		report.results.firstOrNull()?.defaultStatEntries(stat)?.let {
+		this.selectedReport = report
-			this.entries = it
-		}
 
 	}
 
@@ -76,9 +83,78 @@ class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener {
 
 		this.legendView = LegendView(requireContext())
 		this.legendContainer.addView(this.legendView)
-		this.legendView.prepareWithStat(this.stat, this.entries.size)
 
-		val dataSet = PALineDataSet(this.entries, this.stat.name, requireContext())
+		this.selectedReport?.let {
+			this.loadGraph(it)
+		}
+
+		this.aggregationTypes.forEach { type ->
+			val chip = Chip(requireContext())
+			chip.id = type.ordinal
+			chip.text = requireContext().getString(type.resId)
+			chip.chipStartPadding = 8f.px
+			chip.chipEndPadding = 8f.px
+			this.chipGroup.addView(chip)
+		}
+
+		this.chipGroup.check(this.stat.aggregationTypes.first().ordinal)
+
+		this.chipGroup.setOnCheckedChangeListener(object : ChipGroupExtension.SingleSelectionOnCheckedListener() {
+			override fun onCheckedChanged(group: ChipGroup, checkedId: Int) {
+				super.onCheckedChanged(group, checkedId)
+				val aggregationType = aggregationTypes[checkedId]
+
+				reports[aggregationType]?.let {
+					loadGraph(it)
+				} ?: run {
+
+				}
+
+			}
+		})
+
+	}
+
+	private fun launchStatComputation() {
+
+		GlobalScope.launch(coroutineContext) {
+
+			var r: Report? = null
+			val test = GlobalScope.async {
+				val s = Date()
+				Timber.d(">>> start...")
+
+				val realm = Realm.getDefaultInstance()
+
+				val aggregationType = stat.aggregationTypes.first()
+//				r = Calculator.computeStatsWithEvolutionByAggregationType(realm, computableGroup, aggregationType)
+
+				realm.close()
+
+				val e = Date()
+				val duration = (e.time - s.time) / 1000.0
+				Timber.d(">>> ended in $duration seconds")
+
+			}
+			test.await()
+
+			if (!isDetached) {
+				r?.let {
+					loadGraph(it)
+				}
+			}
+		}
+
+	}
+
+
+	fun loadGraph(report: Report) {
+
+		report.results.firstOrNull()?.defaultStatEntries(stat)?.let { entries ->
+
+			this.legendView.prepareWithStat(this.stat, entries.size)
+
+			val dataSet = PALineDataSet(entries, this.stat.name, requireContext())
 			val colors = arrayOf(R.color.green_light).toIntArray()
 			dataSet.setColors(colors, context)
 			dataSet.setDrawCircles(false)
@@ -101,26 +177,8 @@ class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener {
 			this.chartView.setStyle(false, requireContext())
 			this.chartView.setOnChartValueSelectedListener(this)
 
-		this.chartView.highlightValue((this.entries.size - 1).toFloat(), 0)
+			this.chartView.highlightValue((entries.size - 1).toFloat(), 0)
-
-		this.aggregationTypes.forEach { type ->
-			val chip = Chip(requireContext())
-			chip.id = type.ordinal
-			chip.text = requireContext().getString(type.resId)
-			chip.chipStartPadding = 8f.px
-			chip.chipEndPadding = 8f.px
-			this.chipGroup.addView(chip)
-		}
-
-		this.chipGroup.check(this.stat.aggregationTypes.first().ordinal)
-
-		this.chipGroup.setOnCheckedChangeListener(object : ChipGroupExtension.SingleSelectionOnCheckedListener() {
-			override fun onCheckedChanged(group: ChipGroup, checkedId: Int) {
-				super.onCheckedChanged(group, checkedId)
-				val aggregationType = aggregationTypes[checkedId]
-//				toast("Show: ${this.aggregationTypes[group.getChildAt(checkedId).id].name}")
 		}
-		})
 
 	}
 
@@ -133,7 +191,6 @@ class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener {
 	override fun onValueSelected(e: Entry?, h: Highlight?) {
 
 		e?.let { entry ->
-			h?.let { highlight ->
 
 			val identifier = entry.data as ObjectIdentifier
 			val item = getRealm().where(identifier.clazz).equalTo("id", identifier.id).findAll().firstOrNull()
@@ -145,7 +202,7 @@ class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener {
 
 				this.legendView.setItemData(this.stat, formattedDate, entryValue, totalStatValue)
 			}
-			}
+
 		}
 
 	}

app/src/main/java/net/pokeranalytics/android/ui/fragment/StatsFragment.kt

@@ -37,7 +37,7 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
 	private var stringTournament = ""
 
 	private lateinit var statsAdapter: RowRepresentableAdapter
-	private var report : Report? = null
+	private var report: Report? = null
 
 	companion object {
 
@@ -161,18 +161,40 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
 
 	}
 
-	private fun createSessionGroupsAndStartCompute(realm: Realm) : Report {
+	private fun createSessionGroupsAndStartCompute(realm: Realm): Report {
 
-        val allStats: List<Stat> = listOf(Stat.NETRESULT, Stat.HOURLY_RATE, Stat.AVERAGE, Stat.NUMBER_OF_SETS, Stat.AVERAGE_DURATION, Stat.DURATION)
+		val allStats: List<Stat> = listOf(
+			Stat.NETRESULT,
+			Stat.HOURLY_RATE,
+			Stat.AVERAGE,
+			Stat.NUMBER_OF_SETS,
+			Stat.AVERAGE_DURATION,
+			Stat.DURATION
+		)
 		val allSessionGroup = ComputableGroup(stringAll, listOf(), allStats)
-        val cgStats: List<Stat> = listOf(Stat.NETRESULT, Stat.HOURLY_RATE, Stat.NET_BB_PER_100_HANDS, Stat.HOURLY_RATE_BB, Stat.AVERAGE, Stat.STANDARD_DEVIATION_HOURLY, Stat.WIN_RATIO, Stat.NUMBER_OF_GAMES, Stat.AVERAGE_BUYIN)
+		val cgStats: List<Stat> = listOf(
+			Stat.NETRESULT,
+			Stat.HOURLY_RATE,
+			Stat.NET_BB_PER_100_HANDS,
+			Stat.HOURLY_RATE_BB,
+			Stat.AVERAGE,
+			Stat.STANDARD_DEVIATION_HOURLY,
+			Stat.WIN_RATIO,
+			Stat.NUMBER_OF_GAMES,
+			Stat.AVERAGE_BUYIN
+		)
 		val cgSessionGroup = ComputableGroup(stringCashGame, listOf(QueryCondition.CASH), cgStats)
-        val tStats: List<Stat> = listOf(Stat.NETRESULT, Stat.HOURLY_RATE, Stat.ROI, Stat.WIN_RATIO, Stat.NUMBER_OF_GAMES, Stat.AVERAGE_BUYIN)
+		val tStats: List<Stat> =
+			listOf(Stat.NETRESULT, Stat.HOURLY_RATE, Stat.ROI, Stat.WIN_RATIO, Stat.NUMBER_OF_GAMES, Stat.AVERAGE_BUYIN)
 		val tSessionGroup = ComputableGroup(stringTournament, listOf(QueryCondition.TOURNAMENT), tStats)
 
 		Timber.d(">>>>> Start computations...")
 
-        return Calculator.computeGroups(realm, listOf(allSessionGroup, cgSessionGroup, tSessionGroup), Calculator.Options())
+		return Calculator.computeGroups(
+			realm,
+			listOf(allSessionGroup, cgSessionGroup, tSessionGroup),
+			Calculator.Options()
+		)
 
 	}
 
@@ -181,7 +203,7 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
 		statsAdapter.notifyDataSetChanged()
 	}
 
-    private fun convertReportIntoRepresentables(report: Report) : ArrayList<RowRepresentable> {
+	private fun convertReportIntoRepresentables(report: Report): ArrayList<RowRepresentable> {
 
 		val rows: ArrayList<RowRepresentable> = ArrayList()
 
@@ -223,10 +245,14 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
 				Timber.d(">>> start...")
 
 				val realm = Realm.getDefaultInstance()
-				val options = Calculator.Options()
+//				val options = Calculator.Options()
-				options.evolutionValues = Calculator.Options.EvolutionValues.STANDARD
+//				options.evolutionValues = Calculator.Options.EvolutionValues.STANDARD
-				options.displayedStats = listOf(stat)
+//				options.displayedStats = listOf(stat)
-				report = Calculator.computeGroups(realm, listOf(computableGroup), options)
+
+				val aggregationType = stat.aggregationTypes.first()
+				report = Calculator.computeStatsWithEvolutionByAggregationType(realm, computableGroup, aggregationType)
+
+//				report = Calculator.computeGroups(realm, listOf(computableGroup), options)
 				realm.close()
 
 				val e = Date()