using Common.DbExtends.Extends;
using Common.Models.Enums;
using Common.Models.SubTables;
using Common.Models.UnqTables;
using Common.Requests.Lianmengs;
using Common.Utils;
using Newtonsoft.Json.Linq;
using Server.MyClass.Caches;
using SqlSugar;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Server.Timers
{
    /// <summary>
    /// 美团订单定时同步
    /// </summary>
    public class MtOrderTimer : MyTimer
    {
        public MtOrderTimer()
        {

            MTRequest.OrderNoticeEvent += MTRequest_OrderNoticeEvent;
        }


        Client Client = Client.SingleClient;
        private SqlSugar.SqlSugarClient Db { get { return Client.Db; } }
        private ConcurrentDictionary<int, bool> IsUpdateing = new ConcurrentDictionary<int, bool>();

        protected override void Run(object state, bool timedOut)
        {
            var lianmengs = this.Db.Queryable<Lianmeng>().Where(w => w.LianmengType == Common.Models.Enums.LianmengType.美团联盟&&w.ExpirationTime>DateTime.Now).ToList();
            foreach (var lianmeng in lianmengs)
            {
                //防止重复读取
                if (IsUpdateing.ContainsKey(lianmeng.Id))
                {
                    continue;
                }
                var lastDateTime = GetLastDateTime(lianmeng.Id + "");
                if ((DateTime.Now - lastDateTime).TotalSeconds <= 60)//60秒间隔读取
                {
                    continue;
                }
                //启动线程读取
                ThreadPool.QueueUserWorkItem((o) =>
                {
                    HandleOrderLianmeng(o as Lianmeng);
                }, lianmeng);
            }
        }
        /// <summary>
        /// 同步某个账号美团订单
        /// </summary>
        /// <param name="lianmeng"></param>
        private void HandleOrderLianmeng(Lianmeng lianmeng)
        {
            //防止重复读取
            if (IsUpdateing.ContainsKey(lianmeng.Id))
            {
                return;
            }
            //标记防止重复读取
            IsUpdateing[lianmeng.Id] = true;
            try
            {
                var req = new MTRequest(lianmeng);
                //上次读取时间
                var lastDateTime = GetLastDateTime(lianmeng.Id + "");
                if (lastDateTime == DateTime.MinValue)
                {
                    //如果没有时间，读取最近1个月的数据
                    lastDateTime = DateTime.Now.AddDays(-30);
                }
                //本次读取时间
                var datetime = DateTime.Now;
                //处理订单
                HandleOrder(lianmeng, req, lastDateTime, datetime);
                //记录本次读取时间
                SetLastDateTime(lianmeng.Id + "", datetime);
            }
            catch (Exception ex)
            {
                Db.OnLog("美团订单同步2", ex);
            }
            finally
            {
                //删除防止重复读取标记
                IsUpdateing.TryRemove(lianmeng.Id, out _);
                if (lianmeng.ExpirationTime < DateTime.Now)
                {
                    Db.Updateable(lianmeng).UpdateColumns(s => new { s.ExpirationTime }).ExecuteCommand();
                }
            }
        }
        /// <summary>
        /// 处理订单
        /// </summary>
        /// <param name="lianmeng"></param>
        /// <param name="req"></param>
        /// <param name="lastDateTime"></param>
        /// <param name="datetime"></param>
        private void HandleOrder(Lianmeng lianmeng, MTRequest req, DateTime lastDateTime, DateTime datetime)
        {
            lastDateTime = lastDateTime.AddMinutes(-1);
            req.GetCPSOrderList(lastDateTime, datetime, (items) =>
            {
                var db = Db;
                db.UseTran(() =>
                {
                    var addlist = new List<MtOrder>();
                    foreach (var item in items)
                    {
                        var uniqueItemId = item["uniqueItemId"].Value<long>();
                        var modifyTime = item["modifyTime"].Value<string>();
                        var orderPayTime = item["orderPayTime"].Value<DateTime>();
                        var itemStatus = (MtItemOrderStatus)item["itemStatus"].Value<int>();
                        var itemBizStatus = (MtItemBizStatusEnum)item["itemBizStatus"].Value<int>();
                        var tablenames = db.GetTableName<MtOrder>(orderPayTime);
                        var info = db.Queryable<MtOrder>().Where(w => w.uniqueItemId == uniqueItemId).SplitTable(t => t.InTableNames(tablenames)).First();
                        if (info != null)
                        {
                            if (info.modifyTime == modifyTime)
                            {
                                continue;
                            }
                            else if ((int)info.SystemOrderStatus > 3000)
                            {
                                continue;
                            }
                            //复制对象
                            Util.CopyToObj(item, info);
                            //设置订单状态
                            SetOrderState(itemStatus, itemBizStatus, info);
                            //修改数据
                            db.Updateable(info).SplitTable(t => t.InTableNames(tablenames)).ExecuteCommand();
                        }
                        else
                        {
                            var order = new MtOrder();
                            order.Id = Util.CreateID(orderPayTime);
                            order.LianmengId = lianmeng.Id;
                            Util.CopyToObj(item, order);
                            SetOrderState(itemStatus, itemBizStatus, order);
                            addlist.Add(order);
                        }
                    }
                    if (addlist.Count > 0)
                    {
                        //批量插入到数据库
                        db.Insertable(addlist).SplitTable().ExecuteCommand();
                    }
                }, ex => db.OnLog("美团订单同步", ex));
                return false;
            });
            //处理异常订单
            HandleAbnormalOrderLianmeng(lianmeng, lastDateTime, datetime);
        }

        /// <summary>
        /// 设置订单状态
        /// </summary>
        /// <param name="itemStatus"></param>
        /// <param name="itemBizStatus"></param>
        /// <param name="order"></param>
        private void SetOrderState(MtItemOrderStatus itemStatus, MtItemBizStatusEnum itemBizStatus, MtOrder order)
        {
            switch (itemStatus)
            {
                case MtItemOrderStatus.未使用:
                    order.SystemOrderStatus = Common.Models.Enums.SystemOrderStatus.未知;
                    break;
                case MtItemOrderStatus.已使用:
                    order.SystemOrderStatus = Common.Models.Enums.SystemOrderStatus.订单收货;
                    break;
                case MtItemOrderStatus.退款中:
                    order.SystemOrderStatus = Common.Models.Enums.SystemOrderStatus.订单退款中;
                    break;
                case MtItemOrderStatus.已退款:
                    order.SystemOrderStatus = Common.Models.Enums.SystemOrderStatus.全额退款;
                    break;
                case MtItemOrderStatus.已消费退款:
                    order.SystemOrderStatus = Common.Models.Enums.SystemOrderStatus.全额退款;
                    break;
                default:
                    break;
            }
            switch (itemBizStatus)
            {
                case MtItemBizStatusEnum.支付成功:
                    order.SystemOrderStatus = Common.Models.Enums.SystemOrderStatus.订单付款;
                    break;
                case MtItemBizStatusEnum.核销成功:
                    order.SystemOrderStatus = Common.Models.Enums.SystemOrderStatus.订单收货;
                    break;
                case MtItemBizStatusEnum.结算成功:
                    order.SystemOrderStatus = Common.Models.Enums.SystemOrderStatus.订单结算;
                    break;
                case MtItemBizStatusEnum.无效订单:
                    order.SystemOrderStatus = Common.Models.Enums.SystemOrderStatus.订单失效;
                    break;
                case MtItemBizStatusEnum.未知状态:
                    break;
                default:
                    break;
            }
        }

        /// <summary>
        /// 读取异常订单处理
        /// </summary>
        /// <param name="lianmeng"></param>
        /// <param name="lastDateTime"></param>
        private void HandleAbnormalOrderLianmeng(Lianmeng lianmeng, DateTime lastDateTime, DateTime dateTime)
        {
            var req = new MTRequest(lianmeng);
            req.GetCPSAbnormalOrderList(lastDateTime, dateTime, items =>
            {
                var db = Db;
                db.UseTran(() =>
                {
                    foreach (var item in items)
                    {
                        var uniqueItemId = item["uniqueItemId"].Value<long>();
                        var eventType = item["eventType"].Value<int>();
                        var info = db.Queryable<MtOrder>().Where(w => w.uniqueItemId == uniqueItemId).SplitTable(t => t.Take(2)).First();
                        if (info != null)
                        {
                            if ((int)info.SystemOrderStatus > 3000)
                            {
                                continue;
                            }
                            switch (eventType)
                            {
                                case 1:
                                    //退款
                                    info.SystemOrderStatus = Common.Models.Enums.SystemOrderStatus.全额退款;
                                    break;
                                case 2:
                                    //风控
                                    info.SystemOrderStatus = Common.Models.Enums.SystemOrderStatus.订单失效;
                                    break;
                                case 4:
                                    //负项调整
                                    info.SystemOrderStatus = Common.Models.Enums.SystemOrderStatus.订单失效;
                                    break;
                            }
                            //修改数据
                            db.Updateable(info).SplitTable(t => t.Take(2)).ExecuteCommand();
                        }
                        else
                        {
                            //订单不存在
                        }
                    }
                }, ex => db.OnLog("美团异常订单处理", ex));
                return false;
            });
        }
        /// <summary>
        /// 获取上次时间
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        private DateTime GetLastDateTime(string id)
        {
            return Client.Config.RuntimeCache.GetPublicValue("订单同步" + id, () => DateTime.MinValue);
        }
        /// <summary>
        /// 记录上次时间
        /// </summary>
        /// <param name="id"></param>
        /// <param name="now"></param>
        private void SetLastDateTime(string id, DateTime now)
        {
            Client.Config.RuntimeCache.SetPublicValue("订单同步" + id, now);
        }

        /// <summary>
        /// 收到需要订单更新事件
        /// </summary>
        /// <param name="start"></param>
        /// <param name="end"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void MTRequest_OrderNoticeEvent(Lianmeng lianmeng, DateTime start, DateTime end)
        {
            var req = new MTRequest(lianmeng);
            HandleOrder(lianmeng, req, start, end);
        }
    }
}