Remote_Board_Game/RBG_Server.Core/CommunicationHandler.cs

using NATUPNPLib;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

namespace RBG_Server
{
    /// <summary>
    /// Contains all communication data, from both the client's and server's perspective (should be able to switch between each mode as necessary)
    /// </summary>
    /// 
    public class CommunicationHandler
    {
        UPnPNAT upnpnat = new();
        IStaticPortMapping portMapping;
        

        /// <summary>
        /// Image data is stored in memory in a dictionary collection. Each byte[] represents an image file, compressed according to its file type;
        /// which helps save space in memory. Uses a CachedByteArray; essentially a normal byte array but automatically stored on disk if it is larger
        /// than a set size.
        /// This limit can be changed at any time, if memory is required to be freed
        /// </summary>
        public ConcurrentDictionary<string, CachedByteArray> ImageCollection { get; } = new();

        public List<Player> Players {  get; } = new List<Player>();

        public List<string> ImageList {  get; } = new();

        public string BoardName { get; set; }

        public IPAddress IpAddress { get; set; }

        public short Port { get; set; }

        private TcpClient stateRetriever { get; set; }

        private TcpClient dataRetriever { get; set; }


        public int ColumnCount { get;private set; }

        public int RowCount { get;private set; }

        public int ColumnZoomStart { get;private set; }

        public int RowZoomStart { get;private set; }

        public int ColumnZoomSpan { get;private set; }

        public int RowZoomSpan { get;private set; }

        public int StartingColumn { get;private set; }

        public int StartingRow { get;private set; }

        public void InitialiseServer()
        {
            // Find the server's active (reliable) network adapter, by creating a remote connection and retrieving our IP from it:
            using (Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
            {
                s.Bind(new IPEndPoint(IPAddress.Any, 0));
                s.Connect("microsoft.com", 0);
                // The IP is implicitly the one assigned to the interface the OS would use to connect to the remote address
                IpAddress = (s.LocalEndPoint as IPEndPoint).Address;
            }
            // Create the upnp mapping
            upnpnat.StaticPortMappingCollection.Add(Port, "TCP", Port, IpAddress.ToString(), true, "RBGServer");

            TcpListener listener = new(IPAddress.Any, Port); // Allow local comms

            listener.Start();
            while (true)
            {
                TcpClient client = listener.AcceptTcpClient();
                // Delegate to another thread
                _ = Task.Run(() =>
                {
                    AcceptConnections(client);
                });
            }
        }

        private void AcceptConnections(TcpClient client)
        {
            // Handle actual connections here
            throw new NotImplementedException();
        }

        public void InitialiseClient(TcpClient client)
        {
            // At this point, no details about the game are loaded; we must load them from the server (to which we have already connected [no data should have been sent]).
            NetworkStream stateStream = stateRetriever.GetStream();
            Task stateLoader = new Task(async () =>
            {
                
            });
            


            NetworkStream dataStream = dataRetriever.GetStream();
            Task dataLoader = new Task(async () =>
            {
               
                // At this point, the minimal amount of work required by the data thread has been done (load all thumbs)
                // When an asset is needed from here, queue a load
            });

            // start the tasks; they should have 

            dataLoader.Start();
            stateLoader.Start();


            byte[] buffer = new byte[] {0,0,0,1,1};
            // Writing to the stream is to be considered near constant-time, but reading is non-constant.
            // This application model must be synchronous, but we execute other commands before expecting our response to have arrived (it can complete at any time in that period)
            stateStream.Write(buffer, 0, buffer.Length);
            buffer[0] = 1;
            buffer[3] = 0;
            dataStream.Write(buffer, 0, buffer.Length);
            // A details request is [<uint32, length>, <byte command>]
            // The response is about the same format:
            var stateResponse = GetResponse(stateStream, 4);
            var dataResponse = GetResponse(dataStream, 4);
            // First, load the board state (low mip-map, row definitions, column definitions, zoom position etc.)
            // Retrieval command for the board
            // Then load the player list, and use the low mip for their sprites
            // Then check each loaded image and load the med, then large, then full sprite
            // Then load the low of each unused image (for quick retrieval)
        }

        struct ProgressData
        {
            /// <summary>
            /// Current activity being processed
            /// </summary>
            public enum Activity
            {
                Idle,
                MessageSent,
                MessageReceived,
                ProcessingMessage,
                MessageProcessed,
                CollectionRecieved,
                // ----- Image stuffs
                ImageDownloaded,
                // ----- Gameplay stuffs
                Finished,
            }
            public Activity CurrentActivity;

            public int Progress;
        }

        /// <summary>
        /// Initialises data loader
        /// </summary>
        /// <param name="dataStream"></param>
        /// <param name="progressUpdates"></param>
        /// <returns></returns>
        private async Task InitDataLoader(NetworkStream dataStream, IProgress<ProgressData> progressUpdates)
        {
            byte[] buffer = new byte[] { 2, 0, 0, 0, 128, 0 }; // Get image collection names
            dataStream.Write(buffer, 0, buffer.Length);
            // Notify Data was sent
            progressUpdates.Report(new ProgressData()
            {
                CurrentActivity = ProgressData.Activity.MessageSent,
                Progress = 0,
            });
            var dataResponse = await GetResponse(dataStream, 4);
            // Notify Data was recieved
            progressUpdates.Report(new ProgressData()
            {
                CurrentActivity = ProgressData.Activity.MessageReceived,
                Progress = 1,
            });

            dataResponse = await GetResponse(dataStream, GetInt32(dataResponse));
            List<byte> data = new List<byte>();
            int start = 0;
            while (start < dataResponse.Length)
            {
                int pos = start;
                while (dataResponse[pos++] != 0) ;
                ImageList.Add(Encoding.UTF8.GetString(dataResponse[start..pos]));
                start = pos;
            }
            // Load all low-resolution images
            for (int i = 0; i < ImageList.Count; i++)
            {
                string item = ImageList[i];
                byte[] strBytes = Encoding.ASCII.GetBytes(item);
                buffer = new byte[strBytes.Length + 6];
                byte[] lenBytes = GetBytes(strBytes.Length + 6);
                lenBytes.CopyTo(buffer, 0);
                buffer[4] = 129; // Download image
                buffer[5] = 0; // mip_low
                strBytes.CopyTo(buffer, 6);
                dataStream.Write(buffer, 0, buffer.Length);
                // Read the length, then the data
                dataResponse = await GetResponse(dataStream);
                dataResponse = await GetResponse(dataStream, GetInt32(dataResponse));
                ImageCollection.TryAdd(item + "_mip_low", (CachedByteArray)dataResponse);
                progressUpdates.Report(new ProgressData()
                {
                    CurrentActivity = ProgressData.Activity.MessageReceived,
                    Progress = i,
                });
            }
        }

        private async Task InitGameLoader(NetworkStream stateStream, IProgress<ProgressData> progressUpdates)
        {
            // Get game board details
            byte[] buffer = new byte[] { 1, 0, 0, 0, 1 };
            stateStream.Write(buffer, 0, buffer.Length);
            // Response size
            var stateResponse = await GetResponse(stateStream, 4);
            // Response data
            stateResponse = await GetResponse(stateStream, GetInt32(stateResponse)); // Get the full response data
                                                                                     // Board state data
            int playerID = GetInt32(stateResponse[..4]);
            ColumnCount = GetInt32(stateResponse[..8]);
            RowCount = GetInt32(stateResponse[8..12]);
            ColumnZoomStart = GetInt32(stateResponse[12..16]);
            RowZoomStart = GetInt32(stateResponse[16..20]);
            ColumnZoomSpan = GetInt32(stateResponse[20..24]);
            RowZoomSpan = GetInt32(stateResponse[24..28]);
            StartingColumn = GetInt32(stateResponse[28..32]);
            StartingRow = GetInt32(stateResponse[32..36]);
            // Basic board data loaded; fetch players
            buffer = new byte[] { 1, 0, 0, 0, 2 };
            stateStream.Write(buffer, 0, buffer.Length);
            stateResponse = await GetResponse(stateStream, 4);
            stateResponse = await GetResponse(stateStream, GetInt32(stateResponse));
            // state response contains a player list;
            // Player ID (Int32)
            // Player Name (null-terminated string)
            // Player Sprite (null-terminated string)
            // Player Column (Int32)
            // Player Row (Int32)
            int start = 0;
            while (start < stateResponse.Length)
            {

                int pos = start + 4;
                int responsePlayerID = GetInt32(stateResponse[start..pos]);
                start = pos;
                while (stateResponse[pos++] != 0) ; // skip the bytes that aren't null
                string responsePlayerName = Encoding.UTF8.GetString(stateResponse[start..pos]);
                start = pos;
                while (stateResponse[pos++] != 0) ; // skip the bytes that aren't null
                string responsePlayerSprite = Encoding.UTF8.GetString(stateResponse[start..pos]);
                start = pos;
                pos += 4;
                int playerColumn = GetInt32(stateResponse[start..pos]);
                start = pos;
                pos += 4;
                int playerRow = GetInt32(stateResponse[start..pos]);
                start = pos;
                Player player = new Player(responsePlayerName, responsePlayerSprite, playerRow, playerColumn);
                Players.Add(player);
            }
        }

        /// <summary>
        /// Idea is that each response is prefaced by a 4 byte stream length specifier.
        /// This requires a busy wait to achieve, if not all recieved at once.
        /// We retrieve the 
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="targetLength"></param>
        /// <returns></returns>
        private async Task<byte[]> GetResponse(NetworkStream stream, int targetLength=4)
        {
            if (stream.CanRead)
            {
                byte[] buffer = new byte[targetLength];
                int numberOfBytesRead = 0;

                // Incoming message may be larger than the buffer size.
                do
                {
                    numberOfBytesRead += await stream.ReadAsync(buffer.AsMemory(numberOfBytesRead, targetLength - numberOfBytesRead));
                }
                while (numberOfBytesRead < targetLength);
                return buffer;
            }
            return Array.Empty<byte>();
        }

        static internal byte[] GetBytes(int i)
        {
            byte[] bytes = BitConverter.GetBytes(i);
            if (BitConverter.IsLittleEndian)
            {
                // We need data in big-endian format; so reverse the array
                Array.Reverse(bytes);
            }
            return bytes;
        }

        static internal int GetInt32(byte[] bytes)
        {
            if (BitConverter.IsLittleEndian)
            {
                // We need data in little-endian format; so reverse the array
                Array.Reverse(bytes);
            }
            return BitConverter.ToInt32(bytes, 0);
        }
    }
}