Fixes hand evaluator issues

app/src/main/java/net/pokeranalytics/android/model/migrations/PokerAnalyticsMigration.kt

@@ -192,6 +192,7 @@ class PokerAnalyticsMigration : RealmMigration {
                 hhSchema.addField("month", Integer::class.java)
                 hhSchema.addField("year", Integer::class.java)
                 hhSchema.addField("dayOfMonth", Integer::class.java)
+                hhSchema.addRealmListField("winningPositions", Integer::class.java)
 
                 val cardSchema = schema.create("Card")
                 cardSchema.addField("value", Int::class.java)

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

@@ -124,7 +124,7 @@ open class Card : RealmObject() {
 
 		override val viewType: Int = RowViewType.TITLE_GRID.ordinal
 
-		val evualuatorSuit: Int?
+		val evaluatorSuit: Int?
 			get() {
 				return when (this) {
 					SPADES -> net.pokeranalytics.android.ui.modules.handhistory.evaluator.Card.SPADES
@@ -134,8 +134,6 @@ open class Card : RealmObject() {
 					else -> null
 				}
 			}
-
-
 	}
 
 	/***
@@ -223,9 +221,9 @@ open class Card : RealmObject() {
 
 	fun toEvaluatorCard():net.pokeranalytics.android.ui.modules.handhistory.evaluator.Card? {
 		val rank = this.value
-		val suit = this.suit?.evualuatorSuit
+		val suit = this.suit?.evaluatorSuit
 		return if (rank != null && suit != null) {
-			net.pokeranalytics.android.ui.modules.handhistory.evaluator.Card(rank, suit)
+			net.pokeranalytics.android.ui.modules.handhistory.evaluator.Card(rank - 2, suit)
 		} else {
 			null
 		}

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

@@ -20,6 +20,7 @@ import net.pokeranalytics.android.model.interfaces.DeleteValidityStatus
 import net.pokeranalytics.android.model.interfaces.Identifiable
 import net.pokeranalytics.android.model.interfaces.TimeFilterable
 import net.pokeranalytics.android.model.realm.Session
+import net.pokeranalytics.android.ui.modules.handhistory.evaluator.EvaluatorBridge
 import net.pokeranalytics.android.ui.modules.handhistory.model.ActionReadRow
 import net.pokeranalytics.android.ui.modules.handhistory.model.CardHolder
 import net.pokeranalytics.android.ui.view.RowRepresentable
@@ -115,6 +116,11 @@ open class HandHistory : RealmObject(), Deletable, RowRepresentable, Filterable,
 	 */
 	var heroIndex: Int? = null
 
+	/***
+	 * Indicates if the hero wins the hand
+	 */
+	var winningPositions: RealmList<Int> = RealmList()
+
 	/***
 	 * The board
 	 */
@@ -403,6 +409,30 @@ open class HandHistory : RealmObject(), Deletable, RowRepresentable, Filterable,
 		return actionItems.joinToString(" ")
 	}
 
+	/***
+	 * Returns if the hero has won the hand, or part of the pot
+	 */
+	val heroWins: Boolean?
+		get() {
+			return this.heroIndex?.let {
+				this.winningPositions.contains(it)
+			} ?: run {
+				null
+			}
+		}
+
+//	private fun definesIfHeroWins() {
+//		this.heroIndex?.let { heroIndex ->
+//
+//			val heroCards = this.playerSetupForPosition(heroIndex)?.cards
+//			val heroNumberOfCards = heroCards?.size ?: 0
+//			if (this.board.size == 5 && heroNumberOfCards > 1) {
+//
+//			}
+//
+//		}
+//	}
+
 	/***
 	 * Creates a list of cards for the hand history to give a representation of the hand
 	 * We will try to add a minimum of 5 cards using by priority:
@@ -455,4 +485,46 @@ open class HandHistory : RealmObject(), Deletable, RowRepresentable, Filterable,
 		return views
 	}
 
+	fun compareHands(activePositions: List<Int>): List<Int> {
+
+		// Evaluate all hands
+		val results = activePositions.map {
+			this.playerSetupForPosition(it)?.cards?.let { hand ->
+				EvaluatorBridge.playerHand(hand, this.board)
+			} ?: run {
+				Int.MAX_VALUE
+			}
+		}
+
+		// Check who has best score (EvaluatorBridge gives a lowest score for a better hand)
+		return results.min()?.let { best ->
+			val winners = mutableListOf<Int>()
+			results.forEachIndexed { index, i ->
+				if (i == best && i != Int.MAX_VALUE) {
+					winners.add(activePositions[index])
+				}
+			}
+			winners
+		} ?: run {
+			listOf<Int>() // type needed for build
+		}
+
+	}
+
+	fun defineWinnerPositions() {
+
+		val folds = this.sortedActions.filter { it.type == Action.Type.FOLD }.map { it.position }
+		val activePositions = (0 until this.numberOfPlayers).toMutableList()
+		activePositions.removeAll(folds)
+
+		val winningPositions = when (activePositions.size) {
+			0 -> listOf() // no winner, everyone has fold. Should not happen
+			1 -> activePositions // One player has not fold, typically BET / FOLD
+			else -> this.compareHands(activePositions) // Several players remains, typically BET/FOLD or CHECKS
+		}
+
+		this.winningPositions.clear()
+		this.winningPositions.addAll(winningPositions)
+	}
+
 }

app/src/main/java/net/pokeranalytics/android/ui/modules/handhistory/HandHistoryAdapter.kt

@@ -39,7 +39,6 @@ import net.pokeranalytics.android.ui.view.RowRepresentable
 import net.pokeranalytics.android.ui.view.holder.RowViewHolder
 import net.pokeranalytics.android.ui.view.rowrepresentable.ViewIdentifier
 import net.pokeranalytics.android.util.extensions.formatted
-import java.util.*
 
 
 enum class HandRowType(var layoutRes: Int) : ViewIdentifier, RowRepresentable {

app/src/main/java/net/pokeranalytics/android/ui/modules/handhistory/evaluator/EvaluatorBridge.kt

@@ -11,8 +11,8 @@ class EvaluatorBridge {
 			arr: Array<T>,
 			len: Int,
 			startPosition: Int,
-			result: Array<T>,
+			result: Array<T?>,
-			callback: (Array<T>) -> (Unit)
+			callback: (Array<T?>) -> (Unit)
 		) {
 			if (len == 0) {
 				callback.invoke(result)
@@ -30,27 +30,30 @@ class EvaluatorBridge {
 
 		fun playerHand(hand: List<Card>, board: List<Card>): Int {
 
-			val handCards = hand.mapNotNull { it.toEvaluatorCard() }.toTypedArray()
+			val handCards = hand.mapNotNull { it.toEvaluatorCard() }
-			val boardCards = board.mapNotNull { it.toEvaluatorCard() }.toTypedArray()
+			val boardCards = board.mapNotNull { it.toEvaluatorCard() }
 
 			val handSize = 5
 			var result = Int.MAX_VALUE
-			when (hand.size) {
+			when (handCards.size) {
-				2 -> { // Hold'em
+				in 0..2 -> { // Hold'em
-					val allCards = arrayOf<net.pokeranalytics.android.ui.modules.handhistory.evaluator.Card>()
+					val allCards = mutableListOf<net.pokeranalytics.android.ui.modules.handhistory.evaluator.Card>()
-					allCards.plus(handCards)
+					allCards.addAll(handCards)
-					allCards.plus(boardCards)
+					allCards.addAll(boardCards)
 
 					if (allCards.size >= handSize) {
-						Combinator.combinations(allCards, handSize, 0, arrayOf()) {
+						Combinator.combinations(allCards.toTypedArray(), handSize, 0, arrayOfNulls(handSize)) {
 							result = min(result, Hand.evaluate(it))
 						}
 					}
 				}
 				else -> { // Omahas
-					Combinator.combinations(boardCards, 3, 0, arrayOf()) { bc ->
+					val bcArray = boardCards.toTypedArray()
-						Combinator.combinations(handCards, 2, 0, arrayOf()) { hc ->
+					val hcArray = handCards.toTypedArray()
-							val fcc = arrayOf<net.pokeranalytics.android.ui.modules.handhistory.evaluator.Card>()
+
+					Combinator.combinations(bcArray, 3, 0, arrayOfNulls(3)) { bc ->
+						Combinator.combinations(hcArray, 2, 0, arrayOfNulls(2)) { hc ->
+							val fcc = arrayOf<net.pokeranalytics.android.ui.modules.handhistory.evaluator.Card?>()
 							fcc.plus(bc) // Five Card Combination
 							fcc.plus(hc)
 							result = min(result, Hand.evaluate(fcc))

app/src/main/java/net/pokeranalytics/android/ui/modules/handhistory/model/ActionList.kt

@@ -238,6 +238,7 @@ class ActionList(var listener: ActionListListener) : ArrayList<ComputedAction>()
 	 * Returns the list of position still in play before the given [index]
 	 */
 	fun activePositions(index: Int, showDown: Boolean = false): MutableList<Position> {
+
 		val oustedPositions = this.take(index + 1)
 			.filter {
 				if (showDown) {
@@ -251,6 +252,7 @@ class ActionList(var listener: ActionListListener) : ArrayList<ComputedAction>()
 		val allPositions = this.positions.clone() as LinkedHashSet<Position>
 		allPositions.removeAll(oustedPositions)
 		return allPositions.toMutableList()
+
 	}
 
 	/***

app/src/main/java/net/pokeranalytics/android/ui/modules/handhistory/model/HandHistoryViewModel.kt

@@ -595,6 +595,7 @@ class HandHistoryViewModel : ViewModel(), RowRepresentableDataSource, CardCentra
 			this.handHistory.actions.clear()
 			val actions = this.sortedActions.map { it.action }
 			this.handHistory.actions.addAll(actions)
+			this.handHistory.defineWinnerPositions()
 
 			if (!this.handHistory.isManaged) {
 				realm.copyToRealmOrUpdate(this.handHistory)

app/src/main/java/net/pokeranalytics/android/ui/modules/handhistory/views/RowHandHistoryViewHolder.kt

@@ -3,6 +3,7 @@ package net.pokeranalytics.android.ui.modules.handhistory.views
 import android.view.View
 import androidx.recyclerview.widget.RecyclerView
 import kotlinx.android.synthetic.main.row_hand_history_view.view.*
+import net.pokeranalytics.android.R
 import net.pokeranalytics.android.model.handhistory.Street
 import net.pokeranalytics.android.model.realm.handhistory.HandHistory
 import net.pokeranalytics.android.ui.adapter.BindableHolder
@@ -30,7 +31,14 @@ class RowHandHistoryViewHolder(itemView: View) : RecyclerView.ViewHolder(itemVie
 
 		itemView.amount.text = handHistory.potSizeForStreet(Street.SUMMARY).formatted()
 
-//		itemView.handHistoryRow.setData(handHistory)
+		val colorId = when(handHistory.heroWins) {
+			true -> R.color.green
+			false -> R.color.red
+			else -> R.color.kaki_light
+		}
+
+		itemView.amount.setTextColor(itemView.context.getColor(colorId))
+
 		val listener = View.OnClickListener {
 			delegate?.onRowSelected(position, row)
 		}

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

@@ -56,46 +56,6 @@ class HandHistoryRowView : FrameLayout {
 
 		rowHandHistory.amount.text = handHistory.potSizeForStreet(Street.SUMMARY).formatted()
 
-//		val realm = Realm.getDefaultInstance()
-//		realm.executeTransaction {
-//
-//			val list = listOf(Card.newInstance(it, null, Card.Suit.CLOVER),
-//				Card.newInstance(Realm.getDefaultInstance(), 12, Card.Suit.HEART)
-//			)
-//
-//			list.forEach { card ->
-//				val view = card.view(context, LayoutInflater.from(context), rowHandHistory.cardsLayout)
-//				rowHandHistory.cardsLayout.addView(view)
-//			}
-//
-//			LayoutInflater.from(context).inflate(R.layout.view_card_separator, rowHandHistory.cardsLayout)
-//
-//			val list2 = listOf(Card.newInstance(it, null, Card.Suit.CLOVER),
-//				Card.newInstance(Realm.getDefaultInstance(), 12, Card.Suit.HEART)
-//			)
-//
-//			list2.forEach { card ->
-//				val view = card.view(context, LayoutInflater.from(context), rowHandHistory.cardsLayout)
-//				rowHandHistory.cardsLayout.addView(view)
-//			}
-//
-//		}
-
-		// Date
-//		rowHandHistory.transactionDateDay.text = handHistory.date.getShortDayName()
-//		rowHandHistory.transactionDateNumber.text = handHistory.date.getDayNumber()
-
-		// Title / Game type
-//		var title = handHistory.type?.name ?: "" + " " + handHistory.comment
-//		var subtitle = handHistory.bankroll?.name
-//
-//		rowHandHistory.transactionTitle.text = title
-//		rowHandHistory.transactionSubtitle.text = subtitle
-//
-//		 Amount
-//		val formattedStat = ComputedStat(Stat.NET_RESULT, handHistory.amount, currency = handHistory.bankroll?.utilCurrency).format()
-//		rowHandHistory.transactionAmount.setTextFormat(formattedStat, context)
-
 	}
 
 }