using Newtonsoft.Json.Linq;
using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CommonUtil.RabbitMQ
{
    /// <summary>
    /// 
    /// </summary>
    public class MQClientFullChannel : IDisposable
    {

        #region 变量

        /// <summary>
        /// 接收
        /// </summary>
        public IModel channelReceive { get; internal set; }

        /// <summary>
        /// 链接
        /// </summary>
        public IConnection connectionReceive { get; internal set; }

        /// <summary>
        /// 发送对象
        /// </summary>
        public string queueName { get; set; }

        /// <summary>
        /// 日志文件名
        /// </summary>
        public string logName { get; set; }

        /// <summary>
        /// >0 表示允许重连，等待多少毫秒
        /// </summary>
        public int reConnectTime { get; set; }


        #endregion

        #region 构造函数

        /// <summary>
        /// 空构造函数
        /// </summary>
        public MQClientFullChannel()
        {
            queueName = "";
            logName = "MQ日志";
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="qname">需要接收或发送的qname</param>
        public MQClientFullChannel(string qname)
        {
            queueName = qname;
            logName = "MQ日志";
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="qname">需要接收或发送的qname</param>
        /// <param name="lname">日志文件</param>
        public MQClientFullChannel(string qname, string lname)
        {
            queueName = qname;
            logName = lname;
        }

        /// <summary>
        /// 
        /// </summary>
        public void Dispose()
        {
            if (connectionReceive != null)
            {
                connectionReceive.Dispose();
            }

            if (channelReceive != null)
            {
                channelReceive.Dispose();
            }
        }

        #endregion

        #region 发送消息 静态方法

        /// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="param"></param>
        /// <param name="mqname"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public static string SendMessageStatic(MQClientParam param, string mqname, string message)
        {
            using (MQClientFullChannel mQClientFullChannel = new MQClientFullChannel(mqname))
            {
                string ret = mQClientFullChannel.SendMessage(param, message);
                return ret;
            }

        }

        /// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="mode"></param>
        /// <param name="mqname"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public static string SendMessageStatic(int mode, string mqname, string message)
        {
            using (MQClientFullChannel mQClientFullChannel = new MQClientFullChannel(mqname))
            {
                string ret = mQClientFullChannel.SendMessage(mode, message);
                return ret;
            }
        }

        #endregion

        #region 发送消息

        /// <summary>
        /// 添加即时消息
        /// </summary>
        /// <param name="param"></param>
        /// <param name="mqname"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public string SendMessage(MQClientParam param, string mqname, string message)
        {
            try
            {

                ConnectionFactory factory = new ConnectionFactory();
                factory.HostName = param.HostName;
                factory.UserName = param.UserName;
                factory.Password = param.Password;
                factory.Port = param.Port;
                factory.VirtualHost = param.VirtualHost;
                using (var connection = factory.CreateConnection())
                {
                    using (var channel = connection.CreateModel())
                    {
                        channel.QueueDeclare(mqname, true, false, false, null);
                        var properties = channel.CreateBasicProperties();
                        properties.DeliveryMode = 2;
                        properties.Persistent = true;
                        var body = Encoding.UTF8.GetBytes(message);
                        channel.BasicPublish("", mqname, properties, body);
                    }
                }
                return "ok";
            }
            catch (Exception ee)
            {
                // 写入日志
                Task.Run(() =>
                {
                    LogUtil.Error(ee.Message.ToString(), logName);
                });
                return ee.Message.ToString();
            }
        }

        /// <summary>
        /// 添加即时消息
        /// </summary>
        /// <param name="param"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public string SendMessage(MQClientParam param, string message)
        {
            string mqname = queueName;
            if (string.IsNullOrWhiteSpace(mqname))
            {
                return "传入的参数不正确!";
            }
            return SendMessage(param, mqname, message);
        }

        /// <summary>
        /// 根据AppSetting.Json中的内容发送信息
        /// </summary>
        /// <param name="mode"> 0-独立 1-集群</param>
        /// <param name="mqname"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public string SendMessage(int mode, string mqname, string message)
        {
            MQClientParam param;
            string ret = GetParam(mode, out param);
            if (ret != "ok") return ret;
            return SendMessage(param, mqname, message);
        }

        /// <summary>
        /// 根据AppSetting.Json中的内容发送信息
        /// </summary>
        /// <param name="mode">0-独立 1-集群</param>
        /// <param name="message"></param>
        /// <returns></returns>
        public string SendMessage(int mode, string message)
        {
            string mqname = queueName;
            if (string.IsNullOrWhiteSpace(mqname))
            {
                return "传入的参数不正确!";
            }
            return SendMessage(mode, mqname, message);
        }
        /// <summary>
        /// 发送定时消息
        /// </summary>
        /// <param name="mode"></param>
        /// <param name="mqname"></param>
        /// <param name="message"></param>
        /// <param name="sendTime"></param>
        /// <returns></returns>
        public static string SendDelayMessageStatic(int mode, string mqname, string message, DateTime sendTime)
        {
            using (MQClientFullChannel mQClientFullChannel = new MQClientFullChannel())
            {
                string ret = mQClientFullChannel.SendDelayMessage(mode, mqname, message, sendTime);
                return ret;
            }
        }

        /// <summary>
        /// 添加延时消息
        /// </summary>
        /// <param name="param"></param>
        /// <param name="mqname"></param>
        /// <param name="message"></param>
        /// <param name="sendtime"></param>
        /// <returns></returns>
        public string SendDelayMessage(MQClientParam param, string mqname, string message, DateTime sendtime)
        {
            try
            {
                if (sendtime <= DateTime.Now)
                {
                    return SendMessage(param, queueName, message);
                }
                else
                {
                    TimeSpan ts = sendtime - DateTime.Now;
                    long ttl = long.Parse(ts.TotalMilliseconds.ToString("f0"));
                    ConnectionFactory factory = new ConnectionFactory();
                    factory.HostName = param.HostName;
                    factory.UserName = param.UserName;
                    factory.Password = param.Password;
                    factory.Port = param.Port;
                    factory.VirtualHost = param.VirtualHost;
                    using (var connection = factory.CreateConnection())
                    {
                        using (var channel = connection.CreateModel())
                        {
                            //string fqname = Enum.GetName(queueName.GetType(), queueName);
                            Dictionary<string, object> dic = new Dictionary<string, object>();
                            dic.Add("x-expires", ttl + 300000); //队列中所有消息都有相同的过期时间
                            dic.Add("x-message-ttl", ttl);//队列上消息过期时间，应小于队列过期时间  
                            dic.Add("x-dead-letter-exchange", "exchange-direct");//过期消息转向路由  
                            dic.Add("x-dead-letter-routing-key", mqname);//过期消息转向路由相匹配routingkey  

                            string qname = "duomaitime" + Guid.NewGuid().ToString();
                            channel.ExchangeDeclare(exchange: "exchange-direct", type: "direct");
                            channel.QueueDeclare(qname, true, false, false, dic);
                            var properties = channel.CreateBasicProperties();
                            properties.DeliveryMode = 2;
                            properties.Persistent = true;
                            var body = Encoding.UTF8.GetBytes(message);
                            channel.BasicPublish("", qname, properties, body);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                return ex.ToString();
            }

            return "ok";
        }

        /// <summary>
        /// 添加延时消息
        /// </summary>
        /// <param name="param"></param>
        /// <param name="message"></param>
        /// <param name="sendtime"></param>
        /// <returns></returns>
        public string SendDelayMessage(MQClientParam param, string message, DateTime sendtime)
        {
            string mqname = queueName;
            if (string.IsNullOrWhiteSpace(mqname))
            {
                return "传入的参数不正确!";
            }

            return SendDelayMessage(param, mqname, message, sendtime);
        }


        /// <summary>
        /// 添加延时消息
        /// </summary>
        /// <param name="mode">0-独立 1-集群</param>
        /// <param name="mqname"></param>
        /// <param name="message"></param>
        /// <param name="sendtime"></param>
        /// <returns></returns>
        public string SendDelayMessage(int mode, string mqname, string message, DateTime sendtime)
        {
            MQClientParam param;
            string ret = GetParam(mode, out param);
            if (ret != "ok") return ret;
            return SendDelayMessage(param, mqname, message, sendtime);
        }

        /// <summary>
        /// 添加延时消息
        /// </summary>
        /// <param name="mode"></param>
        /// <param name="message"></param>
        /// <param name="sendtime"></param>
        /// <returns></returns>
        public string SendDelayMessage(int mode, string message, DateTime sendtime)
        {
            string mqname = queueName;
            if (string.IsNullOrWhiteSpace(mqname))
            {
                return "传入的参数不正确!";
            }

            MQClientParam param;
            string ret = GetParam(mode, out param);
            if (ret != "ok") return ret;
            return SendDelayMessage(param, mqname, message, sendtime);
        }


        #endregion

        #region 接收消息

        /// <summary>
        /// 消息到达客户端发起的事件
        /// </summary>
        /// <param name="result">BasicDeliverEventArgs消息对象</param>
        public delegate void ActionEvent(EventMessageResultCluster result);

        /// <summary>
        /// 事件激活委托实例
        /// </summary>
        private ActionEvent _onMessage;

        /// <summary>
        /// 当侦听的队列中有消息到达时触发的执行事件
        /// </summary>
        public event ActionEvent OnMessage
        {
            add
            {
                if (_onMessage == null)
                {
                    _onMessage += value;
                }
            }
            remove
            {
                if (_onMessage != null)
                {
                    _onMessage -= value;
                }
            }
        }

        /// <summary>
        /// 连接成功
        /// </summary>
        private Action<MQClientParam> _onConnected;

        /// <summary>
        /// 链接成功回调
        /// </summary>
        public event Action<MQClientParam> OnConnected
        {
            add
            {
                if (_onConnected == null)
                {
                    _onConnected += value;
                }
            }
            remove
            {
                if (_onConnected != null)
                {
                    _onConnected -= value;
                }
            }
        }

        /// <summary>
        /// 链接成功回调
        /// </summary>
        /// <param name="param"></param>
        public void Connected(MQClientParam param)
        {
            if (_onConnected != null)
            {
                _onConnected(param);
            }
        }

        /// <summary>
        /// 连接断开
        /// </summary>
        private Action<MQClientParam> _onDisConnected;

        /// <summary>
        /// 连接断开回调
        /// </summary>
        public event Action<MQClientParam> OnDisConnected
        {
            add
            {
                if (_onDisConnected == null)
                {
                    _onDisConnected += value;
                }
            }
            remove
            {
                if (_onDisConnected != null)
                {
                    _onDisConnected -= value;
                }
            }
        }

        /// <summary>
        /// 连接断开回调
        /// </summary>
        /// <param name="param"></param>
        public void DisConnected(MQClientParam param)
        {
            if (_onDisConnected != null)
            {
                _onDisConnected(param);
            }
        }


        /// <summary>
        /// 侦听初始化
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        public void ConnectInit(MQClientParam param)
        {
            try
            {
                string fqname = queueName;
                ConnectionFactory factory = new ConnectionFactory();
                factory.HostName = param.HostName;
                factory.UserName = param.UserName;
                factory.Password = param.Password;
                factory.Port = param.Port;
                factory.VirtualHost = param.VirtualHost;
                factory.AutomaticRecoveryEnabled = true;
                factory.NetworkRecoveryInterval = TimeSpan.FromSeconds(10);
                connectionReceive = factory.CreateConnection();

                connectionReceive.ConnectionShutdown += (o, e) =>
                {
                    Task.Run(() =>
                    {
                        LogUtil.Info(JSONUtil.ObjectToJson(param) + " --> 链接关闭", logName);
                    });

                    // 调用链接关闭的回调
                    DisConnected(param);

                    // 关闭
                    Close();

                    if (reConnectTime > 0)
                    {
                        //等待并重新链接
                        Task.Delay(reConnectTime).Wait();
                        ConnectInit(param);
                    }
                };


                //获取通道
                channelReceive = connectionReceive.CreateModel();
                channelReceive.ExchangeDeclare(exchange: "exchange-direct", type: "direct");
                channelReceive.QueueBind(fqname, "exchange-direct", fqname);

                //创建事件驱动的消费者类型
                var consumer = new EventingBasicConsumer(channelReceive);
                consumer.Received += consumer_Received;
                channelReceive.BasicQos(0, 1, false); //一次只获取一个消息进行消费
                channelReceive.BasicConsume(fqname, false, consumer);

                // 链接成功,调用一下通知调用者
                if (connectionReceive.IsOpen)
                {
                    this.Connected(param);
                }
            }
            catch (Exception ee)
            {
                Task.Run(() =>
                {
                    LogUtil.Info("ConnectInit(MQClientParam param)异常:" + ee.Message.ToSingular(), logName);
                });

                // 调用链接关闭的回调
                DisConnected(param);

                // 关闭
                Close();

                if (reConnectTime > 0)
                {
                    //等待并重新链接
                    Task.Delay(reConnectTime).Wait();
                    ConnectInit(param);
                }
            }

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="mode">0-表示监听独立的,>0 表示监听集群中的某一个</param>
        public string Connect(int mode)
        {
            // 根据mode获取参数
            MQClientParam param;
            string ret = "";
            if (mode == 0)
            {
                //独立
                ret = GetParam(0, out param);
                if (ret != "ok")
                {
                    return ret;
                }
            }
            else
            {
                List<MQClientParam> pAll = new List<MQClientParam>();
                ret = GetParam(out pAll);
                if (ret != "ok")
                {
                    return ret;
                }
                if (mode > pAll.Count())
                {
                    return $"Items下没有第[{mode}]条记录";
                }
                param = pAll[mode - 1];
            }
            if (param == null)
            {
                return "MQ参数获取不正确!";
            }

            try
            {
                Task.Factory.StartNew(() =>
                {
                    ConnectInit(param);
                });
            }
            catch (Exception ex)
            {
                Task.Run(() =>
                {
                    LogUtil.Error("Connect(int mode):" + ex.Message.ToString(), "MQClientFullChannel");
                });
                return ex.Message.ToString();
            }
            return "ok";
        }

        /// <summary>
        /// 接受到消息
        /// </summary>
        private void consumer_Received(object sender, BasicDeliverEventArgs e)
        {
            try
            {
                EventMessageResultCluster emr = new EventMessageResultCluster();
                string message = Encoding.UTF8.GetString(e.Body);
                //emr.ReplyToAddress = e.BasicProperties==null?"":e.BasicProperties.ReplyToAddress==null?"":e.BasicProperties.ReplyToAddress.ToString();
                emr.ConsumerTag = e?.ConsumerTag?.ToString();
                emr.RoutingKey = e?.RoutingKey?.ToString();
                emr.Topic = "";
                emr.Content = message;
                if (_onMessage != null)
                {
                    //触发外部侦听事件
                    _onMessage(emr);
                }

                if (emr.IsOperationOk == false)
                {
                    //WriteLine("MQ日志", "未能消费此消息，重新放入队列头:" + message);
                    //未能消费此消息，重新放入队列头
                    channelReceive.BasicReject(e.DeliveryTag, false);
                }
                else if (channelReceive.IsClosed == false)
                {
                    //WriteLine("MQ日志", "确认消息:" + message);
                    channelReceive.BasicAck(e.DeliveryTag, false);
                    //MqTraceLog.SaveTraceLog(queueName.ToString(), message, 1);
                }
            }
            catch (Exception ex)
            {
                LogUtil.Error("接收消息出错:" + ex.ToString(), "MQClientFullChannel");
            }
        }

        #endregion

        #region 关闭链接

        /// <summary>
        /// 关闭连接
        /// </summary>
        public void Close()
        {
            try
            {
                if (channelReceive != null)
                {
                    channelReceive.Close();
                    channelReceive.Dispose();
                }
            }
            catch { }

            try
            {
                if (connectionReceive != null)
                {
                    connectionReceive.Close();
                    connectionReceive.Dispose();
                }
            }
            catch { }

        }

        #endregion


        #region 获取appsetting.json中的MQ参数
        /// <summary>
        /// 获取MQ参数
        /// </summary>
        /// <param name="mode">0-独立 1-集群</param>
        /// <param name="param"></param>
        /// <returns></returns>
        public string GetParam(int mode, out MQClientParam param)
        {
            param = null;
            // 获取appsetting.json文件中的MQConfig信息
            JArray mqItem = null;
            if (mode == 0)
            {
                // 独立
                mqItem = (JArray)JSONUtil.JsonToObject(JSONUtil.ObjectToJson((ConfigUtil.GetChildren($"MQConfig"))));
                if (mqItem == null || mqItem.Count() < 4)
                {
                    return "MQ集群参数配置不正确,参数过少!";
                }
            }
            else
            {
                //指定
                var items = ConfigUtil.GetChildren("MQConfig:Items");
                if (items.Count() < 1)
                {
                    return "没有配置MQ集群参数";
                }

                // 随即获取要使用哪个MQConfig
                //int rm = new Random().Next(0, items.Count());
                int rm = mode;
                // 获取参数
                mqItem = (JArray)JSONUtil.JsonToObject(JSONUtil.ObjectToJson((ConfigUtil.GetChildren($"MQConfig:Items:{rm}"))));
                if (mqItem == null || mqItem.Count() < 4)
                {
                    return "MQ集群参数配置不正确,参数过少!";
                }

            }
            param = new MQClientParam();
            try
            {
                foreach (var tmp in mqItem)
                {
                    switch (tmp["Key"].ToString().ToLower())
                    {
                        case "hostname":
                            param.HostName = tmp["Value"].ToString();
                            break;
                        case "port":
                            param.Port = Convert.ToInt32(tmp["Value"]);
                            break;
                        case "username":
                            param.UserName = tmp["Value"].ToString();
                            break;
                        case "password":
                            param.Password = tmp["Value"].ToString();
                            break;
                        case "retrycount":
                            param.RetryCount = Convert.ToInt32(tmp["Value"]);
                            break;
                        case "virtualhost":
                            param.VirtualHost = tmp["Value"].ToString();
                            break;
                    }
                }
            }
            catch (Exception ee)
            {
                return "MQ集群参数设置不正确!" + ee.Message.ToString();
            }

            if (param == null)
            {
                return "MQ参数获取失败!";
            }
            return "ok";
        }


        /// <summary>
        /// 获取所有集群参数
        /// </summary>
        /// <param name="paramAll"></param>
        /// <returns></returns>
        public string GetParam(out List<MQClientParam> paramAll)
        {
            paramAll = null;
            //集群
            var items = ConfigUtil.GetChildren("MQConfig:Items");
            if (items.Count() < 1)
            {
                return "没有配置MQ集群参数";
            }
            for (int i = 0; i < items.Count(); i++)
            {
                JArray mqItem = (JArray)JSONUtil.JsonToObject(JSONUtil.ObjectToJson((ConfigUtil.GetChildren($"MQConfig:Items:{i}"))));
                if (mqItem == null || mqItem.Count() < 4)
                {
                    continue;
                }

                // 循环获取
                MQClientParam param = new MQClientParam();
                try
                {
                    foreach (var tmp in mqItem)
                    {
                        switch (tmp["Key"].ToString().ToLower())
                        {
                            case "hostname":
                                param.HostName = tmp["Value"].ToString();
                                break;
                            case "port":
                                param.Port = Convert.ToInt32(tmp["Value"]);
                                break;
                            case "username":
                                param.UserName = tmp["Value"].ToString();
                                break;
                            case "password":
                                param.Password = tmp["Value"].ToString();
                                break;
                            case "retrycount":
                                param.RetryCount = Convert.ToInt32(tmp["Value"]);
                                break;
                            case "virtualhost":
                                param.VirtualHost = tmp["Value"].ToString();
                                break;
                        }
                    }
                }
                catch (Exception ee)
                {
                    LogUtil.Error("MQ集群参数设置不正确:" + ee.Message.ToString(), "MQClientFullChannel");
                    continue;
                }
                paramAll = paramAll == null ? new List<MQClientParam>() : paramAll;
                paramAll.Add(param);
            }

            return "ok";
        }



        #endregion


        /// <summary>
        /// 具体发送的参数
        /// </summary>
        public class MQClientParam
        {
            /// <summary>
            /// MQ服务器地址
            /// </summary>
            public string HostName { get; set; }

            /// <summary>
            /// MQ服务器端口
            /// </summary>
            public int Port { get; set; }

            /// <summary>
            /// MQ登录名
            /// </summary>
            public string UserName { get; set; }

            /// <summary>
            /// MQ密码
            /// </summary>
            public string Password { get; set; }

            /// <summary>
            /// 
            /// </summary>
            public string VirtualHost { get; set; }

            /// <summary>
            /// 
            /// </summary>
            public int RetryCount { get; set; }
        }

        /// <summary>
        /// 
        /// </summary>
        public class RabbitMQSetCluster
        {
            private string hostname = "106.14.15.190";
            /// <summary>
            /// 地址
            /// </summary>
            public string HostName
            {
                get { return this.hostname; }
            }


            private List<string> listhostname = new List<string>(new string[] { "106.14.15.190", "106.14.223.74", "101.132.39.50" });

            /// <summary>
            /// 
            /// </summary>
            public List<string> HostNameList
            {
                get { return this.listhostname; }
            }



            private int port = 8102;
            /// <summary>
            /// 端口
            /// </summary>
            public int Port
            {
                get { return this.port; }
            }

            private string username = "duomaicrm";
            /// <summary>
            /// 用户名
            /// </summary>
            public string UserName
            {
                get { return this.username; }
            }

            private string password = "taocrm123";
            /// <summary>
            /// 密码
            /// </summary>
            public string Password
            {
                get { return this.password; }
            }
        }


        /// <summary>
        /// 
        /// </summary>
        public class EventMessageResultCluster
        {
            /// <summary>
            /// 
            /// </summary>
            public string Topic { get; set; }

            /// <summary>
            /// 
            /// </summary>
            public string Content { get; set; }

            /// <summary>
            /// 消息处理是否成功
            /// </summary>
            public bool IsOperationOk { get; set; }

            /// <summary>
            /// 
            /// </summary>
            public void Confirm()
            {
                this.IsOperationOk = true;
            }

            /// <summary>
            /// 
            /// </summary>
            public void Fail()
            {
                this.IsOperationOk = false;
            }

            /// <summary>
            /// 
            /// </summary>
            public string ConsumerTag { get; set; }

            /// <summary>
            /// 
            /// 
            /// </summary>
            public string RoutingKey { get; set; }

        }


    }
}