Game.cs

using System;
using System.Windows.Forms;

namespace idk
{
    internal enum Turn
    {
        Player1,
        Player2
    }

    internal enum TurnResult
    {
        Success,
        DrawnCard,
        InvalidMove,
        GameOver
    }

    internal class Game : Rules
    {
        public event EventHandler TwoResponseResolved;
        public Player1 Player1 { get; private set; }
        public Player2 Player2 { get; private set; }
        public Deck Deck { get; private set; }
        public DiscardPile DiscardPile { get; private set; }
        public Turn CurrentTurn { get; private set; }
        public TurnResult LastTurnResult { get; private set; }
        public Card.Suit? SelectedSuit { get; private set; }

        private bool isTwoAttackPending;
        private PlayerView pendingTwoDefender;
        private PlayerView pendingTwoAttacker;

        public bool IsTwoAttackPending => isTwoAttackPending;

        public Game()
        {
            Player1 = new Player1();
            Player2 = new Player2();
            Deck = new Deck();
            DiscardPile = new DiscardPile();
            SelectedSuit = null;

            isTwoAttackPending = false;
            pendingTwoDefender = null;
            pendingTwoAttacker = null;
        }

        public void StartGame()
        {
            for (int i = 0; i < 5; i++)
            {
                Player1.AddCard(Deck.GetCard());
                Player2.AddCard(Deck.GetCard());
            }

            DiscardPile.AddCardToPile(Deck.GetCard());
            CurrentTurn = Turn.Player1;
        }

        public void ClickCard(EventArgs e, object sender)
        {
            var clickedBox = sender as PictureBox;
            if (clickedBox == null) return;

            var card = clickedBox.Tag as Card;
            if (card == null) return;

            // If a Two attack is pending, interpret this click as the defender response.
            if (TryResolvePendingTwoWithCard(card))
                return;

            PlayerView currentPlayer = null;
            PlayerView opponentPlayer = null;

            if (CurrentTurn == Turn.Player1 && Player1.HasCard(card))
            {
                currentPlayer = Player1;
                opponentPlayer = Player2;
            }
            else if (CurrentTurn == Turn.Player2 && Player2.HasCard(card))
            {
                currentPlayer = Player2;
                opponentPlayer = Player1;
            }
            else
            {
                return;
            }

            if (islegal(DiscardPile.TopCard, card, SelectedSuit))
            {
                currentPlayer.RemoveCard(card);
                DiscardPile.AddCardToPile(card);
                LastTurnResult = TurnResult.Success;

                if (card.rank != Card.Rank.Seven)
                {
                    SelectedSuit = null;
                }

                if (card.rank == Card.Rank.Two)
                {
                    BeginTwoAttack(opponentPlayer, currentPlayer);
                }
                else if (card.rank == Card.Rank.Seven)
                {
                    HandleSpecialCardSeven(currentPlayer, opponentPlayer);
                }
                else
                {
                    AdvanceTurn();
                }
            }
            else
            {
                LastTurnResult = TurnResult.InvalidMove;
            }
        }

        private void BeginTwoAttack(PlayerView defender, PlayerView attacker)
        {
            isTwoAttackPending = true;
            pendingTwoDefender = defender;
            pendingTwoAttacker = attacker;

            Action onDrawCards = () => ResolveTwoByDrawing(defender);

            defender.HandleOpponentSpecialCard(DiscardPile.TopCard, this, onDrawCards);
        }

        private bool TryResolvePendingTwoWithCard(Card responseCard)
        {
            if (!isTwoAttackPending || responseCard == null)
                return false;

            if (pendingTwoDefender == null || !pendingTwoDefender.HasCard(responseCard))
                return false;

            if (responseCard.rank != Card.Rank.King && responseCard.rank != Card.Rank.Four && responseCard.rank != Card.Rank.Two)
                return false;

            pendingTwoDefender.RemoveCard(responseCard);
            DiscardPile.AddCardToPile(responseCard);

            var attacker = pendingTwoAttacker;
            var defender = pendingTwoDefender;

            isTwoAttackPending = false;
            pendingTwoAttacker = null;
            pendingTwoDefender = null;

            if (responseCard.rank == Card.Rank.Two)
            {
                // counterattack: swap roles
                BeginTwoAttack(attacker, defender);
            }
            else
            {
                // blocked: attacker's turn continues
            }

            TwoResponseResolved?.Invoke(this, EventArgs.Empty);

            return true;
        }

        private void ResolveTwoByDrawing(PlayerView defender)
        {
            if (!isTwoAttackPending || pendingTwoDefender != defender)
                return;

            if (Deck.Count >= 2)
            {
                defender.AddCard(Deck.GetCard());
                defender.AddCard(Deck.GetCard());
            }
            else if (Deck.Count == 1)
            {
                defender.AddCard(Deck.GetCard());
            }

            isTwoAttackPending = false;
            pendingTwoAttacker = null;
            pendingTwoDefender = null;

            // after drawing, attacker's turn continues

            TwoResponseResolved?.Invoke(this, EventArgs.Empty);
        }

        private void HandleSpecialCardSeven(PlayerView currentPlayer, PlayerView opponent)
        {
            Action<Card.Suit> onSuitSelected = (selectedSuit) =>
            {
                SelectedSuit = selectedSuit;
                
                var suitName = GetSuitName(selectedSuit);
                MessageBox.Show($"Opponent selected: {suitName}\nYou must play a {suitName} card or another Seven!", 
                    "Suit Selected", MessageBoxButtons.OK, MessageBoxIcon.Information);
                
                AdvanceTurn();
            };

            currentPlayer.HandleSuitSelection(this, onSuitSelected);
        }

        private string GetSuitName(Card.Suit suit)
        {
            switch (suit)
            {
                case Card.Suit.Rosu:
                    return "Hearts ♥";
                case Card.Suit.Romb:
                    return "Diamonds ♦";
                case Card.Suit.Trefla:
                    return "Clubs ♣";
                case Card.Suit.Negru:
                    return "Spades ♠";
                default:
                    return suit.ToString();
            }
        }

        public void AdvanceTurn()
        {
            if (Player1.CardCount == 0)
            {
                LastTurnResult = TurnResult.GameOver;
                SelectedSuit = null;
                MessageBox.Show("Player 1 wins!");
                return;
            }
            else if (Player2.CardCount == 0)
            {
                LastTurnResult = TurnResult.GameOver;
                SelectedSuit = null;
                MessageBox.Show("Player 2 wins!");
                return;
            }

            CurrentTurn = (CurrentTurn == Turn.Player1) ? Turn.Player2 : Turn.Player1;
        }
    }
}