using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;
using NewLife.Exceptions;
using NewLife.Net.Common;
using NewLife.Net.Sockets;

namespace NewLife.Net.Proxy
{
    /// <summary>代理会话</summary>
    /// <typeparam name="TProxy">实际代理类型</typeparam>
    /// <typeparam name="TProxySession">代理会话类型</typeparam>
    public class ProxySession<TProxy, TProxySession> : ProxySession
        where TProxy : ProxyBase<TProxySession>
        where TProxySession : ProxySession, new()
    {
        /// <summary>代理对象</summary>
        public TProxy Proxy { get { return (this as IProxySession).Proxy as TProxy; } set { (this as IProxySession).Proxy = value; } }
    }

    /// <summary>代理会话。客户端的一次转发请求（或者Tcp连接），就是一个会话。转发的全部操作都在会话中完成。</summary>
    /// <remarks>
    /// 一个会话应该包含两端，两个Socket，服务端和客户端
    /// 客户端<see cref="INetSession.Session"/>发来的数据，在这里经过一系列过滤器后，转发给服务端<see cref="Remote"/>；
    /// 服务端<see cref="Remote"/>返回的数据，在这里经过过滤器后，转发给客户端<see cref="INetSession.Session"/>。
    /// </remarks>
    public class ProxySession : NetSession, IProxySession
    {
        #region 属性
        private IProxy _Proxy;
        /// <summary>代理对象</summary>
        IProxy IProxySession.Proxy { get { return _Proxy; } set { _Proxy = value; } }

        private ISocketSession _Remote;
        /// <summary>远程服务端。跟目标服务端通讯的那个Socket，其实是客户端TcpClientX/UdpClientX</summary>
        public ISocketSession Remote { get { return _Remote; } set { _Remote = value; } }

        //private IPEndPoint _RemoteEndPoint;
        ///// <summary>服务端远程IP终结点</summary>
        //public IPEndPoint RemoteEndPoint { get { return _RemoteEndPoint; } set { _RemoteEndPoint = value; } }

        //private ProtocolType _RemoteProtocolType;
        ///// <summary>服务端协议。默认与客户端协议相同</summary>
        //public ProtocolType RemoteProtocolType { get { return _RemoteProtocolType; } set { _RemoteProtocolType = value; } }

        private NetUri _RemoteUri;
        /// <summary>服务端地址</summary>
        public NetUri RemoteUri { get { return _RemoteUri ?? (_RemoteUri = new NetUri()); } }

        //private String _RemoteHost;
        ///// <summary>远程主机</summary>
        //public virtual String RemoteHost { get { return _RemoteHost; } set { _RemoteHost = value; } }
        #endregion

        #region 构造
        /// <summary>实例化一个代理会话</summary>
        public ProxySession()
        {
            DisposeWhenSendError = true;
        }

        /// <summary>子类重载实现资源释放逻辑时必须首先调用基类方法</summary>
        /// <param name="disposing">从Dispose调用（释放所有资源）还是析构函数调用（释放非托管资源）</param>
        protected override void OnDispose(bool disposing)
        {
            base.OnDispose(disposing);

            var remote = Remote;
            if (remote != null)
            {
                Remote = null;
                remote.Dispose();
            }
        }
        #endregion

        #region 数据交换
        /// <summary>开始会话处理。参数e里面可能含有数据</summary>
        /// <param name="e"></param>
        public override void Start(ReceivedEventArgs e)
        {
            // 如果未指定远程协议，则与来源协议一致
            if (RemoteUri.ProtocolType == 0) RemoteUri.ProtocolType = Session.ProtocolType;

            base.Start(e);
        }

        /// <summary>收到客户端发来的数据</summary>
        /// <param name="e"></param>
        protected override void OnReceive(ReceivedEventArgs e)
        {
            WriteDebugLog("[{0}] {1} => {2}", ID, ClientEndPoint, e.Stream.Length);

            if (e.Stream != null)
            {
                if (Remote == null) StartRemote(e);

                //Remote.Send(stream, RemoteEndPoint);
                if (Remote != null) SendRemote(e.Stream);
            }
        }

        /// <summary>开始远程连接</summary>
        /// <param name="e"></param>
        protected virtual void StartRemote(ReceivedEventArgs e)
        {
            var start = DateTime.Now;
            ISocketSession session = null;
            try
            {
                session = CreateRemote(e);
                //if (client.ProtocolType == ProtocolType.Tcp && !client.Client.Connected) client.Connect(RemoteEndPoint);
                session.OnDisposed += (s, e2) =>
                {
                    // 这个是必须清空的，是否需要保持会话呢，由OnRemoteDispose决定
                    _Remote = null;
                    OnRemoteDispose(s as ISocketSession);
                };
                session.Received += new EventHandler<ReceivedEventArgs>(Remote_Received);
                session.ReceiveAsync();

                //Debug.Assert(session.Client.Connected);
                Remote = session;
            }
            catch (Exception ex)
            {
                if (session != null) session.Dispose();
                this.Dispose();

                var ts = DateTime.Now - start;
                //var host = String.IsNullOrEmpty(RemoteHost) ? "" + RemoteEndPoint : RemoteHost;
                //throw new XException(ex, "无法连接远程服务器{0}！耗时{1}！", RemoteUri, ts);
                WriteLog("无法为{0}连接远程服务器{1}！耗时{2}！{3}", ClientUri, RemoteUri, ts, ex.Message);
            }
        }

        ///// <summary>用于记录不可连接的地址，带超时时间。</summary>
        //static Dictionary<String, DateTime> _NotConnected = new Dictionary<string, DateTime>();

        /// <summary>为会话创建与远程服务器通讯的Socket。可以使用Socket池达到重用的目的。默认实现创建与服务器相同类型的客户端</summary>
        /// <param name="e"></param>
        /// <returns></returns>
        protected virtual ISocketSession CreateRemote(ReceivedEventArgs e)
        {
            //var key = "" + RemoteEndPoint;
            //if (String.IsNullOrEmpty(key)) throw new ArgumentNullException("RemoteEndPoint");

            //DateTime dt;
            //if (_NotConnected.TryGetValue(key, out dt))
            //{
            //    if (dt > DateTime.Now) throw new NetException("指定时间内连接{0}超时，稍候再试！", key);
            //    _NotConnected.Remove(key);
            //}

            var client = NetService.Resolve<ISocketClient>(RemoteUri.ProtocolType);
            var rep = RemoteUri.EndPoint;
            if (rep != null)
            {
                client.AddressFamily = rep.AddressFamily;
                client.Connect(rep);
            }
            return client.CreateSession();

            //return NetService.CreateSession(new NetUri(RemoteProtocolType, RemoteEndPoint));
        }

        /// <summary>远程连接断开时触发。默认销毁整个会话，子类可根据业务情况决定客户端与代理的链接是否重用。</summary>
        /// <param name="client"></param>
        protected virtual void OnRemoteDispose(ISocketSession client) { this.Dispose(); }

        void Remote_Received(object sender, ReceivedEventArgs e)
        {
            try
            {
                OnReceiveRemote(e);
            }
            catch (Exception ex) { this.Dispose(); WriteLog(ex.Message); throw; }
        }

        /// <summary>收到远程服务器返回的数据</summary>
        /// <param name="e"></param>
        protected virtual void OnReceiveRemote(ReceivedEventArgs e)
        {
            //WriteDebugLog("[{0}] {1} <= {2}", ID, RemoteUri.EndPoint, e.Stream.Length);

            if (e.Stream != null)
            {
                var session = Session;
                if (session == null || session.Disposed)
                    this.Dispose();
                else
                {
                    try
                    {
                        Send(e.Stream);
                    }
                    catch { this.Dispose(); throw; }
                }
            }
        }
        #endregion

        #region 发送
        /// <summary>发送数据</summary>
        /// <param name="buffer">缓冲区</param>
        /// <param name="offset">位移</param>
        /// <param name="size">写入字节数</param>
        public virtual IProxySession SendRemote(byte[] buffer, int offset = 0, int size = 0)
        {
            try
            {
                Remote.Send(buffer, offset, size);
            }
            catch { this.Dispose(); throw; }

            return this;
        }

        /// <summary>发送数据流</summary>
        /// <param name="stream"></param>
        /// <returns></returns>
        public virtual IProxySession SendRemote(Stream stream)
        {
            try
            {
                Remote.Send(stream);
            }
            catch { this.Dispose(); throw; }

            return this;
        }

        /// <summary>发送字符串</summary>
        /// <param name="msg"></param>
        /// <param name="encoding"></param>
        public virtual IProxySession SendRemote(string msg, Encoding encoding = null)
        {
            try
            {
                Remote.Send(msg, encoding);
            }
            catch { this.Dispose(); throw; }

            return this;
        }
        #endregion

        #region 辅助
        /// <summary>已重载。</summary>
        /// <returns></returns>
        public override string ToString() { return base.ToString() + "=>" + Remote; }
        #endregion
    }
}