using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;


using Google.Protobuf;


using ServerCore; using ServerBase;


namespace ServerBase;


//=============================================================================================
// 패킷 송신 관리자
//
// author : kangms
// 
//=============================================================================================

public class PacketSender
{
	private readonly ISession m_owner;
	private readonly Dictionary<IPacketCommand, PacketSendHandler> m_packet_send_handlers = new();

	public PacketSender(ISession session)
	{
		m_owner = session;
	}

	public async Task<bool> registerSendHandlerAll()
	{
        var assemblies = AppDomain.CurrentDomain.GetAssemblies();

        return await Task.Run(() =>
        {
			foreach (var assembly in assemblies)
			{
				foreach (Type type in assembly.GetTypes())
				{
					var custom_attribs = (PacketHandlerAttribute[])type.GetCustomAttributes(typeof(PacketHandlerAttribute), false);
					if (custom_attribs.Length <= 0)
					{
						continue;
					}

					foreach (var each in custom_attribs)
					{
						if (false == hasNamespace(type.Namespace, each.getPacketCommand()))
						{
							break;
						}

						if (false == m_owner.GetType().Equals(each.getHandlerOwner()))
						{
							break;
						}

						var packet_command = each.getPacketCommand();
						if (false == isValidPacketSendHandler(each.getHandlerClass()))
						{
							break;
						}

						if (true == hasSendHandler(packet_command))
						{
							Log.getLogger().error($"Already register PacketCommand !!! : packetCommnad:{packet_command.toBasicString()}");
							return false;
						}

						var handler_class = Activator.CreateInstance(each.getHandlerClass()) as PacketSendHandler;
						if (null == handler_class)
						{
							Log.getLogger().error($"Failed to create PacketSendHandler !!! : packetCommnad:{packet_command.toBasicString()}");
							return false;
						}

						registerSendHandler(packet_command, handler_class);
						break;
					}
				}
			}

			if (0 >= m_packet_send_handlers.Count)
			{
				Log.getLogger().warn($"No PacketSendHandler registered !!!");
			}

			return true;
		});
	}

	public bool registerSendHandler(IPacketCommand packetCommand, PacketSendHandler toRegisterSendHandler)
	{
		if (true == m_packet_send_handlers.ContainsKey(packetCommand))
		{
			Log.getLogger().error($"Already registered Send Handler !!! : {packetCommand.toBasicString()}");
			return false;
		}

		m_packet_send_handlers.Add(packetCommand, toRegisterSendHandler);
		return true;
	}


	public bool isValidPacketSendHandler(Type pakcetSendHandler)
	{
		if(false == pakcetSendHandler.IsSubclassOf(typeof(PacketSendHandler)))
		{
			return false;
		}

		return true;
	}

	public PacketSendHandler? findSendHandler(IPacketCommand packetCommand)
	{
		if (false == m_packet_send_handlers.ContainsKey(packetCommand))
		{
			return null;
		}

		return m_packet_send_handlers[packetCommand];
	}

	public bool hasSendHandler(IPacketCommand packetCommand)
	{
		if (true == m_packet_send_handlers.ContainsKey(packetCommand))
		{
			return true;
		}

		return false;
	}

	public bool hasNamespace(string? toCheckNamespace, IPacketCommand packetCommand)
	{
		string packet_handler_namespace = "PacketHandler";

            if (   null != toCheckNamespace
                && true == toCheckNamespace.Contains(packet_handler_namespace))
            {
                return true;
            }
            else
            {
                ServerCore.Log.getLogger().error($"Invalid Namespace !!! : {packet_handler_namespace} != {toCheckNamespace}, packetCommnad:{packetCommand.toBasicString()}");
            }

		return false;
	}

	public static bool isEqualPacket<T>(Google.Protobuf.IMessage recvMessage)
		where T : class
	{
		if(false == typeof(T).Equals(recvMessage))
		{
			return false;
		}

		return true;
	}
}