Bugfix and improve Comparator

app/src/main/java/net/pokeranalytics/android/model/comparison/Comparator.kt

@@ -8,99 +8,89 @@ import net.pokeranalytics.android.exceptions.PokerAnalyticsException
 import net.pokeranalytics.android.model.filter.Filterable
 import net.pokeranalytics.android.model.filter.QueryCondition
 import net.pokeranalytics.android.model.realm.Session
-import net.pokeranalytics.android.ui.fragment.CalendarFragment
 import java.util.*
 import kotlin.collections.ArrayList
-import kotlin.collections.HashSet
 
 enum class Comparator {
-    DAY_OF_WEEK,
+	DAY_OF_WEEK,
-    MONTH_OF_YEAR,
+	MONTH_OF_YEAR,
-    MONTH,
+	MONTH,
-    YEAR,
+	YEAR,
-    BLIND,
+	BLIND,
-    ;
+	;
 
-    val queryConditions: List<QueryCondition>
+	val queryConditions: List<QueryCondition>
-        get() {
+		get() {
-            return when (this) {
+			return when (this) {
-                MONTH_OF_YEAR -> List(12) { index-> QueryCondition.MONTH().apply { setMonth(index+1) } }
+				MONTH_OF_YEAR -> List(12) { index -> QueryCondition.MONTH().apply { setMonth(index) } }
-                DAY_OF_WEEK -> listOf()
+				DAY_OF_WEEK -> listOf()
-                YEAR -> {
+				YEAR -> {
-                    val years = arrayListOf<QueryCondition.YEAR>()
+					val years = arrayListOf<QueryCondition.YEAR>()
-                    val calendar = Calendar.getInstance()
+					val calendar = Calendar.getInstance()
-                    calendar.time = Date()
+					calendar.time = Date()
-                    val yearNow = calendar.get(Calendar.YEAR)
+					val yearNow = calendar.get(Calendar.YEAR)
-                    val realm = Realm.getDefaultInstance()
+					val realm = Realm.getDefaultInstance()
-                    realm.where<Session>().sort("year", Sort.ASCENDING).findFirst()?.year?.let {
+					realm.where<Session>().sort("year", Sort.ASCENDING).findFirst()?.year?.let {
-                        List(yearNow - it ) { index-> QueryCondition.YEAR().apply { setYear(yearNow - index) } }
+						for (index in 0..(yearNow - it)) {
-                    }
+							years.add(QueryCondition.YEAR().apply { setYear(yearNow - index) })
-                    realm.close()
+						}
-                    years
+					}
-                    /*
+					realm.close()
-                    val years = arrayListOf<QueryCondition.YEAR>()
+					years
-                    val realm = Realm.getDefaultInstance()
+				}
-                    val distinctYears = realm.where<Session>().distinct("year").findAll().sort("year", Sort.DESCENDING)
+				else -> throw PokerAnalyticsException.QueryTypeUnhandled
-                    distinctYears.forEach { session ->
+			}
-                        session.year?.let { year ->
+		}
-                            years.add(QueryCondition.YEAR().apply { setYear(year) })
-                        }
-                    }
-                    realm.close()
-                    years
-                    */
-                }
-                else -> throw PokerAnalyticsException.QueryTypeUnhandled
-            }
-        }
 
 }
 
 fun List<Comparator>.combined(): List<List<QueryCondition>> {
-    val comparatorList = ArrayList<List<QueryCondition>>()
+	val comparatorList = ArrayList<List<QueryCondition>>()
-    this.forEach {
+	this.forEach {
-        comparatorList.add(it.queryConditions)
+		comparatorList.add(it.queryConditions)
-    }
+	}
 	return getCombinations(comparatorList)
 }
 
 inline fun <reified T : Filterable> List<QueryCondition>.query(realm: Realm): RealmQuery<T> {
-    var realmQuery = realm.where<T>()
+	var realmQuery = realm.where<T>()
-    this.forEach {
+	this.forEach {
-        realmQuery = it.filter(realmQuery)
+		realmQuery = it.filter(realmQuery)
-    }
+	}
-    return realmQuery
+	return realmQuery
 }
 
 fun <T> getCombinations(lists: List<List<T>>): List<List<T>> {
-    var combinations: MutableSet<List<T>> = LinkedHashSet()
+	var combinations: MutableSet<List<T>> = LinkedHashSet()
-    var newCombinations: MutableSet<List<T>>
+	var newCombinations: MutableSet<List<T>>
 
-    var index = 0
+	var index = 0
 
-    // extract each of the integers in the first list
+	// extract each of the integers in the first list
-    // and add each to ints as a new list
+	// and add each to ints as a new list
-    for (i in lists[0]) {
+	if (lists.isNotEmpty()) {
-        val newList = ArrayList<T>()
+		for (i in lists[0]) {
-        newList.add(i)
+			val newList = ArrayList<T>()
-        combinations.add(newList)
+			newList.add(i)
-    }
+			combinations.add(newList)
-	index++
+		}
-    while (index < lists.size) {
+		index++
-        val nextList = lists[index]
+	}
-        newCombinations = LinkedHashSet()
+	while (index < lists.size) {
-        for (first in combinations) {
+		val nextList = lists[index]
-            for (second in nextList) {
+		newCombinations = LinkedHashSet()
-                val newList = ArrayList<T>()
+		for (first in combinations) {
-                newList.addAll(first)
+			for (second in nextList) {
-                newList.add(second)
+				val newList = ArrayList<T>()
-                newCombinations.add(newList)
+				newList.addAll(first)
-            }
+				newList.add(second)
-        }
+				newCombinations.add(newList)
-        combinations = newCombinations
+			}
+		}
+		combinations = newCombinations
 
-        index++
+		index++
-    }
+	}
 
-    return combinations.toList()
+	return combinations.toList()
 }