package poker.domain

import poker.domain.Valor._
import poker.domain.Naipe._
import org.testng.annotations._
import org.junit.Assert._
import poker.PokerHelperTest._

class CombinacaoTest {
  
  @Test
  def conjuntosDe_CartaMaisAlta() {
    var conjuntos = menorCartaMaisAlta().conjuntosDe()
    assertEquals(5, conjuntos.length)
    assertTrue(conjuntos.forall { c:Iterable[Carta] => c.toList.length == 1 })
  }
  
  @Test
  def conjuntosDe_UmPar() {
    var conjuntos = menorPar().conjuntosDe()
    assertEquals(4, conjuntos.length)
    assertEquals(2, conjuntos(0).toList.length)
    assertEquals(1, conjuntos(1).toList.length)
    assertEquals(1, conjuntos(2).toList.length)
    assertEquals(1, conjuntos(3).toList.length)
  }
  
  @Test
  def conjuntosDe_DoisPares() {
    var conjuntos = menorDoisPares().conjuntosDe()
    assertEquals(3, conjuntos.length)
    assertEquals(2, conjuntos(0).toList.length)
    assertEquals(2, conjuntos(1).toList.length)
    assertEquals(1, conjuntos(2).toList.length)
  }
  
  @Test
  def conjuntosDe_FullHouse() {
    var conjuntos = menorFullHouse().conjuntosDe()
    assertEquals(2, conjuntos.length)
    assertEquals(3, conjuntos(0).toList.length)
    assertEquals(2, conjuntos(1).toList.length)
  }
  
  @Test
  def conjuntosDe_Quadra() {
    var conjuntos = menorQuadra().conjuntosDe()
    assertEquals(2, conjuntos.length)
    assertEquals(4, conjuntos(0).toList.length)
    assertEquals(1, conjuntos(1).toList.length)
  }
  
  @Test
  def qtdeDePares() {
    assertEquals(0, menorCartaMaisAlta().pares())
    assertEquals(1, menorPar().pares())
    assertEquals(2, menorDoisPares().pares())
    assertEquals(0, menorTrinca().pares())
    assertEquals(1, menorFullHouse().pares())
    assertEquals(0, menorQuadra().pares())
  }
  
  @Test
  def qtdeDeTrincas() {
    assertEquals(0, menorCartaMaisAlta().trincas())
    assertEquals(0, menorPar().trincas())
    assertEquals(0, menorDoisPares().trincas())
    assertEquals(1, menorTrinca().trincas())
    assertEquals(1, menorFullHouse().trincas())
    assertEquals(0, menorQuadra().trincas())
  }
  
  @Test
  def qtdeDeQuadras() {
    assertEquals(0, menorCartaMaisAlta().trincas())
    assertEquals(0, menorPar().quadras())
    assertEquals(0, menorDoisPares().quadras())
    assertEquals(0, menorTrinca().quadras())
    assertEquals(0, menorFullHouse().quadras())
    assertEquals(1, menorQuadra().quadras())
  }
  
  @Test
  def sequencia() {
    assertTrue(menorSequencia().sequencia())
//    assertTrue(maiorSequencia().sequencia())
    assertTrue(sequenciaComAS2().sequencia())
    assertFalse(menorPar().sequencia())
    assertFalse(menorDoisPares().sequencia())
    assertFalse(menorTrinca().sequencia())
    assertFalse(menorFullHouse().sequencia())
//    assertFalse(menorFlush().sequencia())
    assertFalse(menorQuadra().sequencia())
  }
  
//  S: Royal Straight Flush
//  S: Straight Flush
//  V: Four of a kind
//  V: full house
//  N: flush
//  S: Straight
//  V: Three of a kind
//  V: Two Pairs
//  V: One Pair: menor par com maior HighCard, par com par, par+carta mais alta,...
//  V: High Card: carta mais alta com mais alta, segunda mais alta, ultima mais alta, empate
  
//  @Test
//  def combinacoesComCartaMaisAlta_GanhaCartaMaisAlta() {
//    assertTrue(c((2, PAUS), (3, PAUS), (4, OUROS), (5, OUROS), (8, ESPADAS)) > 
//               c((2, OUROS), (3, OUROS), (4, PAUS), (5, PAUS), (7, COPAS)))
//
//    assertTrue(c((2, PAUS), (3, PAUS), (4, OUROS), (5, OUROS), (7, ESPADAS)) < 
//               c((2, OUROS), (3, OUROS), (4, PAUS), (5, PAUS), (8, COPAS)))
//  }
  
}
