Fixes with criteria / aggregation

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

@@ -10,7 +10,6 @@ import net.pokeranalytics.android.model.filter.filter
 import net.pokeranalytics.android.model.filter.name
 import net.pokeranalytics.android.model.realm.ComputableResult
 import net.pokeranalytics.android.model.realm.SessionSet
-import net.pokeranalytics.android.model.upToNow
 import net.pokeranalytics.android.util.extensions.startOfDay
 import timber.log.Timber
 import java.util.*
@@ -121,22 +120,51 @@ class Calculator {
 			return when (aggregationType) {
 				AggregationType.SESSION, AggregationType.DURATION -> this.computeGroups(realm, listOf(group), options)
 				AggregationType.MONTH, AggregationType.YEAR -> {
-					val criteria: List<Criteria> = aggregationType.criterias
+					val queryLists = aggregationType.queryLists
-					this.computeStatsWithComparators(realm, criteria, group.conditions, options)
+					this.computeStatsWithComparators(realm, queryLists, group.conditions, options)
 				}
 			}
 		}
 
+
+		fun computeStatsWithCriterias(
+			realm: Realm,
+			criterias: List<Criteria>,
+			conditions: List<QueryCondition> = listOf(),
+			options: Options = Options()
+		): Report {
+
+			val computableGroups: MutableList<ComputableGroup> = mutableListOf()
+
+			criterias.combined().forEach { comparatorConditions ->
+
+				val allConditions = mutableListOf<QueryCondition>()
+				allConditions.addAll(conditions)
+				allConditions.addAll(comparatorConditions)
+
+				val group = ComputableGroup(allConditions.name(), allConditions)
+				computableGroups.add(group)
+
+			}
+
+			if (computableGroups.size == 0) {
+				val group = ComputableGroup(conditions.name(), conditions)
+				computableGroups.add(group)
+			}
+
+			return this.computeGroups(realm, computableGroups, options)
+		}
+
 		fun computeStatsWithComparators(
             realm: Realm,
-            criteria: List<Criteria> = listOf(),
+            compConditions: List<List<QueryCondition>> = listOf(),
             conditions: List<QueryCondition> = listOf(),
             options: Options = Options()
 		): Report {
 
 			val computableGroups: MutableList<ComputableGroup> = mutableListOf()
 
-			criteria.combined().upToNow().forEach { comparatorConditions ->
+			compConditions.forEach { comparatorConditions ->
 
 				val allConditions = mutableListOf<QueryCondition>()
 				allConditions.addAll(conditions)

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

@@ -48,7 +48,9 @@ class Report(var options: Calculator.Options) {
 
 		statToUse?.let {
 			this._results.forEachIndexed { index, results ->
-				results.computedStat(it)?.progressValue?.let { progressValue ->
+				val stat = results.computedStat(it)
+				val progressValue = stat?.progressValue
+				progressValue?.let { progressValue ->
 					entries.add(Entry(index.toFloat(), progressValue.toFloat(), results))
 				}
 			}
@@ -243,14 +245,15 @@ class ComputedResults(group: ComputableGroup, shouldManageMultiGroupProgressValu
 
 		if (this.shouldManageMultiGroupProgressValues) {
 
-			this.group.comparedComputedResults?.let { previousResult ->
+			fun computeProgressValues(computedResults: ComputedResults) {
+
 				this.allStats().forEach { computedStat ->
 					val stat = computedStat.stat
-					previousResult.computedStat(stat)?.let { previousComputedStat ->
+					computedResults.computedStat(stat)?.let { previousComputedStat ->
 						when (stat) {
 							Stat.NET_RESULT, Stat.HOURLY_DURATION, Stat.BB_NET_RESULT, Stat.BB_SESSION_COUNT,
 							Stat.WINNING_SESSION_COUNT, Stat.TOTAL_BUYIN, Stat.HANDS_PLAYED, Stat.NUMBER_OF_GAMES, Stat.NUMBER_OF_SETS -> {
-								val previousValue = previousComputedStat.progressValue ?: previousComputedStat.value
+								val previousValue = previousComputedStat.progressValue ?: 0.0
 								computedStat.progressValue = previousValue + computedStat.value
 							}
 							else -> {}
@@ -259,6 +262,13 @@ class ComputedResults(group: ComputableGroup, shouldManageMultiGroupProgressValu
 						computedStat.progressValue = computedStat.value
 					}
 				}
+
+			}
+
+			this.group.comparedComputedResults?.let { previousResult ->
+				computeProgressValues(previousResult)
+			} ?: run {
+				computeProgressValues(this)
 			}
 
 			val netResult = this.computedStat(Stat.NET_RESULT)?.progressValue

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

@@ -4,6 +4,7 @@ import android.content.Context
 import net.pokeranalytics.android.R
 import net.pokeranalytics.android.exceptions.FormattingException
 import net.pokeranalytics.android.model.Criteria
+import net.pokeranalytics.android.model.filter.QueryCondition
 import net.pokeranalytics.android.model.interfaces.Timed
 import net.pokeranalytics.android.ui.graph.AxisFormatting
 import net.pokeranalytics.android.ui.view.RowRepresentable
@@ -47,11 +48,18 @@ enum class AggregationType {
 			}
 		}
 
-	val criterias: List<Criteria>
+	val queryLists: List<List<QueryCondition>>
 		get() {
 			return when (this) {
-				MONTH -> listOf(Criteria.Years, Criteria.MonthsOfYear)
+				MONTH -> Criteria.AllMonthsUpToNow.predicates
-				YEAR -> listOf(Criteria.Years)
+				YEAR -> {
+					val conditions = Criteria.Years.queryConditions
+					val list = mutableListOf<List<QueryCondition>>()
+					conditions.forEach {
+						list.add(listOf(it))
+					}
+					return list
+				}
 				else -> listOf()
 			}
 		}

app/src/main/java/net/pokeranalytics/android/model/Criteria.kt

@@ -4,6 +4,16 @@ import io.realm.Realm
 import io.realm.Sort
 import io.realm.kotlin.where
 import net.pokeranalytics.android.exceptions.PokerAnalyticsException
+import net.pokeranalytics.android.model.Criteria.Bankrolls.comparison
+import net.pokeranalytics.android.model.Criteria.Blinds.comparison
+import net.pokeranalytics.android.model.Criteria.Games.comparison
+import net.pokeranalytics.android.model.Criteria.Limits.comparison
+import net.pokeranalytics.android.model.Criteria.Locations.comparison
+import net.pokeranalytics.android.model.Criteria.TableSizes.comparison
+import net.pokeranalytics.android.model.Criteria.TournamentFeatures.comparison
+import net.pokeranalytics.android.model.Criteria.TournamentFees.comparison
+import net.pokeranalytics.android.model.Criteria.TournamentNames.comparison
+import net.pokeranalytics.android.model.Criteria.TournamentTypes.comparison
 import net.pokeranalytics.android.model.filter.QueryCondition
 import net.pokeranalytics.android.model.interfaces.NameManageable
 import net.pokeranalytics.android.model.realm.*
@@ -188,7 +198,14 @@ sealed class Criteria {
                     }
                     years
                 }
-                else -> listOf(listOf())
+                else -> {
+                    val conditions = this.queryConditions
+                    val list = mutableListOf<List<QueryCondition>>()
+                    conditions.forEach {
+                        list.add(listOf(it))
+                    }
+                    return list
+                }
             }
         }
 

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

@@ -122,7 +122,7 @@ class ReportsFragment : PokerAnalyticsFragment(), StaticRowRepresentableDataSour
 			val requiredStats: List<Stat> = listOf(Stat.NET_RESULT)
 			val options = Calculator.Options(evolutionValues = Calculator.Options.EvolutionValues.STANDARD, stats = requiredStats)
 
-			val report = Calculator.computeStatsWithComparators(realm, criteria = criteria, options = options)
+			val report = Calculator.computeStatsWithCriterias(realm, criterias = criteria, options = options)
 
 			Timber.d("launchComputation: ${System.currentTimeMillis() - startDate.time}ms")
 

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

@@ -17,7 +17,6 @@ import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
 import net.pokeranalytics.android.R
 import net.pokeranalytics.android.calculus.*
-import net.pokeranalytics.android.model.combined
 import net.pokeranalytics.android.ui.activity.components.PokerAnalyticsActivity
 import net.pokeranalytics.android.ui.extensions.ChipGroupExtension
 import net.pokeranalytics.android.ui.extensions.hideWithAnimation
@@ -127,7 +126,7 @@ class StatisticDetailsFragment : PokerAnalyticsFragment() {
 
 				when (aggregationType) {
 					AggregationType.MONTH, AggregationType.YEAR -> {
-						val queryConditions = aggregationType.criterias.combined()
+						val queryConditions = aggregationType.queryLists
 						if (queryConditions.size < 2) {
 							Toast.makeText(context, R.string.less_then_2_values_for_display, Toast.LENGTH_LONG).show()
 							return

app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/ReportRow.kt

@@ -14,7 +14,7 @@ enum class ReportRow : RowRepresentable {
 	DAY_OF_WEEKS,
 	GENERAL,
 	LOCATIONS,
-	NUMBER_OF_TABLES,
+//	NUMBER_OF_TABLES,
 	TOURNAMENT_TYPES,
 	GAME;
 
@@ -39,7 +39,7 @@ enum class ReportRow : RowRepresentable {
 				DAY_OF_WEEKS -> R.string.day_of_the_week
 				GENERAL -> R.string.general
 				LOCATIONS -> R.string.locations
-				NUMBER_OF_TABLES -> R.string.number_of_tables
+//				NUMBER_OF_TABLES -> R.string.number_of_tables
 				TOURNAMENT_TYPES -> R.string.tournament_type_complete
 				GAME -> R.string.game
 			}
@@ -55,7 +55,7 @@ enum class ReportRow : RowRepresentable {
 				DAY_OF_WEEKS -> listOf(Criteria.DaysOfWeek)
 				GENERAL -> listOf(Criteria.SessionTypes, Criteria.BankrollTypes)
 				LOCATIONS -> listOf(Criteria.Locations)
-				NUMBER_OF_TABLES -> listOf() //TODO
+//				NUMBER_OF_TABLES -> listOf() //TODO
 				TOURNAMENT_TYPES -> listOf(Criteria.TournamentTypes)
 				GAME -> listOf(Criteria.Games)
 			}