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.Net;
using System.Net.Sockets;
using System.IO;
using System.Threading;

namespace Game_Server
{
    public partial class GinRummyServerForm : Form
    {
        // Thread signal.
        private  ManualResetEvent tcpClientConnected=new ManualResetEvent(false);
        private int port = 10; //Port number
        private static int MAX_CLIENTS = 4;
        private ServerThread[] clientList = new ServerThread[MAX_CLIENTS];
        private Thread[] clientThreads = new Thread[MAX_CLIENTS];
        private string[] playerNames = new String[MAX_CLIENTS];
        private int numberOfPlayersToConnect;
        private int clientCount;
        private IPAddress localAddr = IPAddress.Parse("127.0.0.1");
        private TcpClient socketForClient;

        public GinRummyServerForm()
        {
            InitializeComponent();
            numberOfPlayersLabel.Text = "Number of connected players: 0";
        }

        private delegate void DisplayDelegate(int clientCount);

        private void updateClientCountLabel(int clientCount)
        {
            numberOfPlayersLabel.Text = "Number of connected clients: " + clientCount;
        }


        // Process the client connection.
        private void DoAcceptTcpClientCallback(IAsyncResult ar) 
        {
            this.Validate();

            // Get the listener that handles the client request.
            TcpListener listener = (TcpListener)ar.AsyncState;

            // End the operation 

            socketForClient = listener.EndAcceptTcpClient(ar);         

            // Signal the calling thread to continue.
            tcpClientConnected.Set();

        }

        private void launchServerButton_Click(object sender, EventArgs e)
        {
            numberOfPlayersToConnect = (int)numberOfPlayersInput.Value;

            try
            {
                // Set the event to nonsignaled state.
                tcpClientConnected.Reset();

                TcpListener server = new TcpListener(localAddr, port);

                // Start listening for client requests.
                server.Start();

                int clientID = 0;
                clientCount = 0;

                while (clientID < numberOfPlayersToConnect)
                {
                    // Set the event to nonsignaled state.
                    tcpClientConnected.Reset();

                    server.BeginAcceptTcpClient(new AsyncCallback(DoAcceptTcpClientCallback),server);

                    // Wait until a connection is made and processed before 
                    // continuing.

                    tcpClientConnected.WaitOne();
                    if (socketForClient.Connected)
                    {
                        clientCount++;
                        numberOfPlayersLabel.Invoke(new DisplayDelegate(updateClientCountLabel), new object[] { clientCount });
                        ServerThread listenerThread = new ServerThread(socketForClient, clientID);
                        Thread thread = new Thread(new ThreadStart(listenerThread.runServerThread));
                        clientList[clientID] = listenerThread;
                        clientThreads[clientID] = thread;
                        clientID++;
                        thread.Start();
                        string name=clientList[clientID].getMessage();
                        int id = Convert.ToInt32(clientList[clientID].getMessage());
                    }             
                }

                // Initialize list of players and deck and deal the cards
            }
            catch (SocketException ex)
            {
                Console.WriteLine("SocketException: {0}", ex);
            }

            infoTextbox.Text = "Aborting threads";
            for (int i = 0; i < numberOfPlayersToConnect; i++)
            {
                clientThreads[i].Abort();
            }
        }
    }

    class ServerThread
    {
        private TcpClient client;
        private int clientID;
        private StreamWriter writer;
        private StreamReader reader;

        public ServerThread(TcpClient _client, int _clientID)
        {
            client = _client;
            clientID = _clientID;

            NetworkStream networkStream = client.GetStream();

            writer = new System.IO.StreamWriter(networkStream);
            reader = new System.IO.StreamReader(networkStream);
        }

        public int ID
        {
            get { return clientID; }
        }

        public void runServerThread()
        {    
            while (true) { }
        }

        public void sendMessage(String message)
        {
            writer.WriteLine(message);
            writer.Flush();
        }

        public string getMessage()
        {
            string message = reader.ReadLine();
            return message;
        }
    }
}