BadNetworkConsoleClient.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
 
using BadScript2.ConsoleAbstraction.Implementations.Remote.Client.Commands;
using BadScript2.ConsoleAbstraction.Implementations.Remote.Packets;
 
namespace BadScript2.ConsoleAbstraction.Implementations.Remote.Client;
 
public class BadNetworkConsoleClient
{
    private readonly string m_Address;
 
    private readonly TcpClient m_Client;
 
    private readonly IBadNetworkConsoleClientCommandParser m_Parser;
 
 
    private readonly int m_Port;
 
    private bool m_ExitRequested;
 
    private Thread? m_ReadThread;
 
    public BadNetworkConsoleClient(TcpClient client, Func<BadNetworkConsoleClient, IBadNetworkConsoleClientCommandParser> parserFactory)
    {
        m_Client = client;
        m_Address = "";
        m_Port = -1;
        m_Parser = parserFactory(this);
    }
 
    public BadNetworkConsoleClient(TcpClient client) : this(client, DefaultParserFactory) { }
 
    public BadNetworkConsoleClient(string address, int port) : this(address, port, DefaultParserFactory) { }
 
    public BadNetworkConsoleClient(string address, int port, Func<BadNetworkConsoleClient, IBadNetworkConsoleClientCommandParser> parserFactory)
    {
        m_Address = address;
        m_Port = port;
        m_Client = new TcpClient();
        m_Parser = parserFactory(this);
    }
 
    public static int HeartBeatSendInterval { get; set; } = 3000;
 
    public static int ConsoleReadInputSleep { get; set; } = 100;
 
    public static int ConsoleWriteSleep { get; set; } = 100;
 
    public static IBadNetworkConsoleClientCommandParser DefaultParserFactory(BadNetworkConsoleClient client)
    {
        BadDefaultNetworkClientCommandParser parser = new BadDefaultNetworkClientCommandParser(client);
        parser.AddCommand(c => new BadNetworkConsoleClientDisconnectCommand(c));
        parser.AddCommand(_ => new BadNetworkConsoleClientListCommand(parser));
 
        return parser;
    }
 
 
    public void Start()
    {
        m_ExitRequested = false;
        BadConsole.WriteLine($"[Console Client] Connecting to {m_Address}:{m_Port}");
 
        if (!m_Client.Connected)
        {
            m_Client.Connect(m_Address, m_Port);
        }
 
        BadConsole.WriteLine("[Console Client] Connected");
 
 
        m_ReadThread = new Thread(Write);
        m_ReadThread.Start();
        Read();
    }
 
    public void Stop()
    {
        m_ExitRequested = true;
    }
 
    private void ProcessPacket(BadConsolePacket packet)
    {
        switch (packet)
        {
            case BadConsoleClearPacket:
                Console.Clear();
 
                break;
            case BadConsoleDisconnectPacket:
                m_ExitRequested = true;
 
                break;
            case BadConsoleHelloPacket hello:
                HeartBeatSendInterval = hello.HeartBeatInterval;
 
                break;
            case BadConsoleWritePacket { IsWriteLine: true } wp:
                Console.WriteLine(wp.Message);
 
                break;
            case BadConsoleWritePacket wp:
                Console.Write(wp.Message);
 
                break;
            case BadConsoleColorChangePacket { IsBackground: true } cs:
                Console.BackgroundColor = cs.Color;
 
                break;
            case BadConsoleColorChangePacket cs:
                Console.ForegroundColor = cs.Color;
 
                break;
            default:
                throw new BadNetworkConsoleException("Invalid Packet");
        }
    }
 
    private void Read()
    {
        while (!m_ExitRequested)
        {
            if (!m_Client.Connected)
            {
                break;
            }
 
            if (m_Client.Available != 0)
            {
                byte[] len = new byte[sizeof(int)];
                NetworkStream stream = m_Client.GetStream();
                int read = stream.Read(len, 0, len.Length);
 
                if (read != len.Length)
                {
                    throw new BadNetworkConsoleException("Invalid Packet Size");
                }
 
                byte[] packet = new byte[BitConverter.ToInt32(len, 0)];
                read = stream.Read(packet, 0, packet.Length);
 
                if (read != packet.Length)
                {
                    throw new BadNetworkConsoleException("Invalid Packet");
                }
 
                ProcessPacket(BadConsolePacket.Deserialize(packet));
            }
            else
            {
                Thread.Sleep(ConsoleWriteSleep);
            }
        }
 
        if (!m_Client.Connected)
        {
            return;
        }
 
        NetworkStream str = m_Client.GetStream();
        List<byte> packetData = new List<byte>();
        byte[] packetBytes = BadConsoleDisconnectPacket.Packet.Serialize();
        packetData.AddRange(BitConverter.GetBytes(packetBytes.Length));
        packetData.AddRange(packetBytes);
        str.Write(packetData.ToArray(), 0, packetData.Count);
        m_Client.Dispose();
    }
 
    private void SendHeartBeat()
    {
        byte[] packetData = BadConsoleHeartBeatPacket.Packet.Serialize();
        List<byte> packet = new List<byte>();
        packet.AddRange(BitConverter.GetBytes(packetData.Length));
        packet.AddRange(packetData);
        m_Client.GetStream().Write(packet.ToArray(), 0, packet.Count);
    }
 
    private void Write()
    {
        DateTime lastHeartBeat = DateTime.Now;
 
        while (!m_ExitRequested)
        {
            Task<string> task = Task.Run(Console.ReadLine);
 
            while (!m_ExitRequested && !task.IsCompleted)
            {
                if (lastHeartBeat + TimeSpan.FromMilliseconds(HeartBeatSendInterval) < DateTime.Now)
                {
                    SendHeartBeat();
                    lastHeartBeat = DateTime.Now;
                }
 
                Thread.Sleep(ConsoleReadInputSleep);
            }
 
            if (m_ExitRequested)
            {
                break;
            }
 
            string message = task.Result ?? "client::disconnect";
 
            if (message.StartsWith("client::"))
            {
                string cmd = message.Substring("client::".Length);
                m_Parser.ExecuteCommand(cmd);
 
                continue;
            }
 
            lastHeartBeat = DateTime.Now;
            byte[] packetData = new BadConsoleReadPacket(message).Serialize();
            List<byte> packet = new List<byte>();
            packet.AddRange(BitConverter.GetBytes(packetData.Length));
            packet.AddRange(packetData);
            m_Client.GetStream().Write(packet.ToArray(), 0, packet.Count);
        }
 
        m_ReadThread = null;
    }
}