using NLog;
using POSV.Bean;
using POSV.Entity;
using POSV.ShoppingCart;
using POSV.Utils;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace POSV.Helper
{
    public class ChuDaHelper
    {
        private static Logger logger = NLog.LogManager.GetCurrentClassLogger();

        /// <summary>
        /// 出品
        /// </summary>
        public static void MadePrinter(OrderObject orderObject, bool updateDbPrintNum = true)
        {
            bool isException = false;
            try
            {
                //是否开启出品
                var allowPrinter = Global.Instance.GlobalConfigBoolValue(ConfigConstant.PERIPHERAL_KITCHEN_ALLOW_CHUPIN, false);
                if (allowPrinter)
                {
                    var KITLists = Global.KitPlan._kitPlanList;
                    //厨打方案对应的单品列表
                    var plans = new Dictionary<string, List<OrderItem>>();
                    //点单列表中允许出品的记录集
                    var lists = orderObject.Items.FindAll(x => !string.IsNullOrEmpty(x.ChupinFlag) && x.ChupinFlag.Equals("1"));

                    if (lists == null || lists.Count() == 0)
                    {
                        logger.Warn("没有配置要出品的商品");

                        return;
                    }

                    //将厨打记录加工为:方案ID==>集合
                    foreach (var e in lists)
                    {
                        //如果厨打方案ID不存在，新建
                        if (!plans.ContainsKey(e.Chupin))
                        {
                            plans[e.Chupin] = new List<OrderItem>();
                        }
                        plans[e.Chupin].Add(e);
                    }


                    //遍历厨打方案
                    if (plans.Count > 0)
                    {
                        //获取厨打方案配置参数
                        var json = Global.Instance.GlobalConfigStringValue(ConfigConstant.PERIPHERAL_KITCHEN_TICKET, string.Empty);
                        //厨打方案是否配置
                        if (!string.IsNullOrEmpty(json))
                        {
                            var kobj = JsonUtils.Deserialize<Dictionary<string, KitchenPrinterItem>>(json);
                            //厨打方案对应的打印机列表
                            var printers = kobj.Values.ToList();

                            //执行厨打的订单项
                            List<OrderItem> result = new List<OrderItem>();

                            foreach (var p in plans)
                            {
                                if (printers.Exists(x => x.KitId == p.Key))
                                {
                                    //厨打方案对应的打印机参数
                                    var pobj = printers.Find(x => x.KitId == p.Key);

                                    if ("None".Equals(pobj.PrinterItem.Name))
                                    {
                                        continue;
                                    }
                                    KitPlan kitPlan = KITLists.Find(x => p.Key == x.Id);
                                    if (kitPlan != null)
                                    {
                                        orderObject.Ext3 = kitPlan.Name;
                                    }

                                    Tuple<bool, string> printResult = null;

                                    switch (pobj.KitType)
                                    {
                                        case 0://一菜一单
                                            {
                                                foreach (var pi in p.Value)
                                                {
                                                    var _items = new List<OrderItem>();
                                                    _items.Add(pi);
                                                    var _vars = PrintHelper.BuilderKitchenVariable(orderObject, _items, pobj, false);

                                                    if (_vars.Item1)
                                                    {
                                                        printResult = PrintHelper.PrinterKitchen(pobj, "出品单", _vars.Item2, pobj.CutPager == 1, pobj.HeaderEmpty, pobj.FooterEmpty);

                                                        if (printResult.Item1)
                                                        {
                                                            result.AddRange(_items);
                                                        }

                                                        Thread.Sleep(pobj.Delay * 1000);
                                                    }
                                                }
                                            }
                                            break;
                                        case 1://一小类一单
                                            {
                                                var groups = p.Value.GroupBy(x => x.TypeId).ToList();
                                                foreach (var g in groups)
                                                {
                                                    var _vars = PrintHelper.BuilderKitchenVariable(orderObject, g.ToList(), pobj, false);

                                                    if (_vars.Item1)
                                                    {
                                                        printResult = PrintHelper.PrinterKitchen(pobj, "出品单", _vars.Item2, pobj.CutPager == 1, pobj.HeaderEmpty, pobj.FooterEmpty);

                                                        if (printResult.Item1)
                                                        {
                                                            result.AddRange(g.ToList());
                                                        }

                                                        Thread.Sleep(pobj.Delay * 1000);
                                                    }
                                                }
                                            }
                                            break;
                                        case 2://一桌一单
                                            {
                                                var _vars = PrintHelper.BuilderKitchenVariable(orderObject, p.Value, pobj, false);

                                                if (_vars.Item1)
                                                {
                                                    printResult = PrintHelper.PrinterKitchen(pobj, "出品单", _vars.Item2, pobj.CutPager == 1, pobj.HeaderEmpty, pobj.FooterEmpty);

                                                    if (printResult.Item1)
                                                    {
                                                        result.AddRange(p.Value);
                                                    }

                                                    Thread.Sleep(pobj.Delay * 1000);
                                                }
                                            }
                                            break;
                                    }

                                    if (printResult != null)
                                    {
                                        logger.Error(printResult.Item2);
                                    }
                                    else
                                    {
                                        logger.Error("厨打方案配置不正确");
                                    }

                                }
                            }

                            if(result.Count > 0)
                            {
                                foreach (var item in result)
                                {
                                    item.ChupinQty = item.Quantity;
                                }

                                if (updateDbPrintNum)
                                {
                                    lock (Global.Instance.SyncLock)
                                    {
                                        //更新厨打数量
                                        using (var db = Global.Instance.OpenDataBase)
                                        {
                                            using (var transaction = db.GetTransaction())
                                            {
                                                foreach (var item in result)
                                                {
                                                    db.Update(item);
                                                }
                                                transaction.Complete();
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        else
                        {
                            logger.Error("尚未配置厨打方案参数");

                        }
                    }
                    else
                    {
                        logger.Error("没有可用的出品方案");
                    }
                }
                else
                {
                    logger.Error("收银参数尚未开启出品打印");
                }

            }
            catch (Exception ex)
            {

            }
            finally
            {
                if (!isException)
                {

                }
            }
        }

        /// <summary>
        /// 厨打标签
        /// </summary>
        /// <param name="order"></param>
        /// <param name="updateDbPrintNum"></param>
        public static void KitchenLabelPrinter(OrderObject order, bool updateDbPrintNum = true)
        {
            try
            {
                var isLabel = Global.Instance.GlobalConfigBoolValue(ConfigConstant.PERIPHERAL_KITCHEN_ALLOW_CHUDA_LABEL, false);

                if (isLabel)
                {
                    if (order.OrderType == OrderType.饿了么 || order.OrderType == OrderType.美团外卖 || order.OrderType == OrderType.百度外卖)
                    {
                        var enablePrintLabel = Global.Instance.GlobalConfigBoolValue(ConfigConstant.PERIPHERAL_KITCHEN_ALLOW_WAIMAI_CHUDA_LABEL, false);
                        if (!enablePrintLabel)
                        {
                            logger.Info("厨打标签打印：未启用外卖打印标签");
                            return;
                        }
                    }

                    //获取厨打方案配置参数
                    var json = Global.Instance.GlobalConfigStringValue(ConfigConstant.PERIPHERAL_KITCHEN_TICKET, string.Empty);
                    //厨打方案是否配置
                    if (!string.IsNullOrEmpty(json))
                    {
                        var kobj = JsonUtils.Deserialize<Dictionary<string, KitchenPrinterItem>>(json);
                        //厨打方案对应的打印机列表
                        var printers = kobj.Values.ToList();
                        //打印标签的item
                        IEnumerable<IGrouping<string, OrderItem>> labelPlanGroup = order.Items.FindAll(x => !string.IsNullOrEmpty(x.ChuDaLabelFlag) && x.ChuDaLabelFlag.Equals("1") && x.RowState != OrderRowState.套餐主).GroupBy(x => x.ChuDaLabel);
                        foreach (IGrouping<string, OrderItem> ig in labelPlanGroup)
                        {
                            var chudaLabel = ig.Key;//厨打标签方案ID

                            var labelRes = LabelPrintHelper.InstallLabelList(order, ig.ToList(), PrintTypeEnum.厨打标签);

                            var labelList = labelRes.Item1;
                            var printItemList = labelRes.Item2;

                            if (labelList.Count > 0)
                            {
                                if (printers.Exists(x => x.KitId == chudaLabel))
                                {
                                    //厨打方案对应的打印机参数
                                    var printer = printers.Find(x => x.KitId == chudaLabel);

                                    if ("None".Equals(printer.PrinterItem.Name))
                                    {
                                        continue;
                                    }

                                    var pobj = LabelPrintHelper.Trans2PrinterObject(printer.PrinterItem);

                                    var tems = Global.Instance.GlobalConfigStringValue(ConfigConstant.PERIPHERAL_LABEL_TEMPLATE);
                                    if (!string.IsNullOrEmpty(tems))
                                    {
                                        var temObj = JsonUtils.Deserialize<List<LabelTemplate>>(tems);
                                        if (temObj != null)
                                        {
                                            var tem = temObj.Find(x => x.Name == "普通标签");
                                            if (tem != null)
                                            {
                                                LabelPrintHelper.PrintLabel(pobj, tem, labelList);
                                                logger.Info("打印订单所有标签完成");

                                                //更新标签打印内容
                                                if (printItemList.Count > 0)
                                                {
                                                    foreach (var item in printItemList)
                                                    {
                                                        item.ChuDaLabelQty = item.Quantity;
                                                    }
                                                    if (updateDbPrintNum)
                                                    {
                                                        lock (Global.Instance.SyncLock)
                                                        {
                                                            using (var db = Global.Instance.OpenDataBase)
                                                            {
                                                                using (var transaction = db.GetTransaction())
                                                                {
                                                                    foreach (var item in printItemList)
                                                                    {
                                                                        db.Update(item);
                                                                    }
                                                                    transaction.Complete();
                                                                }
                                                            }
                                                        }
                                                    }
                                                }

                                            }
                                        }
                                        else
                                        {
                                            logger.Error("未配置标签打印模板，不打印");
                                        }
                                    }
                                    else
                                    {
                                        logger.Error("未配置标签打印模板，不打印");
                                    }
                                }
                            
                            }
                        }
                    }
                    else
                    {
                        logger.Error("尚未配置厨打方案参数");
                    }
                }
                else
                 {
                    logger.Error("收银参数尚未开启厨打标签");
                }
            }
            catch(Exception ex)
            {
                logger.Error(ex, "打印厨打标签异常");
            }
        }

        /// <summary>
        /// 厨打
        /// </summary>
        public static void KitchenPrinter(OrderObject orderObject, bool updateDbPrintNum = true)
        {
            //是否开启厨打
            var allowKitchenPrinter = Global.Instance.GlobalConfigBoolValue(ConfigConstant.PERIPHERAL_KITCHEN_ALLOW_CHUDA, false);
            if (allowKitchenPrinter)
            {
                var KITLists = Global.KitPlan._kitPlanList;

                
                //厨打方案对应的单品列表
                var plans = new Dictionary<string, List<OrderItem>>();
                //点单列表中允许厨打的记录集
                var lists = orderObject.Items.FindAll(x => !string.IsNullOrEmpty(x.ChudaFlag) && x.ChudaFlag.Equals("1")).OrderBy(x => x.OrderNo);
                if(lists == null || lists.Count() == 0)
                {
                    logger.Warn("没有配置要厨打的商品");

                    return;
                }

                //将厨打记录加工为:方案ID==>集合
                foreach (var e in lists)
                {
                    //如果厨打方案ID不存在，新建
                    if (!plans.ContainsKey(e.Chuda))
                    {
                        plans[e.Chuda] = new List<OrderItem>();
                    }
                    plans[e.Chuda].Add(e);
                }

                //遍历厨打方案
                if (plans.Count > 0)
                {
                    //获取厨打方案配置参数
                    var json = Global.Instance.GlobalConfigStringValue(ConfigConstant.PERIPHERAL_KITCHEN_TICKET, string.Empty);
                    //厨打方案是否配置
                    if (!string.IsNullOrEmpty(json))
                    {
                        var kobj = JsonUtils.Deserialize<Dictionary<string, KitchenPrinterItem>>(json);
                        //厨打方案对应的打印机列表
                        var printers = kobj.Values.ToList();

                        //执行厨打的订单项
                        List<OrderItem> result = new List<OrderItem>();

                        foreach (var p in plans)
                        {
                            if (printers.Exists(x => x.KitId == p.Key))
                            {
                                //厨打方案对应的打印机参数
                                var pobj = printers.Find(x => x.KitId == p.Key);

                                if ("None".Equals(pobj.PrinterItem.Name))
                                {
                                    continue;
                                }
                                KitPlan kitPlan = KITLists.Find(x => p.Key==x.Id);
                                if (kitPlan!=null) {
                                    orderObject.Ext3 = kitPlan.Name;
                                }
                                Tuple<bool, string> printResult = null;

                                switch (pobj.KitType)
                                {
                                    case 0://一菜一单
                                        {
                                            foreach (var pi in p.Value)
                                            {
                                                var _items = new List<OrderItem>();
                                                _items.Add(pi);

                                                var _vars = PrintHelper.BuilderKitchenVariable(orderObject, _items, pobj, true);

                                                if (_vars.Item1)
                                                {
                                                    printResult = PrintHelper.PrinterKitchen(pobj, "厨打单", _vars.Item2, pobj.CutPager == 1, pobj.HeaderEmpty, pobj.FooterEmpty);

                                                    if (printResult.Item1)
                                                    {
                                                        result.AddRange(_items);
                                                    }

                                                    Thread.Sleep(pobj.Delay * 1000);
                                                }
                                            }
                                        }
                                        break;
                                    case 1://一小类一单
                                        {
                                            var groups = p.Value.GroupBy(x => x.TypeId).ToList();
                                            foreach (var g in groups)
                                            {
                                                var _vars = PrintHelper.BuilderKitchenVariable(orderObject, g.ToList(), pobj, true);

                                                if (_vars.Item1)
                                                {
                                                    printResult = PrintHelper.PrinterKitchen(pobj, "厨打单", _vars.Item2, pobj.CutPager == 1, pobj.HeaderEmpty, pobj.FooterEmpty);

                                                    if (printResult.Item1)
                                                    {
                                                        result.AddRange(g.ToList());
                                                    }

                                                    Thread.Sleep(pobj.Delay * 1000);
                                                }
                                            }
                                        }
                                        break;
                                    case 2://一桌一单
                                        {
                                            var _vars = PrintHelper.BuilderKitchenVariable(orderObject, p.Value, pobj, true);

                                            if (_vars.Item1)
                                            {
                                                printResult = PrintHelper.PrinterKitchen(pobj, "厨打单", _vars.Item2, pobj.CutPager == 1, pobj.HeaderEmpty, pobj.FooterEmpty);

                                                if (printResult.Item1)
                                                {
                                                    result.AddRange(p.Value);
                                                }

                                                Thread.Sleep(pobj.Delay * 1000);
                                            }
                                        }
                                        break;
                                }

                                if (printResult != null)
                                {
                                    logger.Info(printResult.Item2);

                                }
                                else
                                {
                                    logger.Error("厨打方案配置不正确");
                                }

                            }
                            else
                            {
                                var pobj = printers.FirstOrDefault();

                                if ("None".Equals(pobj.PrinterItem.Name))
                                {
                                    continue;
                                }
                                KitPlan kitPlan = KITLists.FirstOrDefault();
                                if (kitPlan != null)
                                {
                                    orderObject.Ext3 = kitPlan.Name;
                                }
                                Tuple<bool, string> printResult = null;

                                switch (pobj.KitType)
                                {
                                    case 0://一菜一单
                                        {
                                            foreach (var pi in p.Value)
                                            {
                                                var _items = new List<OrderItem>();
                                                _items.Add(pi);

                                                var _vars = PrintHelper.BuilderKitchenVariable(orderObject, _items, pobj, true);

                                                if (_vars.Item1)
                                                {
                                                    printResult = PrintHelper.PrinterKitchen(pobj, "厨打单", _vars.Item2, pobj.CutPager == 1, pobj.HeaderEmpty, pobj.FooterEmpty);

                                                    if (printResult.Item1)
                                                    {
                                                        result.AddRange(_items);
                                                    }

                                                    Thread.Sleep(pobj.Delay * 1000);
                                                }
                                            }
                                        }
                                        break;
                                    case 1://一小类一单
                                        {
                                            var groups = p.Value.GroupBy(x => x.TypeId).ToList();
                                            foreach (var g in groups)
                                            {
                                                var _vars = PrintHelper.BuilderKitchenVariable(orderObject, g.ToList(), pobj, true);

                                                if (_vars.Item1)
                                                {
                                                    printResult = PrintHelper.PrinterKitchen(pobj, "厨打单", _vars.Item2, pobj.CutPager == 1, pobj.HeaderEmpty, pobj.FooterEmpty);

                                                    if (printResult.Item1)
                                                    {
                                                        result.AddRange(g.ToList());
                                                    }

                                                    Thread.Sleep(pobj.Delay * 1000);
                                                }
                                            }
                                        }
                                        break;
                                    case 2://一桌一单
                                        {
                                            var _vars = PrintHelper.BuilderKitchenVariable(orderObject, p.Value, pobj, true);

                                            if (_vars.Item1)
                                            {
                                                printResult = PrintHelper.PrinterKitchen(pobj, "厨打单", _vars.Item2, pobj.CutPager == 1, pobj.HeaderEmpty, pobj.FooterEmpty);

                                                if (printResult.Item1)
                                                {
                                                    result.AddRange(p.Value);
                                                }

                                                Thread.Sleep(pobj.Delay * 1000);
                                            }
                                        }
                                        break;
                                }

                                if (printResult != null)
                                {
                                    logger.Info(printResult.Item2);

                                }
                                else
                                {
                                    logger.Error("厨打方案配置不正确");
                                }
                            }
                        }

                        if(result.Count > 0)
                        {
                            foreach (var item in result)
                            {
                                item.ChudaQty = item.Quantity;
                            }

                            if (updateDbPrintNum)
                            {
                                lock (Global.Instance.SyncLock)
                                {
                                    //更新厨打数量
                                    using (var db = Global.Instance.OpenDataBase)
                                    {
                                        using (var transaction = db.GetTransaction())
                                        {
                                            foreach (var item in result)
                                            {
                                                //db.Save(item);
                                                db.Update(item);
                                            }
                                            transaction.Complete();
                                        }
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        logger.Error("尚未配置厨打方案参数");
                    }
                }
                else
                {
                    logger.Error("没有满足厨打方案的单品");
                }
            }
            else
            {
                logger.Error("打印参数中没有开启厨打");
            }
        }
    }
}