"""
Tests for HandEvaluator class
"""

import pytest
from poker.hand_evaluator import HandEvaluator
from poker.hand_ranking import HandType
from poker.card import Card, Rank, Suit


class TestHandEvaluator:
    """Test cases for HandEvaluator class"""
    
    def test_royal_flush(self):
        """Test royal flush detection"""
        cards_str = "AhKhQhJhTh2c3c"
        ranking = HandEvaluator.evaluateFromInput(cards_str)
        
        assert ranking.hand_type == HandType.ROYAL_FLUSH
        assert str(ranking) == "Royal Flush"
    
    def test_straight_flush(self):
        """Test straight flush detection"""
        cards_str = "2h3h4h5h6h7s8s"
        ranking = HandEvaluator.evaluateFromInput(cards_str)
        
        assert ranking.hand_type == HandType.STRAIGHT_FLUSH
        assert str(ranking) == "Straight Flush(6 high)"
    
    def test_four_of_a_kind(self):
        """Test four of a kind detection"""
        cards_str = "AsKs AhAdAc6s7s"
        ranking = HandEvaluator.evaluateFromInput(cards_str)
        
        assert ranking.hand_type == HandType.FOUR_OF_A_KIND
        assert str(ranking) == "Quad(A)"
    
    def test_full_house(self):
        """Test full house detection"""
        cards_str = "AsAhAd KsKh6s7s"
        ranking = HandEvaluator.evaluateFromInput(cards_str)
        
        assert ranking.hand_type == HandType.FULL_HOUSE
        assert "Full House(A over K)" in str(ranking)
    
    def test_flush(self):
        """Test flush detection"""
        cards_str = "AhKh6h4h2h7s8s"
        ranking = HandEvaluator.evaluateFromInput(cards_str)
        
        assert ranking.hand_type == HandType.FLUSH
        assert "Flush(A high)" in str(ranking)
    
    def test_straight(self):
        """Test straight detection"""
        cards_str = "As2h3d4c5h7s8s"
        ranking = HandEvaluator.evaluateFromInput(cards_str)
        
        assert ranking.hand_type == HandType.STRAIGHT
        assert str(ranking) == "Straight(5 high)"  # A-2-3-4-5 wheel
    
    def test_straight_ace_high(self):
        """Test straight with ace high"""
        cards_str = "AsTsJhQdKh7s8s"
        ranking = HandEvaluator.evaluateFromInput(cards_str)
        
        assert ranking.hand_type == HandType.STRAIGHT
        assert str(ranking) == "Straight(A high)"
    
    def test_three_of_a_kind(self):
        """Test three of a kind detection"""
        cards_str = "AsAhAd6s7h8s9s"
        ranking = HandEvaluator.evaluateFromInput(cards_str)
        
        assert ranking.hand_type == HandType.THREE_OF_A_KIND
        assert str(ranking) == "Three of a Kind(A)"
    
    def test_two_pair(self):
        """Test two pair detection"""
        cards_str = "AsAh6d6s7h8s9s"
        ranking = HandEvaluator.evaluateFromInput(cards_str)
        
        assert ranking.hand_type == HandType.TWO_PAIR
        assert "Two Pair(A and 6)" in str(ranking)
    
    def test_one_pair(self):
        """Test one pair detection"""
        cards_str = "AsAh6d4s2h3cJd"
        ranking = HandEvaluator.evaluateFromInput(cards_str)
        
        assert ranking.hand_type == HandType.ONE_PAIR
        assert str(ranking) == "Pair(A)"
    
    def test_high_card(self):
        """Test high card detection"""
        cards_str = "As6h4d8s9hJdKc"
        ranking = HandEvaluator.evaluateFromInput(cards_str)
        
        assert ranking.hand_type == HandType.HIGH_CARD
        assert str(ranking) == "High Card(A)"
    
    def test_wheel_straight(self):
        """Test A-2-3-4-5 straight (wheel)"""
        cards_str = "As2h3d4c5h7s8s"
        ranking = HandEvaluator.evaluateFromInput(cards_str)
        
        assert ranking.hand_type == HandType.STRAIGHT
        assert ranking.key_ranks[0] == Rank.FIVE  # 5 is high in wheel
    
    def test_invalid_input_not_seven_cards(self):
        """Test error handling for wrong number of cards"""
        with pytest.raises(ValueError):
            HandEvaluator.evaluateFromInput("AsKh")
        
        with pytest.raises(ValueError):
            HandEvaluator.evaluateFromInput("AsKhQdJc9h8s7d6c")
    
    def test_invalid_card_format(self):
        """Test error handling for invalid card format"""
        with pytest.raises(ValueError):
            HandEvaluator.evaluateFromInput("AsKhQdJcXh8s7d")
    
    def test_seven_cards_best_five_selected(self):
        """Test that best 5 cards are selected from 7"""
        # Should pick the straight flush over the pair
        cards_str = "2h3h4h5h6hAsAd"
        ranking = HandEvaluator.evaluateFromInput(cards_str)
        
        assert ranking.hand_type == HandType.STRAIGHT_FLUSH
        assert str(ranking) == "Straight Flush(6 high)"
    
    def test_multiple_possible_straights(self):
        """Test selecting highest straight from multiple possibilities"""
        cards_str = "As2h3d4c5h6s7s"
        ranking = HandEvaluator.evaluateFromInput(cards_str)
        
        assert ranking.hand_type == HandType.STRAIGHT
        # Should pick 3-4-5-6-7 over A-2-3-4-5
        assert ranking.key_ranks[0] == Rank.SEVEN
    
    def test_multiple_possible_flushes(self):
        """Test selecting best flush from multiple suits"""
        cards_str = "AhKh6h4h2h7s8s"
        ranking = HandEvaluator.evaluateFromInput(cards_str)
        
        assert ranking.hand_type == HandType.FLUSH
        assert ranking.key_ranks[0] == Rank.ACE
    
    def test_evaluate_five_cards_directly(self):
        """Test evaluating exactly 5 cards"""
        cards = [
            Card(Rank.ACE, Suit.SPADES),
            Card(Rank.ACE, Suit.HEARTS),
            Card(Rank.ACE, Suit.DIAMONDS),
            Card(Rank.ACE, Suit.CLUBS),
            Card(Rank.KING, Suit.SPADES)
        ]
        ranking = HandEvaluator.evaluate5Cards(cards)
        assert ranking.hand_type == HandType.FOUR_OF_A_KIND
        assert ranking.key_ranks[0] == Rank.ACE