using Articulate_Network.Events;
using Articulate_Network.Interfaces;
using Articulate_Network.Managers;
using Articulate_Network.Packets;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace Articulate_Network
{
    public class Server
    {
        List<IManager> managers = new List<IManager>();
        TcpClient[] clients = new TcpClient[300];

        TcpListener tcpListener;

        public Server()
        {
            InitializeManagers();
        }

        public async Task<bool> Start(string ip, int port)
        {
            tcpListener = new TcpListener(IPAddress.Parse(ip), port);

            bool connected = await Task.Run(async () =>
            {
                try
                {
                    tcpListener.Start();

                    _ = HandleConnections();

                    return true;
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                    return false;
                }
            }
            );

            return false;
        }

        public async Task HandleConnections()
        {
            while (true)
            {
                var client = await tcpListener.AcceptTcpClientAsync();

                for (int i = 0; i < clients.Length; i++)
                    if (clients[i] == null)
                    {
                        clients[i] = client;
                        Console.WriteLine($"Client {i + 1} connected from {(client.Client.RemoteEndPoint as IPEndPoint).Address}.");
                        break;
                    }

                _ = ReceiveData(client);

                OnClientConnected(new ClientConnectedEventArgs() { TcpClient = client });
            }
        }

        /*public async Task<bool> ReceiveData(TcpClient client)
        {
            await Task.Run(() =>
            {
                byte[] buffer = new byte[8192];
                var ms = new MemoryStream(buffer);
                var br = new BinaryReader(ms);

                while (client.Connected)
                {
                    try
                    {
                        int bytesToRead = client.Client.Receive(buffer, buffer.Length, SocketFlags.None);

                        ms.Position = 0;

                        while (ms.Position < bytesToRead)
                        {
                            int length = (int)br.ReadInt64();

                            OnDataReceived(new Articulate_Network.Events.DataReceivedEventArgs()
                            {
                                Packet = Get<PacketManager>().DeserializePacket(ms),
                                Client = client
                            });

                            int end = (int)br.ReadInt64();
                        }
                    }
                    catch (SocketException e)
                    {

                    }
                }
            });

            return false;
        }*/

        public async Task<bool> ReceiveData(TcpClient client)
        {
            await Task.Run(() =>
            {
                byte[] buffer = new byte[16384];
                int offset = 0;

                while (client.Connected)
                {
                    try
                    {
                        int bytesToRead = client.Client.Receive(buffer, offset, buffer.Length - offset, SocketFlags.None);

                        if (bytesToRead == 0)
                        {
                            Console.WriteLine("No data.");
                            continue;
                        }

                        var ms = new MemoryStream(buffer);
                        var br = new BinaryReader(ms);

                        if (offset > 0)
                            offset = 0;

                        while (ms.Position < ms.Length)
                        {
                            br.ReadInt32();
                            int length = (int)br.ReadInt64();
                            if (length < 0)
                                break;

                            if (ms.Position + length > ms.Length)
                            {
                                ms.Position -= 8;

                                buffer = new byte[16384];

                                offset = (int)(ms.Length - ms.Position);

                                ms.Read(buffer, 0, offset);

                                break;
                            }
                            ms.Position += length;

                            int end = (int)br.ReadInt64();

                            ms.Position -= 8;

                            if (length == end && length < 1)
                                break;

                            ms.Position -= length;

                            var p = Get<PacketManager>().DeserializePacket(ms);

                            OnDataReceived(new Articulate_Network.Events.DataReceivedEventArgs()
                            {
                                Packet = p,
                                Client = client
                            });

                            br.ReadInt64();
                        }
                    }
                    catch (SocketException e)
                    {
                        Console.WriteLine("Client disconnected.");
                    }
                }
            });

            return false;
        }

        public async Task<bool> SendPacket(TcpClient tcpClient, Packet packet)
        {
            await Task.Run(() =>
            {
                byte[] buffer = Get<PacketManager>().SerializePacket(packet);

                int sentBytes = tcpClient.Client.Send(buffer, buffer.Length, SocketFlags.None);

                if (sentBytes == 0)
                    Console.WriteLine($"Sent: {sentBytes}");
            });

            return false;
        }

        public void InitializeManagers()
        {
            var @interface = typeof(IManager);

            foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
            {
                var managersFound = assembly.GetTypes().Where(t => @interface.IsAssignableFrom(t) && !t.IsAbstract);

                foreach (var m in managersFound)
                {
                    var manager = (IManager)Activator.CreateInstance(m);

                    manager.Initialize();

                    managers.Add(manager);
                }
            }

            Console.WriteLine($"Initialized {managers.Count} manager{(managers.Count > 1 ? "s" : "")}");
        }

        public T Get<T>()
        {
            return (T)managers.SingleOrDefault(t => typeof(T) == t.GetType());
        }

        protected virtual void OnClientConnected(ClientConnectedEventArgs e)
        {
            EventHandler<ClientConnectedEventArgs> handler = ClientConnected;

            if (handler != null)
                handler(this, e);
        }

        public event EventHandler<ClientConnectedEventArgs> ClientConnected;

        protected virtual void OnDataReceived(Articulate_Network.Events.DataReceivedEventArgs e)
        {
            EventHandler<Articulate_Network.Events.DataReceivedEventArgs> handler = DataReceived;

            if (handler != null)
                handler(this, e);
        }

        public event EventHandler<Articulate_Network.Events.DataReceivedEventArgs> DataReceived;
    }
}