namespace ServerLib
{
    using System;
    using System.Collections.Generic;
    using System.Net;
    using System.Net.Sockets;

    internal static class Log
    {
        internal static void Message(string message)
        {
            WriteToConsole(ConsoleColor.White, "MSG", message);
        }
        internal static void Error(string message)
        {
            WriteToConsole(ConsoleColor.Red, "ERR", message);
        }

        private static void WriteToConsole(ConsoleColor fontColor, string level, string message)
        {
            Console.ForegroundColor = fontColor;
            Console.WriteLine($"{DateTime.Now.ToShortDateString()} {DateTime.Now.ToShortTimeString()}| [{level}] |>> {message}");
            Console.ResetColor();
        }
    }

    public enum ServerState
    {
        Undef,
        Started,
        Stopped
    }

    public interface IServer
    {
        public ServerState State { get; }
        public void Start();
        public void Stop();
    }

    public interface IAcceptor
    {
        public event Action<Socket> ClientAccepted;
        public bool IsStarted { get; }
        public void Start();
        public void Stop();
    }

    public interface IHandler
    {
        public event Action<Socket> ClientDisconnected;
        public event Action<Socket, IMessage> ClientMessageAccepted;
        public event Action<Socket, IMessage> ClientMessageSended;

        public void Handle(Socket clientSocket);
    }

    public interface IMessage
    {
        public int Length { get; }
    }

    public class SocketAcceptor : IAcceptor
    {
        private readonly string _host;
        private readonly int _port;

        public SocketAcceptor(string host, int port)
        {
            _host = host;
            _port = port;
        }
        public bool IsStarted { get; private set; }

        public event Action<Socket> ClientAccepted;

        public void Start()
        {
            if (IsStarted) throw new InvalidOperationException("Acceptor alrady started");
            IsStarted = true;
            AcceptLoop();
        }
        public async void Stop()
        {
            if (!IsStarted) throw new InvalidOperationException("Acceptor not started");

            IsStarted = false;
        }

        private async void AcceptLoop()
        {
            Socket acceptor = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            acceptor.Bind(new IPEndPoint(IPAddress.Parse(_host), _port));
            acceptor.Listen(100);
            try
            {
#if DEBUG
                Log.Message($"Start accept on {acceptor.LocalEndPoint}");
#endif
                while (IsStarted)
                {
                    Socket clientSocket = await acceptor.AcceptAsync();
#if DEBUG
                    Log.Message($"Accepted client {clientSocket.RemoteEndPoint}");
#endif
                    ClientAccepted?.Invoke(clientSocket);
                }
            }
            finally
            {
                try
                {
                    acceptor.Shutdown(SocketShutdown.Both);
                }
                finally
                {
                    acceptor.Close();
                }
            }

        }
    }

    public class EchoHandler : IHandler
    {
        public event Action<Socket> ClientDisconnected;
        public event Action<Socket, IMessage> ClientMessageAccepted;
        public event Action<Socket, IMessage> ClientMessageSended;

        internal class RawMsg : IMessage
        {
            public int Length { get; set; }
        }
        public async void Handle(Socket clientSocket)
        {
            if(clientSocket.Connected)
            {
                Memory<byte> buffer = new byte[1024];
                while(clientSocket.Available > 0)
                {
                    int msgLen = await clientSocket.ReceiveAsync(buffer, SocketFlags.None);
                    ClientMessageAccepted?.Invoke(clientSocket, new RawMsg { Length = msgLen });

                    await clientSocket.SendAsync(buffer.Slice(0, msgLen), SocketFlags.None);
                    ClientMessageSended?.Invoke(clientSocket, new RawMsg { Length = msgLen });
                }
            }
            clientSocket.Shutdown(SocketShutdown.Both);
            clientSocket.Close();
            ClientDisconnected?.Invoke(clientSocket);
        }
    }
    public class ServerBase : IServer
    {
        private readonly HashSet<Socket> _clients;
        private readonly IAcceptor _acceptor;
        private readonly IHandler _handler;

        public ServerBase(IAcceptor acceptor, IHandler handler)
        {
            _acceptor = acceptor ?? throw new ArgumentNullException(nameof(acceptor));
            _handler = handler ?? throw new ArgumentNullException(nameof(handler));
            _clients = new HashSet<Socket>();
        }

        #region IServer


        //-----------------------------------------------------------------------------------------

        public ServerState State { get; private set; }

        //-----------------------------------------------------------------------------------------

        public void Start()
        {
            if(State == ServerState.Started) throw new InvalidOperationException("Server alrady started.");
            SubscribeOnHandlerEvents();
            StartAccepor();
            State = ServerState.Started;
        }

        //-----------------------------------------------------------------------------------------

        public void Stop()
        {
            if(State != ServerState.Started) throw new InvalidOperationException("Server not started.");
            UnsubscribeOnHandlerEvents();
            StopAcceptor();
            State = ServerState.Stopped;
        }

        //-----------------------------------------------------------------------------------------

        #endregion IServer

        protected virtual void OnCleintSocketAccpeted(Socket clientSocket)
        {
            RegisterClient(clientSocket);
            _handler.Handle(clientSocket);
        }

        // Эти методы не должны использоваться для того чтобы закрывать сокеты или какую-то еще работу c клиентами производить,
        // все это должно происходить в IHandler
        // Данные методы должны использоваться для логгирования, ведения статистики и т.д.

        protected virtual void OnMessageAccepted(Socket clientSocket, IMessage message)
        {
            Log.Message($"{clientSocket.RemoteEndPoint} accepted {message.Length} bytes");
        }
        protected virtual void OnMessageSended(Socket clientSocket, IMessage message)
        {
            Log.Message($"{clientSocket.RemoteEndPoint} sended {message.Length} bytes");

        }
        protected virtual void OnClientDisconnected(Socket clientSocket)
        {
            //Log.Message($"{clientSocket.RemoteEndPoint} disconnected");
            UnregisterClient(clientSocket);
        }


        private void RegisterClient(Socket clientSocket)
        {
            _clients.Add(clientSocket);
        }
        private void UnregisterClient(Socket clientSocket)
        {
            _clients.Remove(clientSocket);
        }
        private void StartAccepor()
        {
            _acceptor.ClientAccepted += OnCleintSocketAccpeted;
            _acceptor.Start();
        }
        private void StopAcceptor()
        {
            _acceptor.ClientAccepted -= OnCleintSocketAccpeted;
            _acceptor.Stop();
        }
        private void SubscribeOnHandlerEvents()
        {
            _handler.ClientMessageAccepted += OnMessageAccepted;
            _handler.ClientMessageSended += OnMessageSended;
            _handler.ClientDisconnected += OnClientDisconnected;
        }
        private void UnsubscribeOnHandlerEvents()
        {
            _handler.ClientMessageAccepted -= OnMessageAccepted;
            _handler.ClientMessageSended -= OnMessageSended;
            _handler.ClientDisconnected -= OnClientDisconnected;
        }
    }
}