using STcpHelper.Packet;
using System.Net;
using System.Net.Sockets;
using System.Text;

namespace STcpHelper
{
    public class STcpServer
    {
        private CancellationTokenSource _cts;

        private List<TcpClient> _clients;

        private readonly int HEADER_SIZE = 4;
        private readonly int BUFFER_SIZE;
        private int _port;

        private TcpListener _listener;

        public event EventHandler<string> MessageCallback;
        public event EventHandler<Exception> ErrorCallback;

        public STcpServer(int port, int bufferSize = 1024)
        {
            _port = port;
            BUFFER_SIZE = bufferSize;
            _clients = new List<TcpClient>();
        }

        public async void Start()
        {
            _listener = new TcpListener(IPAddress.Parse("127.0.0.1"), _port);
            _listener.Start();
            WriteMessage("Server start...");

            _cts = new CancellationTokenSource();
            while (true)
            {
                if (_cts.IsCancellationRequested)
                    break;

                TcpClient client = await _listener.AcceptTcpClientAsync();
                _clients.Add(client);
                WriteMessage($"Client accepted({client.Client.RemoteEndPoint.ToString()})");


                _cts = new CancellationTokenSource();
                _ = Task.Run(async () =>
                {
                    using (NetworkStream stream = client.GetStream())
                    {
                        byte[] headerBuffer = new byte[HEADER_SIZE];
                        byte[] dataBuffer = new byte[BUFFER_SIZE];
                        try
                        {
                            while (true)
                            {
                                int headerBytesRead = await stream.ReadAsync(headerBuffer, 0, HEADER_SIZE);
                                if (headerBytesRead != 4)
                                {
                                    WriteError(new Exception("Cannot read header"));
                                    return;
                                }

                                STcpPacketHeader header = new STcpPacketHeader(headerBuffer);
                                short dataSize = header.DataLength;
                                int totalRecv = 0;
                                while (totalRecv < dataSize)
                                {
                                    int dataBytesRead = await stream.ReadAsync(dataBuffer, totalRecv, dataSize - totalRecv);
                                    totalRecv += dataBytesRead;
                                }

                                if (header.Type == PacketType.TEXT)
                                {
                                    STcpTextPacket packet = new STcpTextPacket(dataBuffer);
                                    WriteMessage($"[{client.Client.RemoteEndPoint.ToString()}] Type: {header.Type.ToString()}");

                                    // Broadcast
                                    BroadcastMessage(packet.Text, client);

                                }

                                if (!IsClientConnected(client))
                                    break;
                            }
                        }
                        catch (Exception ex)
                        {
                            WriteError(ex);
                        }

                        WriteMessage($"Client disconnected({client.Client.RemoteEndPoint.ToString()})");
                        client.Close();
                        _clients.Remove(client);
                    }
                }, _cts.Token);
            }
        }

        public void Stop()
        {
            _cts.Cancel();
        }

        private byte[] MakeTextPacket(string text)
        {
            STcpTextPacket packet = new STcpTextPacket(text);
            return packet.Serialize();
        }

        private void BroadcastMessage(string message, TcpClient sender)
        {
            byte[] resonseByte = MakeTextPacket(message);
            foreach (TcpClient client in _clients)
            {
                if (client != sender && IsClientConnected(client))
                    client.GetStream().WriteAsync(resonseByte, 0, resonseByte.Length);
            }
        }

        private bool IsClientConnected(TcpClient client)
        {
            try
            {
                if (client != null &&
                    client.Client != null &&
                    client.Client.Connected)
                    return true;
            }
            catch (Exception ex)
            {
                WriteError(ex);
            }

            return false;
        }

        private void WriteMessage(string message)
        {
            if (this.MessageCallback != null)
                this.MessageCallback(this, message);
        }

        private void WriteError(Exception ex)
        {
            if (this.ErrorCallback != null)
                this.ErrorCallback(this, ex);
        }
    }
}