using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading;
using Gin_Rummy_Game;

namespace Gin_Rummy_GUI
{
    public partial class GinRummyForm : Form
    {
        private static string CardImagesFolder = "C:\\Documents and Settings\\spannm\\Desktop\\Personal Stuff\\C#\\C# Projects VS2008\\Gin Rummy\\Gin Rummy Game\\Card Images\\";
        private int numberOfPlayers, currentPlayer;
        private Player[] players;
        private String interactivePlayerName=null;
        private PictureBox[] selectedSwapPictureBoxes;
        private DeckOfCards drawDeck, discardDeck;
        private String faceDownCardFile = "b1fv.gif";
        private int numberOfSwapPictureBoxes;

        public GinRummyForm()
        {
            numberOfPlayers = 4;
            selectedSwapPictureBoxes = new PictureBox[2];
            InitializeComponent();
        }

        private void displayHand(GroupBox gb, List<PlayingCard> hand, Boolean faceDown)
        {
            String cardFile = CardImagesFolder + faceDownCardFile;

            if (hand == null)
                return;

            hand.Sort();

            int handSize = hand.Count;

            for (int cardNo = 0; cardNo < handSize; cardNo++)
            {
                Control c = gb.Controls[handSize-cardNo-1];
                Type controlType = c.GetType();
                if (!controlType.ToString().Equals("System.Windows.Forms.PictureBox"))
                    return;
                PictureBox pb = (PictureBox)c;

                if (faceDown)
                    pb.Image = Image.FromFile(cardFile);
                else
                {
                    PlayingCard card = hand[cardNo];
                    pb.Image = card.getImage();
                }

            }
        }

        private void updateDeckPanel()
        {
            if (drawDeck.Size == 0)
            {
                // Reshuffle the discard deck which becomes the draw deck
                do
                {
                    PlayingCard card1 = discardDeck.drawCard();
                    drawDeck.addCard(card1);
                } while (discardDeck.Size > 0);

                drawDeck.shuffleDeck();

                PlayingCard card = drawDeck.drawCard();
                discardDeck.addCard(card);
            }

            String cardFile = CardImagesFolder + faceDownCardFile;
            deckPanel.Visible = true;
            PlayingCard card2 = discardDeck.TopCard;
            discardDeckPictureBox.Image = card2.getImage();
            drawDeckPictureBox.Image = Image.FromFile(cardFile);

          //  PlayingCard c1 = drawDeck.TopCard;
          //  drawDeckPictureBox.Image = c1.getImage();

            updateCountLabels();
        }

        private void updateCountLabels()
        {
            drawDeckCountLabel.Text = drawDeck.Size + " cards";
            discardDeckCountLabel.Text = discardDeck.Size+ " cards";
        }

        private int  getControlOfType<T>(Panel p)
        {
           int controlIndex = 0;
           bool controlFound = false;    
           do
           {
               if (p.Controls[controlIndex] is T)
                       controlFound = true;
                   else
                       controlIndex++;
           } while ((!controlFound) && (controlIndex < p.Controls.Count));

           return controlIndex;
        }

        private void showWinMessage(int winningPlayer)
        {
            // Display the hand
            if (winningPlayer > 0)    // Autonomous player
            {
                Panel p = (Panel)computerPlayerPanels.Controls[winningPlayer - 1];
                int controlIndex = getControlOfType<GroupBox>(p);
                GroupBox gb = (GroupBox)(p.Controls[controlIndex]); // Should be GroupBox
                displayHand(gb, players[winningPlayer].Hand, false);
            }

            MessageBox.Show(players[winningPlayer].Name + " wins!");

            // Disable all buttons and prompt for a new game
            gameTextBox.Text = "Click 'New Game' button to start";
  
            for (int player = 0; player < numberOfPlayers; player++)
            {
                if (player > 0)
                {
                    Panel p = (Panel)computerPlayerPanels.Controls[player - 1];
                    int controlIndex = getControlOfType<Button>(p);
                    Button b = (Button)(p.Controls[controlIndex]);
                    b.Enabled = false;
                }
                else
                {
                    Panel p = (Panel)interactivePlayerPanel;
                    int controlIndex = getControlOfType<Button>(p);
                    Button b = (Button)(p.Controls[controlIndex]);
                    b.Enabled = false;
                 }
            }
        }

        private void GinRummyForm_FormClosed(object sender, FormClosedEventArgs e)
        {
            MessageBox.Show("Close game?");
        }

        private void newGameButton_Click(object sender, EventArgs e)
        {
            // Create the deck of cards
            drawDeck = new DeckOfCards(false);
            drawDeck.shuffleDeck();

            // Create the array of players
            players = new Player[numberOfPlayers];

            // Allocate the players as interactive or autonomous
            if (interactivePlayerName == null)
                interactivePlayerName = gameTextBox.Text;

            players[0] = new InteractivePlayer(interactivePlayerName);

            for (int i = 1; i < numberOfPlayers; i++)
                players[i] = new AutonomousPlayer("Computer" + (i - 1));

            // Deal the cards and display the hands on the form
            drawDeck.dealDeck(players, numberOfPlayers);

            // Create initialize the discard deck
            discardDeck = new DeckOfCards(true);

            // Draw the first card from the draw deck and add it to the discard deck
            PlayingCard card = drawDeck.drawCard();
            discardDeck.addCard(card);
            updateDeckPanel();
      
            // Initialize labels for player names and display other panels
            interactivePlayerLabel.Text = interactivePlayerName;
            interactivePlayerPanel.Visible = true;
            computerPlayerPanels.Visible = true;

            // Display interactive player hand
            displayHand(interactivePlayerPictureBoxes, players[0].Hand , false);
            interactivePlayerPictureBoxes.Visible = true;
            
            // Enable play button
            int controlIndex = getControlOfType<Button>(interactivePlayerPanel);
            Button b = (Button)(interactivePlayerPanel.Controls[controlIndex]);
            b.Enabled = true;         

            // Display card images on computer player panels 
            for (int panelNumber = 0; panelNumber < (numberOfPlayers - 1); panelNumber++)
            {
                Panel p = (Panel)computerPlayerPanels.Controls[panelNumber];      
                controlIndex = getControlOfType<GroupBox>(p);
                GroupBox gb = (GroupBox)(p.Controls[controlIndex]); // Should be GroupBox
                displayHand(gb, players[panelNumber+1].Hand, true);
                p.Visible = true;
            }

            // No picture boxes to swap as yet
            numberOfSwapPictureBoxes = 0;
            selectedSwapPictureBoxes[0] = selectedSwapPictureBoxes[1] = null;

            // Enable picture boxes and reset borders
            drawDeckPictureBox.BorderStyle = BorderStyle.None;
            drawDeckPictureBox.Enabled = false;
            discardDeckPictureBox.BorderStyle = BorderStyle.None;
            discardDeckPictureBox.Enabled = false;
            for (int i=0; i<7; i++)
            {
                PictureBox p = (PictureBox)(interactivePlayerPictureBoxes.Controls[i]);
                p.BorderStyle = BorderStyle.None;
                p.Enabled = false;
            }

            // Start game with player 0
            gameTextBox.Text = players[0].Name + " to play";
            currentPlayer = 0;
        }

        private void updateGUI(Panel playerPanel, int currentPlayer)
        {

            // Update the hand display and the deck panel
            int controlIndex = getControlOfType<GroupBox>(playerPanel);
            GroupBox gb = (GroupBox)(playerPanel.Controls[controlIndex]); // Should be GroupBox
            if (currentPlayer==0)
                displayHand(gb, players[currentPlayer].Hand, false);
            else
                displayHand(gb, players[currentPlayer].Hand, true);

            updateDeckPanel();

            // Disable the current panel play button
            controlIndex = getControlOfType<Button>(playerPanel);
            Button playButton = (Button)playerPanel.Controls[controlIndex];
            playButton.Enabled = false;

            currentPlayer = (currentPlayer + 1) % numberOfPlayers;

            // Get next player panel and enable the play button
            if (currentPlayer > 0)
            {
                Panel p = (Panel)computerPlayerPanels.Controls[currentPlayer - 1];
                controlIndex = getControlOfType<Button>(p);
                Button b = (Button)(p.Controls[controlIndex]);
                b.Enabled = true;
                gameTextBox.Text = players[currentPlayer].Name + " to play";
            }
            else
            {
                Panel p = (Panel)interactivePlayerPanel;
                controlIndex = getControlOfType<Button>(p);
                Button b = (Button)(p.Controls[controlIndex]);
                b.Enabled = true;
                gameTextBox.Text = players[0].Name + " to play";
            }
        }

        private void play(Panel playerPanel, int currentPlayer)
        {
            // Play the hand
            if (players[currentPlayer] is AutonomousPlayer)
            {
                PlayState rp = players[currentPlayer].playHand(drawDeck, discardDeck);
                players[currentPlayer].upDateDecks(drawDeck, discardDeck, rp);
            }
        }

        private PlayingCard getCardFromPictureBox(PictureBox p)
        {
            if (p == drawDeckPictureBox)
                return drawDeck.TopCard;
            else if (p == discardDeckPictureBox)
                return discardDeck.TopCard;
            else
            {
                for (int i = 0; i < 7; i++)
                {
                    PictureBox p1 = (PictureBox)(interactivePlayerPictureBoxes.Controls[i]);
                    if (p == p1)
                         return players[currentPlayer].Hand[7-i-1];
                }
            }

            return null;
        }

        private int getSelectedPictureBoxIndex(PictureBox picBox)
        {
            int pictureBoxIndex = -1;
            for (int i = 0; i < 7; i++)
            {
                PictureBox p = (PictureBox)(interactivePlayerPictureBoxes.Controls[i]);
                if (picBox == p)
                    pictureBoxIndex = i;
            }

            return pictureBoxIndex;
        }

        private PlayState selectSwapPictureBoxes(PictureBox picBox)
        {
            PlayState returnObj = new PlayState(null, PlayState.DeckType.NOPLAY);

            if (numberOfSwapPictureBoxes == 0)
            {
                if (picBox == discardDeckPictureBox)
                {
                    selectedSwapPictureBoxes[numberOfSwapPictureBoxes++] = picBox;
                    picBox.BorderStyle = BorderStyle.Fixed3D;
                    picBox.Enabled = false;
                    gameTextBox.Text = "Select a card from " + players[currentPlayer].Name + "'s hand to swap with";
                    return returnObj;
                }
                else if (picBox == drawDeckPictureBox)
                {
                    selectedSwapPictureBoxes[numberOfSwapPictureBoxes++] = picBox;
                    picBox.BorderStyle = BorderStyle.Fixed3D;
                    picBox.Enabled = false;
                    drawDeckPictureBox.Image = drawDeck.TopCard.getImage();
                    gameTextBox.Text = "Either select the discard deck to reject or select a card from " + players[currentPlayer].Name + "'s hand to swap with";
                    return returnObj;
                }
            }
            else if (numberOfSwapPictureBoxes == 1)
            {
                if (selectedSwapPictureBoxes[0] == discardDeckPictureBox)
                {
                    // Select a card from the current players hand
                    int index = getSelectedPictureBoxIndex(picBox);
                    if (index >= 0)
                    {
                        picBox.BorderStyle = BorderStyle.Fixed3D;
                        picBox.Enabled = false;
                        numberOfSwapPictureBoxes++;
                        PlayingCard card1 = players[currentPlayer].Hand[7 - index - 1];
                        returnObj = new PlayState(card1, PlayState.DeckType.DISCARDDECK);
                    }
                }
                else if (selectedSwapPictureBoxes[0] == drawDeckPictureBox)
                {
                    if (picBox == discardDeckPictureBox)
                    {
                        // Drawdeck card discarded
                        picBox.BorderStyle = BorderStyle.Fixed3D;
                        picBox.Enabled = false;
                        numberOfSwapPictureBoxes++;
                        returnObj = new PlayState(null, PlayState.DeckType.BOTHDECKS);
                    }
                    else
                    {
                        // Select a card from the current players hand
                        int index = getSelectedPictureBoxIndex(picBox);
                        if (index >= 0)
                        {
                            picBox.BorderStyle = BorderStyle.Fixed3D;
                            picBox.Enabled = false;
                            numberOfSwapPictureBoxes++;
                            PlayingCard card1 = players[currentPlayer].Hand[7 - index - 1];
                            returnObj = new PlayState(card1, PlayState.DeckType.DRAWDECK);
                        }
                    }
                }

                // Reset borders and disable
                drawDeckPictureBox.BorderStyle = BorderStyle.None;
                discardDeckPictureBox.BorderStyle = BorderStyle.None;
                drawDeckPictureBox.Enabled = false;
                discardDeckPictureBox.Enabled = false;
                for (int i = 0; i < 7; i++)
                {
                    PictureBox p = (PictureBox)(interactivePlayerPictureBoxes.Controls[i]);
                    p.BorderStyle = BorderStyle.None;
                    p.Enabled = false;
                }
            }

            return returnObj;
        } 

        private void interactivePlayerPlayButton_Click(object sender, EventArgs e)
        {
            // Play the hand interactively
            drawDeckPictureBox.Enabled = true;
            discardDeckPictureBox.Enabled = true;
            for (int i = 0; i < 7; i++)
            {
                PictureBox p = (PictureBox)(interactivePlayerPictureBoxes.Controls[i]);
                p.Enabled = true;
            }

            // No picture boxes to swap as yet
            numberOfSwapPictureBoxes = 0;
            selectedSwapPictureBoxes[0] = selectedSwapPictureBoxes[1] = null;
        }

        private void computer0PlayButton_Click(object sender, EventArgs e)
        {
            // Play the hand and update the GUI
            play(computer0PlayerPanel, currentPlayer);
            updateGUI(computer0PlayerPanel, currentPlayer);
            int handVal = players[currentPlayer].handValue(players[currentPlayer].Hand);
            MessageBox.Show("Hand value= " + handVal);

            if (handVal == 7)
            {
                showWinMessage(currentPlayer);
                return;
            }
            currentPlayer = (currentPlayer + 1) % numberOfPlayers;
        }

        private void computer1PlayButton_Click(object sender, EventArgs e)
        {
            // Play the hand and update the GUI
            play(computer1PlayerPanel, currentPlayer);
            updateGUI(computer1PlayerPanel, currentPlayer);
            int handVal = players[currentPlayer].handValue(players[currentPlayer].Hand);
            MessageBox.Show("Hand value= " + handVal);

            if (handVal == 7)
            {
                showWinMessage(currentPlayer);
                return;
            }
            currentPlayer = (currentPlayer + 1) % numberOfPlayers;
        }

        private void computer2PlayButton_Click(object sender, EventArgs e)
        {
            // Play the hand and update the GUI
            play(computer2PlayerPanel, currentPlayer);
            updateGUI(computer2PlayerPanel, currentPlayer);
            int handVal = players[currentPlayer].handValue(players[currentPlayer].Hand);
            MessageBox.Show("Hand value= " + handVal);

            if (handVal == 7)
            {
                showWinMessage(currentPlayer);
                return;
            }
            currentPlayer = (currentPlayer + 1) % numberOfPlayers;
        }

        private void card0PictureBox_MouseClick(object sender, MouseEventArgs e)
        {
            if (currentPlayer!=0)
                return;

            PlayState rp = selectSwapPictureBoxes((PictureBox)sender);

            if (numberOfSwapPictureBoxes == 2)
            {
                players[currentPlayer].upDateDecks(drawDeck, discardDeck, rp);

                updateGUI(interactivePlayerPanel, currentPlayer);
                int handVal = players[currentPlayer].handValue(players[currentPlayer].Hand);
                MessageBox.Show("Hand value= " + handVal+ " current player= " + currentPlayer);

                if (handVal == 7)
                {
                    showWinMessage(currentPlayer);
                    return;
                }
                currentPlayer = (currentPlayer + 1) % numberOfPlayers;
            }
        }

        private void card1PictureBox_MouseClick(object sender, MouseEventArgs e)
        {
            if (currentPlayer != 0)
                return;

            PlayState rp = selectSwapPictureBoxes((PictureBox)sender);

            if (numberOfSwapPictureBoxes == 2)
            {
                players[currentPlayer].upDateDecks(drawDeck, discardDeck, rp);

                updateGUI(interactivePlayerPanel, currentPlayer);
                int handVal = players[currentPlayer].handValue(players[currentPlayer].Hand);
                MessageBox.Show("Hand value= " + handVal);

                if (handVal == 7)
                {
                    showWinMessage(currentPlayer);
                    return;
                }
                currentPlayer = (currentPlayer + 1) % numberOfPlayers;
            }
        }

        private void card2PictureBox_MouseClick(object sender, MouseEventArgs e)
        {
            if (currentPlayer != 0)
                return;

            PlayState rp = selectSwapPictureBoxes((PictureBox)sender);

            if (numberOfSwapPictureBoxes == 2)
            {
                players[currentPlayer].upDateDecks(drawDeck, discardDeck, rp);

                updateGUI(interactivePlayerPanel, currentPlayer);
                int handVal = players[currentPlayer].handValue(players[currentPlayer].Hand);
                MessageBox.Show("Hand value= " + handVal);

                if (handVal == 7)
                {
                    showWinMessage(currentPlayer);
                    return;
                }
                currentPlayer = (currentPlayer + 1) % numberOfPlayers;
            }
        }

        private void card3PictureBox_MouseClick(object sender, MouseEventArgs e)
        {
            if (currentPlayer != 0)
                return;

            PlayState rp = selectSwapPictureBoxes((PictureBox)sender);

            if (numberOfSwapPictureBoxes == 2)
            {
                players[currentPlayer].upDateDecks(drawDeck, discardDeck, rp);

                updateGUI(interactivePlayerPanel, currentPlayer);
                int handVal = players[currentPlayer].handValue(players[currentPlayer].Hand);
                MessageBox.Show("Hand value= " + handVal);

                if (handVal == 7)
                {
                    showWinMessage(currentPlayer);
                    return;
                }
                currentPlayer = (currentPlayer + 1) % numberOfPlayers;
            }
        }

        private void card4PictureBox_MouseClick(object sender, MouseEventArgs e)
        {
            if (currentPlayer != 0)
                return;

            PlayState rp = selectSwapPictureBoxes((PictureBox)sender);

            if (numberOfSwapPictureBoxes == 2)
            {
                players[currentPlayer].upDateDecks(drawDeck, discardDeck, rp);

                updateGUI(interactivePlayerPanel, currentPlayer);
                int handVal = players[currentPlayer].handValue(players[currentPlayer].Hand);
                MessageBox.Show("Hand value= " + handVal);

                if (handVal == 7)
                {
                    showWinMessage(currentPlayer);
                    return;
                }
                currentPlayer = (currentPlayer + 1) % numberOfPlayers;
            }
        }

        private void card5PictureBox_MouseClick(object sender, MouseEventArgs e)
        {
            if (currentPlayer != 0)
                return;

            PlayState rp = selectSwapPictureBoxes((PictureBox)sender);

            if (numberOfSwapPictureBoxes == 2)
            {
                players[currentPlayer].upDateDecks(drawDeck, discardDeck, rp);

                updateGUI(interactivePlayerPanel, currentPlayer);
                int handVal = players[currentPlayer].handValue(players[currentPlayer].Hand);
                MessageBox.Show("Hand value= " + handVal);

                if (handVal == 7)
                {
                    showWinMessage(currentPlayer);
                    return;
                }
                currentPlayer = (currentPlayer + 1) % numberOfPlayers;
            }
        }

        private void card6PictureBox_MouseClick(object sender, MouseEventArgs e)
        {
            if (currentPlayer != 0)
                return;

            PlayState rp = selectSwapPictureBoxes((PictureBox)sender);

            if (numberOfSwapPictureBoxes == 2)
            {
                players[currentPlayer].upDateDecks(drawDeck, discardDeck, rp);

                updateGUI(interactivePlayerPanel, currentPlayer);
                int handVal = players[currentPlayer].handValue(players[currentPlayer].Hand);
                MessageBox.Show("Hand value= " + handVal);

                if (handVal == 7)
                {
                    showWinMessage(currentPlayer);
                    return;
                }
                currentPlayer = (currentPlayer + 1) % numberOfPlayers;
            }
        }

        private void drawDeckPictureBox_MouseClick(object sender, MouseEventArgs e)
        {
            if (currentPlayer != 0)
                return;

            PlayState rp = selectSwapPictureBoxes((PictureBox)sender);

            if (numberOfSwapPictureBoxes == 2)
            {
                players[currentPlayer].upDateDecks(drawDeck, discardDeck, rp);

                updateGUI(interactivePlayerPanel, currentPlayer);
                int handVal = players[currentPlayer].handValue(players[currentPlayer].Hand);
                MessageBox.Show("Hand value= " + handVal);

                if (handVal == 7)
                {
                    showWinMessage(currentPlayer);
                    return;
                }
                currentPlayer = (currentPlayer + 1) % numberOfPlayers;
            }
        }

        private void discardDeckPictureBox_MouseClick(object sender, MouseEventArgs e)
        {
            if (currentPlayer != 0)
                return;

            PlayState rp = selectSwapPictureBoxes((PictureBox)sender);

            if (numberOfSwapPictureBoxes == 2)
            {
                players[currentPlayer].upDateDecks(drawDeck, discardDeck, rp);

                updateGUI(interactivePlayerPanel, currentPlayer);
                int handVal = players[currentPlayer].handValue(players[currentPlayer].Hand);
                MessageBox.Show("Hand value= " + handVal);

                if (handVal == 7)
                {
                    showWinMessage(currentPlayer);
                    return;
                }
                currentPlayer = (currentPlayer + 1) % numberOfPlayers;
            }
        }
     }
}