using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using NLog;
using POSV.Common.Transport;
using POSV.Common.Util;
using JwKdsV.Entity.Product;
using JwKdsV.Core.MessageEvent;
using POSV.Service.Utils;

namespace JwKdsV.Core.Utils
{
    public class SaleClearUtils
    {
        private static Logger logger = NLog.LogManager.GetCurrentClassLogger();

        private static object _lock = new object();

        private static SaleClearUtils _instance = null;

        public static SaleClearUtils Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (_lock)
                    {
                        _instance = new SaleClearUtils();

                        _instance.InitSaleClear();
                    }
                }

                return _instance;
            }
        }

        private ObservableDictionary<string, SaleClear> _maps = null;

        /// <summary>
        /// 加载今日沽清数据
        /// </summary>
        public void InitSaleClear()
        {
            try
            {
                var data = this.GetAvailableSaleClearList();

                List<SaleClear> rows = data.Item3;

                this._maps = new ObservableDictionary<string, SaleClear>();
                foreach (var row in rows)
                {
                    row.Frozen = this.IsFrozen(row);
                    this._maps[row.ProductId] = row;
                }

                logger.Info("加载的沽清商品总数量<{0}>", this._maps.Count);

                this._maps.CollectionChanged += OnCollectionChanged;
            }
            catch (Exception ex)
            {
                logger.Error(ex, "加载沽清数据异常");
            }
        }

        /// <summary>
        /// 加载沽清数据，区分本地数据和共享数据两种
        /// </summary>
        private Tuple<bool, string, List<SaleClear>> GetAvailableSaleClearList()
        {
            bool isSuccess = false;
            string message = string.Empty;

            List<SaleClear> rows = new List<SaleClear>();

            try
            {
                //启用全局沽清，服务中心提供数据
                logger.Info("获取服务中心的沽清数据");

                var data = MessageCenterUtils.Instance.GetGlobalAvailableSaleClear();
                isSuccess = data.Item1;
                message = data.Item2;
                rows = data.Item3;
            }
            catch (Exception ex)
            {
                isSuccess = false;
                message = "沽清数据异常";

                logger.Error(ex, message);
            }

            return new Tuple<bool, string, List<SaleClear>>(isSuccess, message, rows);
        }


        private void OnCollectionChanged(object sender, CollectionChangedEventArgs e)
        {
            logger.Info("操作沽清业务: {0}", e.Action);

            if (e.NewItem != null && e.NewItem is KeyValuePair<string, SaleClear>)
            {
                var map = (KeyValuePair<string, SaleClear>)e.NewItem;

                var saleClear = map.Value;

                bool isSuccess = SaveSaleClear(saleClear);

                if (isSuccess)
                {
                    //发送沽清变动通知
                    MsgEvent.Send(Constant.SALE_CLEAR_CHANGED_NOTIFY, map.Value);
                }
            }
            else
            {
                logger.Warn("沽清业务数据不合法!");
            }
        }

        /// <summary>
        /// 清理本地沽清数据
        /// </summary>
        public void Expired()
        {
            try
            {

                logger.Info("采用共享沽清模式,忽略本机清理操作....");
                return;
            }
            catch (Exception ex)
            {
                logger.Error(ex, "清理过期沽清数据异常");
            }
        }

        /// <summary>
        /// 检测是否有可用的沽清记录存在
        /// </summary>
        /// <param name="saleClear"></param>
        /// <returns></returns>
        public bool CheckSaleClear(SaleClear saleClear)
        {
            return (saleClear != null && saleClear.StopFlag == 0 && !saleClear.Frozen);
        }

        /// <summary>
        /// 沽清是否符合条件
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public bool IsFrozen(SaleClear entity)
        {
            //当前时间
            DateTime dateTime = DateTime.Now;
            //有效沽清时间
            DateTime startTime = Convert.ToDateTime(entity.StartTime);
            //结束时间
            DateTime endTime = Convert.ToDateTime(entity.EndTime);

            return (dateTime.CompareTo(startTime) < 0 || dateTime.CompareTo(endTime) > 0);
        }

        private bool SaveSaleClear(SaleClear saleClear)
        {
            bool isSuccess = true;
            try
            {
                //更新剩余数量
                saleClear.Quantity = saleClear.TotalQuantity - saleClear.SaleQuantity;

                var transport = new TransportMessage<SaleClear>();
                transport.MessageType = MessageType.ProxySaleClear;
                transport.Data = saleClear;

                MqttUtils.Instance.Publish(JsonUtils.Serialize(transport));

                logger.Info("发布变动到消息中心<{0} - {1} = {2}>", saleClear.TotalQuantity, saleClear.SaleQuantity, saleClear.Quantity);
            }
            catch (Exception ex)
            {
                isSuccess = false;
                logger.Error(ex, "本机保存沽清异常");
            }

            return isSuccess;
        }

        public bool SaveOrUpdateNoChanged(SaleClear saleClear)
        {
            bool isSuccess = true;

            this._maps.SaveOrUpdateNoChanged(saleClear.ProductId, saleClear);

            if (isSuccess)
            {
                //发送沽清变动通知
                MsgEvent.Send(Constant.SALE_CLEAR_CHANGED_NOTIFY, saleClear);
            }

            return isSuccess;
        }

        public ObservableDictionary<string, SaleClear> Maps
        {
            get
            {
                return this._maps;
            }
        }

    }
}