using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Slice;
using CommonNetwork_ICE.Common;
using CommonServer.Server;
using CommonServer_ICE.Session;
using CommonServer.Protocol;
using CommonLang.Protocol;
using CommonNetwork_ICE.Util;
using CommonServer_ICE.Server;
using CommonLang.Log;

namespace CommonServer_ICE.Msg
{
    /// <summary>
    /// ICE消息委托处理接口
    /// </summary>
    internal abstract class ServerMsgHandler
    {
        private static Logger log = LoggerFactory.GetLogger("ServerMsgHandler");

        public ServerMsgHandler()
        {
        }

        /// <summary>
        /// 获取通讯类型
        /// </summary>
        public abstract IceConnectServer getServer();

        /// <summary>
        /// 处理收到客户端发来的关键数据包
        /// </summary>
        /// <param name="recvPort">发送方侦听端口</param>
        /// <param name="message">数据包</param>
        /// <param name="ip">发送方IP</param>
        /// <param name="port">发送方端口</param>
        public abstract void RecvData(int recvPort, TransMessage message, string ip, int port);

        /// <summary>
        /// 处理收到客户端发来的关键数据包确认序列号
        /// </summary>
        /// <param name="recvPort">发送方侦听端口</param>
        /// <param name="serial">序列号</param>
        /// <param name="ip">发送方IP</param>
        /// <param name="port">发送方端口</param>
        public abstract void SendDataRecvAck(int recvPort, long serial, string ip, int port);

        /// <summary>
        /// 处理客户端连接到服务器，回发连接响应
        /// </summary>
        /// <param name="recvPort">发送方侦听端口</param>
        /// <param name="ip">发送方IP</param>
        /// <param name="port">发送方端口</param>
        public void Connect(int recvPort, string ip, int port)
        {
            log.Info("收到客户端发来请求连接，地址IP【" + ip + "】，端口【" + port + "】，发送方侦听端口【" + recvPort + "】");
            if (SessionManager.hasSession(ip, port, recvPort))
            {
                // 已经连接，发送连接成功确认
                IceServerIoSession confirmSession = (IceServerIoSession)SessionManager.getSession(ip, port, recvPort);
                if (!confirmSession.IsConnected)
                {
                    confirmSession.IsConnected = true;
                    try
                    {
                        confirmSession.Sender.ConnectAck();
                    }
                    catch (Exception e)
                    {
                        confirmSession.HandleException(e);
                    }
                }
                else
                {
                    log.Error("非法的多次连接，不予处理，客户端地址IP【" + ip + "】，端口【" + port + "】，发送方侦听端口【" + recvPort + "】");
                }
                return;
            }
            IceConnectServer server = this.getServer();
            IceServerIoSession session = SessionManager.createSession(server, ip, port, recvPort);
            // 初始化Session的ICE发送
            IceConnector connector = new IceConnector(Constants.SEND_INTERFACE_NAME, Constants.SERVER_SENDER_RECV_ADAPTER, ip, recvPort, server.getServerConfig().Ip, server.getServerConfig().Port);
            try
            {
                IceInit.InitIceSender(server.getCommType(), connector);
            }
            catch (Exception e)
            {
                session.HandleException(e);
                return;
            }
            if (connector.SenderConnector == null)
            {
                log.Error("初始化服务器端发送器异常，创建Session不成功，客户端地址IP【" + ip + "】，端口【" + port + "】，发送方侦听端口【" + recvPort + "】");
                return;
            }
            session.Connector = connector;
            session.Sender = connector.Sender;

            // 启用Session
            session.IsConnected = true;
            // 发送连接成功确认
            try
            {
                server.OnNewSessionConnected(session);
                session.OnSessionStarted();
                session.Sender.ConnectAck();
            }
            catch (Exception e)
            {
                session.HandleException(e);
            }
        }

        /// <summary>
        /// 服务器发送连接成功响应
        /// </summary>
        /// <param name="ip">发送方IP</param>
        /// <param name="port">发送方端口</param>
        public void ConnectAck(string ip, int port)
        {
        }

        /// <summary>
        /// 处理客户端发出关闭会话请求，服务器
        /// </summary>
        /// <param name="recvPort">发送方侦听端口</param>
        /// <param name="ip">发送方IP</param>
        /// <param name="port">发送方端口</param>
        public void Close(int recvPort, string ip, int port)
        {
            log.Info("收到客户端发来关闭连接请求，地址IP【" + ip + "】，端口【" + port + "】，发送方侦听端口【" + recvPort + "】");
            IceServerIoSession session = (IceServerIoSession)SessionManager.getSession(ip, port, recvPort);
            if (session != null)
            {
                try
                {
                    session.Sender.CloseAck(recvPort);
                }
                catch (Exception e)
                {
                    session.HandleException(e);
                }
                // 发送关闭确认响应
                session.Disconnect(true);
            }
            else
            {
                log.Error("非法的关闭命令，客户端地址IP【" + ip + "】，端口【" + port + "】，发送方侦听端口【" + recvPort + "】");
                return;
            }
        }

        /// <summary>
        /// 处理服务器主动关闭会话，客户端回发关闭连接响应
        /// </summary>
        /// <param name="recvPort">发送方侦听端口</param>
        /// <param name="ip">发送方IP</param>
        /// <param name="port">发送方端口</param>
        public void CloseAck(int recvPort, string ip, int port)
        {
            log.Info("收到客户端发来关闭成功响应，地址IP【" + ip + "】，端口【" + port + "】，发送方侦听端口【" + recvPort + "】");
            IceServerIoSession session;
            if (SessionManager.hasSession(ip, port, recvPort))
            {
                session = (IceServerIoSession)SessionManager.getSession(ip, port, recvPort);
                session.Disconnect(true);
            }
            else
            {
                log.Error("非法的关闭响应命令，客户端地址IP【" + ip + "】，端口【" + port + "】，发送方侦听端口【" + recvPort + "】");
                return;
            }
        }
    }
}