using Articulate_Network.Interfaces;
using Articulate_Network.Managers;
using Articulate_Network.Packets;
using System;
using System.Collections.Generic;
using System.Diagnostics;
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 Client
    {
        List<IManager> managers = new List<IManager>();
        int bufferSize = 16384;

        TcpClient tcp;

        public Client()
        {
            InitializeManagers();

            tcp = new TcpClient()
            {
                SendBufferSize = bufferSize,
                ReceiveBufferSize = bufferSize
            };
        }

        public async Task<TcpClient> Connect(string ip, int port)
        {
            return await Task.Run(() =>
                {
                    try
                    {
                        tcp.Connect(ip, port);

                        tcp.SendBufferSize = bufferSize;
                        tcp.ReceiveBufferSize = bufferSize;

                        _ = ReceiveData();

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

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

                tcp.Client.Send(buffer, buffer.Length, SocketFlags.None);
            });

            return false;
        }

        public async Task<bool> ReceiveData()
        {
            await Task.Run(() =>
            {
                byte[] buffer = new byte[bufferSize];

                int offset = 0;

                while (true)
                {
                    int bytesToRead = tcp.Client.Receive(buffer, offset, buffer.Length - offset, SocketFlags.None);

                    //Console.WriteLine("Bytes to read: " + bytesToRead);

                    var ms = new MemoryStream(buffer, 0, bytesToRead);
                    var br = new BinaryReader(ms);

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

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

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

                        bool endOfPacket = end == length;

                        if (endOfPacket && ms.Position < ms.Length)
                        {
                            int nextPacketSize = (int)br.ReadInt64();

                            ms.Position -= 8;

                            Console.WriteLine("Next size: " + nextPacketSize);

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

                            buffer = new byte[bufferSize];

                            ms.Read(buffer, 0, offset);

                            break;
                        }

                        //Console.WriteLine(ms.Position);

                        /*if (ms.Position + length > ms.Length)
                        {
                            Console.WriteLine("Bytes to read: " + bytesToRead);
                            Console.WriteLine("Memory length: " + ms.Length);
                            Console.WriteLine("Memory Pos: " + ms.Position);
                            Console.WriteLine("Length: " + length);
                            ms.Position -= 8;

                            buffer = new byte[bufferSize];

                            ms.Read(buffer, 0, offset);
                            break;
                        }*/
                    }
                }
            });

            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 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;
    }
}