using System;
using System.Net;
using System.Net.Sockets;
using System.Collections.Generic;
using System.Threading;

using Duck.Virtual.Users;

namespace Duck.Net.Game
{
    /// <summary>
    /// Asynchronous socket server for the info connections.
    /// </summary>
    public static class infoSocketServer
    {
        private static Socket _socketHandler;
        private static int _Port;
        private static int _maxConnections;
        private static int _acceptedConnections;
        private static HashSet<int> _activeConnections;

        /// <summary> 
        /// Initializes the socket listener for game connections and starts listening. 
        /// </summary> 
        /// <param name="bindPort">The port where the socket listener should be bound to.</param> 
        /// <param name="maxConnections">The maximum amount of simultaneous connections.</param> 
        /// <param name="backLog">The maximum length of the connection request queue.</param>
        /// <remarks></remarks> 
        internal static bool Init(int bindPort, int maxConnections, int backLog)
        {
            _Port = bindPort;
            _maxConnections = maxConnections;
            _activeConnections = new HashSet<int>();
            _socketHandler = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            IO.WriteLine("Starting up socket server for info connections on port " + bindPort + "...");
            try
            {
                _socketHandler.Bind(new IPEndPoint(IPAddress.Any, bindPort));
                _socketHandler.Listen(backLog);
                _socketHandler.BeginAccept(new AsyncCallback(connectionRequest), _socketHandler);

                IO.WriteLine("Socket server for info connections running on port " + bindPort + ".");
                IO.WriteLine("Max simultaneous connections is " + maxConnections + ".");
                IO.WriteLine("Max length of connection request queue (backlog) is " + backLog + ".");
                return true;
            }

            catch
            {
                IO.WriteError("Error while setting up asynchronous socket server for info connections on port " + bindPort);
                IO.WriteError("Port " + bindPort + " could be invalid or in use already.");
                return false;
            }
        }
        private static void connectionRequest(IAsyncResult iAr)
        {
            try
            {
                int connectionID = 0;
                for (int i = 1; i < _maxConnections; i++)
                {
                    if (_activeConnections.Contains(i) == false)
                    {
                        connectionID = i;
                        break;
                    }
                }

                if (connectionID > 0)
                {
                    Socket Request = ((Socket)iAr.AsyncState).EndAccept(iAr);
                    IO.WriteLine("Accepted connection [" + connectionID + "] from " + Request.RemoteEndPoint.ToString().Split(':')[0]);
                    _activeConnections.Add(connectionID);
                    _acceptedConnections++;

                    virtualUser Client = new virtualUser(connectionID, Request);
                }
            }
            catch { }
            _socketHandler.BeginAccept(new AsyncCallback(connectionRequest), _socketHandler);
        }
        /// <summary> 
        /// Flags a connection as free. 
        /// </summary> 
        /// <param name="connectionID">The ID of the connection.</param> 
        internal static void freeConnection(int connectionID)
        {
            if (_activeConnections.Contains(connectionID))
            {
                _activeConnections.Remove(connectionID);
                IO.WriteLine("Flagged connection [" + connectionID + "] as free.");
            }
        }
        /// <summary> 
        /// Gets or set an Integer for the maximum amount of connections at the same time. 
        /// </summary> 
        internal static int maxConnections
        {
            get
            {
                return _maxConnections;
            }
            set
            {
                _maxConnections = value;
            }
        }
        internal static int acceptedConnections
        {
            /// <summary> 
            /// Returns as integer of the accepted connections count since init. 
            /// </summary> 
            get { return _acceptedConnections; }
        }
    }
}