update criteria

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

@@ -1,15 +1,13 @@
 package net.pokeranalytics.android.model
 
 import io.realm.Realm
-import io.realm.RealmResults
 import io.realm.Sort
-import io.realm.internal.Table
 import io.realm.kotlin.where
 import net.pokeranalytics.android.exceptions.PokerAnalyticsException
-import net.pokeranalytics.android.model.filter.FilterHelper
 import net.pokeranalytics.android.model.filter.QueryCondition
 import net.pokeranalytics.android.model.interfaces.Identifiable
 import net.pokeranalytics.android.model.realm.*
+import java.util.*
 
 sealed class Criteria {
     abstract class RealmCriteria : Criteria() {
@@ -18,9 +16,9 @@ sealed class Criteria {
         }
     }
 
-    abstract class SimpleCriteria(private val condition:QueryCondition): Criteria() {
+    abstract class SimpleCriteria(private val conditions:List<QueryCondition>): Criteria() {
         fun comparison(): List<QueryCondition> {
-            return listOf(condition)
+            return conditions
         }
     }
 
@@ -32,6 +30,7 @@ sealed class Criteria {
                         is Limits -> session.limit
                         is TournamentTypes -> session.tournamentType
                         is TableSizes -> session.tableSize
+                        //is TournamentFees -> session.tournamentEntryFee
                         else -> null
                     }
                 }
@@ -49,8 +48,14 @@ sealed class Criteria {
     object Limits: StaticCriteria()
     object TableSizes: StaticCriteria()
     object TournamentTypes: StaticCriteria()
-
+    object monthOfYear:  SimpleCriteria(List(12) { index -> QueryCondition.MONTH().apply { intValue = index } })
-    object Tournament : SimpleCriteria(QueryCondition.TOURNAMENT)
+    object dayOfWeek: SimpleCriteria(List(7) { index -> QueryCondition.DAY_OF_WEEK().apply { intValue = index } })
+    object SessionType: SimpleCriteria(listOf(QueryCondition.CASH, QueryCondition.TOURNAMENT))
+    object BankrollType: SimpleCriteria(listOf(QueryCondition.LIVE, QueryCondition.ONLINE))
+    object dayPeriod: SimpleCriteria(listOf(QueryCondition.WEEK_DAY, QueryCondition.WEEK_END))
+    object Year: Criteria()
+    object Blinds: Criteria()
+    //object TournamentFees: StaticCriteria()
 
     val queryConditions: List<QueryCondition>
         get() {
@@ -64,6 +69,36 @@ sealed class Criteria {
                 is Limits -> comparison<QueryCondition.LIMIT>()
                 is TournamentTypes -> comparison<QueryCondition.TOURNAMENT_TYPE>()
                 is TableSizes -> comparison<QueryCondition.TABLE_SIZE>()
+                is Year -> {
+                    val years = arrayListOf<QueryCondition.YEAR>()
+                    val calendar = Calendar.getInstance()
+                    calendar.time = Date()
+                    val yearNow = calendar.get(Calendar.YEAR)
+                    val realm = Realm.getDefaultInstance()
+                    realm.where<Session>().sort("year", Sort.ASCENDING).findFirst()?.year?.let {
+                        for (index in 0..(yearNow - it)) {
+                            years.add(QueryCondition.YEAR().apply {
+                                intValue = yearNow - index
+                            })
+                        }
+                    }
+                    realm.close()
+                    years
+                }
+                is Blinds -> {
+                    val blinds = arrayListOf<QueryCondition.BLIND>()
+                    val realm = Realm.getDefaultInstance()
+                    realm.where<Session>().distinct("blinds", "bankroll.currency.code").findAll().sort("cgSmallBlind", Sort.ASCENDING).map {
+                        it.blinds?.let { stake ->
+                            blinds.add(QueryCondition.BLIND().apply {
+                                blind = stake
+                                hasDefaultCurrency = it.hasDefaultCurrency
+                            })
+                        }
+                    }
+                    realm.close()
+                    blinds
+                }
                 else -> throw PokerAnalyticsException.QueryTypeUnhandled
             }
         }
@@ -92,4 +127,46 @@ sealed class Criteria {
         }
     }
 
+    fun List<Criteria>.combined(): List<List<QueryCondition>> {
+        val comparatorList = ArrayList<List<QueryCondition>>()
+        this.forEach {
+            comparatorList.add(it.queryConditions)
+        }
+        return getCombinations(comparatorList)
+    }
+
+    private fun <T> getCombinations(lists: List<List<T>>): List<List<T>> {
+        var combinations: MutableSet<List<T>> = LinkedHashSet()
+        var newCombinations: MutableSet<List<T>>
+
+        var index = 0
+
+        // extract each of the integers in the first list
+        // and add each to ints as a new list
+        if (lists.isNotEmpty()) {
+            for (i in lists[0]) {
+                val newList = ArrayList<T>()
+                newList.add(i)
+                combinations.add(newList)
+            }
+            index++
+        }
+        while (index < lists.size) {
+            val nextList = lists[index]
+            newCombinations = LinkedHashSet()
+            for (first in combinations) {
+                for (second in nextList) {
+                    val newList = ArrayList<T>()
+                    newList.addAll(first)
+                    newList.add(second)
+                    newCombinations.add(newList)
+                }
+            }
+            combinations = newCombinations
+
+            index++
+        }
+
+        return combinations.toList()
+    }
 }