Sorting first draft

app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/BlindFilterInstrumentedTest.kt

@@ -46,7 +46,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
 
 //        blind.filterSectionRow = FilterSectionRow.Blind
 
-        val filterElement = FilterCondition(arrayListOf(blind), FilterSectionRow.Blind)
+        val filterElement = FilterCondition(arrayListOf(blind), FilterSectionRow.Stakes)
         filter.updateValueBy(filterElement)
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
@@ -91,7 +91,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
             listOfValues = arrayListOf(s2.blinds!!)
         }
 
-        val filterElements = FilterCondition(arrayListOf(blind1, blind2), FilterSectionRow.Blind)
+        val filterElements = FilterCondition(arrayListOf(blind1, blind2), FilterSectionRow.Stakes)
         filter.updateValueBy(filterElements)
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
@@ -133,7 +133,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
             listOfValues = arrayListOf(s3.blinds!!)
         }
 
-        val filterElement = FilterCondition(arrayListOf(blind), FilterSectionRow.Blind)
+        val filterElement = FilterCondition(arrayListOf(blind), FilterSectionRow.Stakes)
         filter.updateValueBy(filterElement)
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
 
@@ -177,7 +177,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
             listOfValues = arrayListOf(s2.cgStakes!!)
         }
 
-        val filterElement = FilterCondition(arrayListOf(stake1, stake2), FilterSectionRow.Blind)
+        val filterElement = FilterCondition(arrayListOf(stake1, stake2), FilterSectionRow.Stakes)
         filter.updateValueBy(filterElement)
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))

app/src/main/java/net/pokeranalytics/android/calculus/optimalduration/CashGameOptimalDurationCalculator.kt

@@ -41,7 +41,7 @@ class CashGameOptimalDurationCalculator {
 			val query = Query().add(QueryCondition.IsCash) // cash game
 			query.add(if (isLive) { QueryCondition.IsLive } else { QueryCondition.IsOnline }) // live / online
 			query.add(QueryCondition.EndDateNotNull) // ended
-			query.add(QueryCondition.BigBlindNotNull) // has BB value
+			query.add(QueryCondition.BiggestBetNotNull) // has BB value
 
 			val sessions = query.queryWith(realm.where(Session::class.java)).findAll()
 			val sessionsByDuration = sessions.groupBy {

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

@@ -7,10 +7,10 @@ import net.pokeranalytics.android.R
 import net.pokeranalytics.android.exceptions.PAIllegalStateException
 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.Stakes.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
@@ -123,7 +123,7 @@ sealed class Criteria(override var uniqueIdentifier: Int) : IntIdentifiable, Row
 						is TournamentFees -> if (session.tournamentEntryFee is S) {
 							session.tournamentEntryFee as S
 						} else throw PokerAnalyticsException.QueryValueMapUnexpectedValue
-						is Blinds -> if (session.cgStakes is S) {
+						is Stakes -> if (session.cgStakes is S) {
 							session.cgStakes as S
 						} else throw PokerAnalyticsException.QueryValueMapUnexpectedValue
 						else -> null
@@ -158,7 +158,7 @@ sealed class Criteria(override var uniqueIdentifier: Int) : IntIdentifiable, Row
 	object DayPeriods : SimpleCriteria(listOf(QueryCondition.IsWeekDay, QueryCondition.IsWeekEnd), 14)
 	object Years : ListCriteria(15)
 	object AllMonthsUpToNow : ListCriteria(16)
-	object Blinds : ListCriteria(17)
+	object Stakes : ListCriteria(17)
 	object TournamentFees : ListCriteria(18)
 	object Cash : SimpleCriteria(listOf(QueryCondition.IsCash), 19)
 	object Tournament : SimpleCriteria(listOf(QueryCondition.IsTournament), 20)
@@ -236,7 +236,7 @@ sealed class Criteria(override var uniqueIdentifier: Int) : IntIdentifiable, Row
 					realm.close()
 					years
 				}
-				is Blinds -> comparison<QueryCondition.AnyStake, String>()
+				is Stakes -> comparison<QueryCondition.AnyStake, String>()
                 is ListCustomFields -> comparison<CustomFieldEntry>()
                 is ValueCustomFields -> {
 	                val realm = Realm.getDefaultInstance()
@@ -270,7 +270,7 @@ sealed class Criteria(override var uniqueIdentifier: Int) : IntIdentifiable, Row
 				DayPeriods -> R.string.weekdays_or_weekend
 				Years -> R.string.year
 				AllMonthsUpToNow -> R.string.month
-				Blinds -> R.string.blind
+				Stakes -> R.string.blind
 				TournamentFees -> R.string.entry_fees
 //                is ListCustomFields -> this.customField.resId
 //                is ValueCustomFields -> this.customField.resId
@@ -318,7 +318,8 @@ sealed class Criteria(override var uniqueIdentifier: Int) : IntIdentifiable, Row
 					TournamentFeatures, Limits, TableSizes, TournamentTypes,
 					MonthsOfYear, DaysOfWeek, SessionTypes,
 					BankrollTypes, DayPeriods, Years,
-					AllMonthsUpToNow, Blinds, TournamentFees
+					AllMonthsUpToNow,
+					Stakes, TournamentFees
 				)
 			}
 	}

app/src/main/java/net/pokeranalytics/android/model/extensions/SessionExtensions.kt

@@ -75,7 +75,7 @@ fun Session.getFormattedGameType(context: Context): String {
 			parameters.add(context.getString(R.string.tournament).capitalize())
 		}
 	} else {
-		if (this.cgAnte != null && this.cgBlinds != null) {
+		if (this.cgAnte != null || this.cgBlinds != null) {
 			parameters.add(getFormattedStakes())
 		}
 		game?.let {

app/src/main/java/net/pokeranalytics/android/model/filter/QueryCondition.kt

@@ -12,6 +12,7 @@ import net.pokeranalytics.android.exceptions.PokerAnalyticsException
 import net.pokeranalytics.android.model.Limit
 import net.pokeranalytics.android.model.TableSize
 import net.pokeranalytics.android.model.TournamentType
+import net.pokeranalytics.android.model.interfaces.CodedStake
 import net.pokeranalytics.android.model.interfaces.Identifiable
 import net.pokeranalytics.android.model.interfaces.NameManageable
 import net.pokeranalytics.android.model.interfaces.StakesHolder
@@ -468,6 +469,11 @@ sealed class QueryCondition : RowRepresentable {
         override fun entityName(context: Context): String {
             return context.getString(R.string.stakes)
         }
+
+		override fun compareTo(other: ListOfValues<String>): Int {
+			return CodedStake(this.listOfValues.first()).compareTo(CodedStake(other.listOfValues.first()))
+		}
+
     }
 
 	class NumberOfTable : ListOfInt() {
@@ -621,7 +627,7 @@ sealed class QueryCondition : RowRepresentable {
 
 	object DateNotNull : NotNullQueryCondition()
 	object EndDateNotNull : NotNullQueryCondition()
-	object BigBlindNotNull : NotNullQueryCondition()
+	object BiggestBetNotNull : NotNullQueryCondition()
 
 	class StartedFromTime(date: Date) : TimeQuery(date) {
 		override var operator = Operator.MORE

app/src/main/java/net/pokeranalytics/android/model/interfaces/StakesHolder.kt

@@ -6,67 +6,129 @@ import net.pokeranalytics.android.util.NULL_TEXT
 import net.pokeranalytics.android.util.UserDefaults
 import net.pokeranalytics.android.util.extensions.formatted
 import net.pokeranalytics.android.util.extensions.toCurrency
+import java.lang.Integer.min
 import java.text.NumberFormat
 import java.text.ParseException
 import java.util.*
 
-interface StakesHolder {
+data class CodedStake(var stakes: String) : Comparable<CodedStake> {
 
-    companion object {
+    var ante: Double? = null
+    var blinds: String? = null
+    var currency: Currency
 
-        private const val cbSeparator = ";"
+    init {
-        private const val cbAnte = "A="
-        private const val cbBlinds = "B="
-        private const val cbCode = "C="
 
-        fun readableStakes(value: String): String {
+        var currencyCode: String? = null
 
-            var ante: Double? = null; var blinds: String? = null; var currencyCode: String? = null
+        val parameters = this.stakes.split(StakesHolder.cbSeparator)
-
+        parameters.forEach { param ->
-            val parameters = value.split(cbSeparator)
+            when {
-            parameters.forEach { param ->
+                param.contains(StakesHolder.cbAnte) -> ante = param.removePrefix(StakesHolder.cbAnte).let { NumberFormat.getInstance().parse(it)?.toDouble() }
-                when {
+                param.contains(StakesHolder.cbBlinds) -> blinds = param.removePrefix(StakesHolder.cbBlinds)
-                    param.contains(cbAnte) -> ante = param.removePrefix(cbAnte).let { NumberFormat.getInstance().parse(it)?.toDouble() }
+                param.contains(StakesHolder.cbCode) -> currencyCode = param.removePrefix(
-                    param.contains(cbBlinds) -> blinds = param.removePrefix(cbBlinds)
+                    StakesHolder.cbCode
-                    param.contains(cbCode) -> currencyCode = param.removePrefix(cbCode)
+                )
-                }
             }
+        }
+
+        this.currency = currencyCode?.let { Currency.getInstance(it) }
+            ?: run { UserDefaults.currency }
 
-            val currency = currencyCode?.let { Currency.getInstance(it) }
+    }
-                ?: run { UserDefaults.currency }
 
-            val formattedBlinds = formattedBlinds(blinds, currency)
+    override fun compareTo(other: CodedStake): Int {
-            val formattedAnte = formattedAnte(ante, currency)
+
-            return formattedStakes(formattedBlinds, formattedAnte)
+        if (this.currency == other.currency) {
+
+            this.blinds?.let { b1 ->
+                other.blinds?.let { b2 ->
+                    if (b1 == b2) {
+                        return this.compareAnte(other)
+                    } else {
+                        val bv1 = this.reversedBlindsArray(b1)
+                        val bv2 = this.reversedBlindsArray(b2)
+
+                        for (i in 0 until min(bv1.size, bv2.size)) {
+                            if (bv1[i] != bv2[i]) {
+                                return bv1[i].compareTo(bv2[i])
+                            } else {
+                                continue
+                            }
+                        }
+                        return bv1.size.compareTo(bv2.size)
+                    }
+                } ?: run {
+                    return 1
+                }
 
+            } ?: run {
+                return this.compareAnte(other)
+            }
+        } else {
+            return this.currency.currencyCode.compareTo(other.currency.currencyCode)
         }
 
-        private fun formattedStakes(formattedBlinds: String?, formattedAnte: String?): String {
+    }
-            val components = arrayListOf<String>()
-            formattedBlinds?.let { components.add(it) }
-            formattedAnte?.let { components.add("($it)") }
 
-            return if (components.isNotEmpty()) {
+    private fun compareAnte(other: CodedStake): Int {
-                components.joinToString(" ")
+        this.ante?.let { a1 ->
-            } else {
+            other.ante?.let { a2 ->
-                NULL_TEXT
+                return a1.compareTo(a2)
+            } ?: run {
+                return 1
             }
+        } ?: run {
+            return -1
         }
+    }
 
-        private fun formattedBlinds(blinds: String?, currency: Currency): String? {
+    private fun reversedBlindsArray(blinds: String): List<Double> {
-            blinds?.let {
+        return blinds.split(BLIND_SEPARATOR).mapNotNull { NumberFormat.getInstance().parse(it)?.toDouble() }.reversed()
-                val placeholder = 1.0
+    }
-                val regex = Regex("-?\\d+(\\.\\d+)?")
+
-                return placeholder.toCurrency(currency).replace(regex, blinds)
+    fun formattedStakes(): String {
-            }
+        val components = arrayListOf<String>()
-            return null
+        this.formattedBlinds()?.let { components.add(it) }
+        this.formattedAnte()?.let { components.add("($it)") }
+
+        return if (components.isNotEmpty()) {
+            components.joinToString(" ")
+        } else {
+            NULL_TEXT
         }
+    }
 
-        private fun formattedAnte(antes: Double?, currency: Currency): String? {
+    private fun formattedBlinds(): String? {
-            antes?.let {
+        this.blinds?.let {
-                return it.toCurrency(currency)
+            val placeholder = 1.0
-            }
+            val regex = Regex("-?\\d+(\\.\\d+)?")
-            return null
+            return placeholder.toCurrency(currency).replace(regex, it)
+        }
+        return null
+    }
+
+    private fun formattedAnte(): String? {
+        this.ante?.let {
+            return it.toCurrency(this.currency)
+        }
+        return null
+    }
+
+}
+
+
+interface StakesHolder {
+
+    companion object {
+
+        const val cbSeparator = ";"
+        const val cbAnte = "A="
+        const val cbBlinds = "B="
+        const val cbCode = "C="
+
+        fun readableStakes(value: String): String {
+            return CodedStake(value).formattedStakes()
         }
 
     }
@@ -98,7 +160,7 @@ interface StakesHolder {
 
     fun generateStakes() {
 
-        if (this.ante == null && this.ante == null) {
+        if (this.ante == null && this.blinds == null) {
             setHolderStakes(null)
             return
         }

app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt

@@ -122,7 +122,7 @@ open class Session : RealmObject(), Savable, RowUpdatable, RowRepresentable, Tim
                 CustomFieldQuery::class.java -> "customFieldEntries.customFields.id"
 	            DateNotNull::class.java -> "startDate"
 	            EndDateNotNull::class.java -> "endDate"
-	            BigBlindNotNull::class.java -> "cgBigBlind"
+	            BiggestBetNotNull::class.java -> "cgBiggestBet"
                 else -> null
 			}
 		}
@@ -339,8 +339,6 @@ open class Session : RealmObject(), Savable, RowUpdatable, RowRepresentable, Tim
 
 	var cgStakes: String? = null
 
-
-
 	// Tournament
 
 	// The entry fee of the tournament
@@ -667,9 +665,13 @@ open class Session : RealmObject(), Savable, RowUpdatable, RowRepresentable, Tim
 
 	fun getFormattedStakes(): String {
 
-		this.cgStakes?.let { return StakesHolder.readableStakes(it) }
+		return this.cgStakes?.let { StakesHolder.readableStakes(it) } ?: run { NULL_TEXT }
 
-		return NULL_TEXT
+//
+//		val formattedBlinds = StakesHolder.formattedBlinds(this.cgBlinds, this.currency)
+//		val formattedAntes = StakesHolder.formattedAnte(this.cgAnte, this.currency)
+//
+//		return StakesHolder.formattedStakes(formattedBlinds, formattedAntes)
 
 //
 //
@@ -1105,9 +1107,6 @@ open class Session : RealmObject(), Savable, RowUpdatable, RowRepresentable, Tim
 	override val stakes: String?
 		get() { return this.cgStakes }
 
-//	override val bankroll: Bankroll?
-//		get() { return this.bankroll }
-
 	override fun setHolderStakes(stakes: String?) {
 		this.cgStakes = stakes
 	}
@@ -1116,21 +1115,4 @@ open class Session : RealmObject(), Savable, RowUpdatable, RowRepresentable, Tim
 		this.cgBiggestBet = biggestBet
 	}
 
-//
-//	private val blindValues: List<Double>
-//		get() {
-//			this.cgBlinds?.let { blinds ->
-//				val blindsSplit = blinds.split(BLIND_SEPARATOR)
-//				return blindsSplit.mapNotNull {
-//					try {
-//						NumberFormat.getInstance().parse(it)?.toDouble()
-//					} catch (e: ParseException) {
-//						null
-//					}
-//				}
-//			}
-//			return listOf()
-//		}
-
-
 }

app/src/main/java/net/pokeranalytics/android/ui/view/rows/FilterCategoryRow.kt

@@ -101,7 +101,7 @@ enum class FilterCategoryRow(override val resId: Int?, override val viewType: In
 					Bankroll
 				)
 				CASH -> arrayListOf(
-					Blind
+					Stakes
 				)
 				TOURNAMENT -> arrayListOf(
 					TournamentType,

app/src/main/java/net/pokeranalytics/android/ui/view/rows/FilterSectionRow.kt

@@ -26,7 +26,7 @@ sealed class FilterSectionRow(override val resId: Int?) : RowRepresentable {
     object SessionDuration: FilterSectionRow(R.string.session_duration)
     object TimeFrameRange: FilterSectionRow(R.string.hour_slot)
     object Sessions: FilterSectionRow(R.string.sessions)
-    object Blind: FilterSectionRow(R.string.blinds)
+    object Stakes: FilterSectionRow(R.string.stakes)
     object CashRebuyCount: FilterSectionRow(R.string.rebuy_count)
     object TournamentType: FilterSectionRow(R.string.tournament_types)
     object TournamentName: FilterSectionRow(R.string.tournament_name)
@@ -134,7 +134,7 @@ sealed class FilterSectionRow(override val resId: Int?) : RowRepresentable {
 				//Sessions -> arrayListOf(QueryCondition.LastGame(), QueryCondition.LastSession())
 
 				// Cash
-				Blind -> Criteria.Blinds.queryConditions.mapFirstCondition()
+				Stakes -> Criteria.Stakes.queryConditions.mapFirstCondition()
 //						CashRebuyCount -> QueryCondition.moreOrLess<QueryCondition.Rebuy>()
 
 				// Tournament

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

@@ -49,7 +49,7 @@ enum class ReportRow : RowRepresentable {
 	val criteria: List<Criteria>
 		get() {
 			return when (this) {
-				BLINDS -> listOf(Criteria.Blinds)
+				BLINDS -> listOf(Criteria.Stakes)
 				BUY_IN -> listOf(Criteria.TournamentFees)
 				DAY_OF_WEEKS -> listOf(Criteria.DaysOfWeek)
 				GENERAL -> listOf(Criteria.SessionTypes, Criteria.BankrollTypes)