using Articulate_Network.Interfaces;
using Articulate_Network.Managers;
using System;
using System.Collections.Generic;
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>();

        TcpListener tcp;

        public Server()
        {
            InitializeManagers();

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

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

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

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

            return false;
        }

        public async Task<bool> SendPacket(IPacket packet)
        {
            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);
                }
            }
        }

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