"""
Edge case tests to achieve 100% code coverage
"""

import pytest
from poker.card import Card, Rank, ShortDeckRank, Suit
from poker.hand_evaluator import HandEvaluator
from poker.hand_ranking import HandType, HandRanking
from shortdeck.hand_ranking import ShortDeckHandType, ShortDeckHandRanking


class TestCoverageEdgeCases:
    """Tests for edge cases to improve code coverage"""
    
    def test_rank_comparison_with_invalid_types(self):
        """Test rank comparisons with invalid types"""
        rank = Rank.ACE
        
        # Test __eq__ with non-Rank object
        result = rank.__eq__("invalid")
        assert result is NotImplemented
        
        # Test __lt__ with non-Rank object  
        result = rank.__lt__("invalid")
        assert result is NotImplemented
        
    def test_shortdeck_rank_comparison_with_invalid_types(self):
        """Test short deck rank comparisons with invalid types"""
        rank = ShortDeckRank.ACE
        
        # Test __eq__ with non-ShortDeckRank object
        result = rank.__eq__("invalid")
        assert result is NotImplemented
        
        # Test __lt__ with non-ShortDeckRank object
        result = rank.__lt__("invalid")
        assert result is NotImplemented
        
    def test_card_creation_with_valid_ranks(self):
        """Test Card creation with valid ranks"""
        # Standard deck card
        card1 = Card(Rank.ACE, Suit.HEARTS)
        assert card1.rank == Rank.ACE
        assert card1.suit == Suit.HEARTS
        assert not card1.is_short_deck()
        
        # Short deck card
        card2 = Card(ShortDeckRank.ACE, Suit.HEARTS)
        assert card2.rank == ShortDeckRank.ACE
        assert card2.suit == Suit.HEARTS
        assert card2.is_short_deck()
            
    def test_hand_evaluator_exactly_5_cards_error(self):
        """Test HandEvaluator with wrong number of cards"""
        cards = [Card(Rank.ACE, Suit.HEARTS)]  # Only 1 card
        
        with pytest.raises(ValueError, match="Expected 5 cards, got 1"):
            HandEvaluator.evaluate_5_cards(cards)
            
    def test_hand_ranking_comparison_with_invalid_types(self):
        """Test HandRanking comparisons with invalid types"""
        cards = [
            Card(Rank.ACE, Suit.HEARTS),
            Card(Rank.KING, Suit.HEARTS), 
            Card(Rank.QUEEN, Suit.HEARTS),
            Card(Rank.JACK, Suit.HEARTS),
            Card(Rank.TEN, Suit.HEARTS)
        ]
        
        ranking = HandRanking(HandType.ROYAL_FLUSH, [Rank.ACE], cards)
        
        # Test comparisons with non-HandRanking objects should return False, not NotImplemented
        assert ranking != "invalid"
        assert not (ranking == "invalid")
        
        # These should not raise exceptions
        try:
            ranking < "invalid"
            ranking <= "invalid" 
            ranking > "invalid"
            ranking >= "invalid"
        except TypeError:
            pass  # Expected behavior
        
    def test_shortdeck_hand_ranking_comparison_with_invalid_types(self):
        """Test ShortDeckHandRanking comparisons with invalid types"""
        cards = [
            Card(ShortDeckRank.ACE, Suit.HEARTS),
            Card(ShortDeckRank.KING, Suit.HEARTS),
            Card(ShortDeckRank.QUEEN, Suit.HEARTS),
            Card(ShortDeckRank.JACK, Suit.HEARTS),
            Card(ShortDeckRank.TEN, Suit.HEARTS)
        ]
        
        ranking = ShortDeckHandRanking(ShortDeckHandType.ROYAL_FLUSH, [ShortDeckRank.ACE], cards)
        
        # Test comparisons with non-ShortDeckHandRanking objects
        assert ranking != "invalid"
        assert not (ranking == "invalid")
        
    def test_card_comparison_and_equality(self):
        """Test Card comparison and equality edge cases"""
        card1 = Card(Rank.ACE, Suit.HEARTS)
        card2 = Card(Rank.ACE, Suit.HEARTS)
        card3 = Card(Rank.KING, Suit.HEARTS)
        
        # Test equality
        assert card1 == card2
        assert card1 != card3
        
        # Test comparison
        assert card1 > card3  # Ace > King
        
        # Test inequality with non-Card object
        result = card1.__eq__("not a card")
        assert result is NotImplemented
        
        result = card1.__lt__("not a card") 
        assert result is NotImplemented
        
    def test_rank_hash_consistency(self):
        """Test rank hash consistency"""
        rank1 = Rank.ACE
        rank2 = Rank.ACE
        rank3 = Rank.KING
        
        assert hash(rank1) == hash(rank2)
        assert hash(rank1) != hash(rank3)
        
    def test_shortdeck_rank_hash_consistency(self):
        """Test short deck rank hash consistency"""
        rank1 = ShortDeckRank.ACE
        rank2 = ShortDeckRank.ACE
        rank3 = ShortDeckRank.KING
        
        assert hash(rank1) == hash(rank2)
        assert hash(rank1) != hash(rank3)
        
    def test_card_string_parsing_valid_cases(self):
        """Test valid card string parsing cases"""
        # Test valid input
        cards = Card.parse_cards("As Kh")
        assert len(cards) == 2
        assert cards[0].rank == Rank.ACE
        assert cards[0].suit == Suit.SPADES
        assert cards[1].rank == Rank.KING
        assert cards[1].suit == Suit.HEARTS
        
        # Test empty string returns empty list
        cards = Card.parse_cards("")
        assert len(cards) == 0
    
    def test_card_getter_methods(self):
        """Test Card getter methods for coverage"""
        card = Card(Rank.ACE, Suit.HEARTS)
        assert card.get_rank() == Rank.ACE
        assert card.get_suit() == Suit.HEARTS
        
    def test_card_legacy_parse_methods(self):
        """Test legacy parsing methods"""
        # Test parseLongCards method
        cards = Card.parseLongCards("As Kh")
        assert len(cards) == 2
        
        # Test parse_short_deck_cards method  
        cards = Card.parse_short_deck_cards("As Kh")
        assert len(cards) == 2
    
    def test_hand_type_comparisons_with_invalid_types(self):
        """Test HandType comparisons with invalid types"""
        hand_type = HandType.ROYAL_FLUSH
        
        # Test __lt__ with invalid type
        result = hand_type.__lt__("invalid")
        assert result is NotImplemented
        
        # Test __eq__ with invalid type
        result = hand_type.__eq__("invalid")
        assert result is NotImplemented