using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using POSV.Entity;
using POSV.Helper;
using POSV.Proxy.Base;
using POSV.Proxy.Common;
using POSV.Proxy.GuoPan.Entity;
using POSV.ServiceCenter;
using POSV.ShoppingCart;
using POSV.Utils;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;

namespace POSV.Proxy.GuoPan
{
    public class GuoPanProxy : ProxyBase
    {
        #region DLL 初始化 
        [DllImport("GuoPAPI.dll")]
        private static extern int apiInit(string msid, string ApiKey, int handle, string extention);

        [DllImport("GuoPAPI.dll")]
        private static extern int apiCall(int msgid);

        [DllImport("GuoPAPI.dll")]
        private static extern int apiClose();

        public static string msid = "45113";
        public static string ApiKey = "f89520ec88df08b2effe27656534278156d76acf";
        private const string extention = "";

        #endregion

        /// <summary>
        /// 初始化果盘DLL
        /// </summary>
        /// <param name="_msid"></param>
        /// <param name="_ApiKey"></param>
        /// <returns></returns>
        public static Tuple<bool, string> ApiInit(string _msid, string _ApiKey, int ParenthWnd)
        {
            try
            {

                var _en = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_ENABLEMEITUANORDER, false);//禁止使用;


                if (_en)
                {
                    return new Tuple<bool, string>(true, "已设置禁止使用");
                }



                //果盘初始化前，先调用一次apiClose接口
                apiClose();

                msid = _msid;
                ApiKey = _ApiKey;
                var _data = apiInit(msid, _ApiKey, ParenthWnd, extention);

                if (_data != 1)
                {

                    var _info = GetData<ConfirmReception>(1.ToString());
                    return new Tuple<bool, string>(false, _info.info);
                }
                else
                {
                    return new Tuple<bool, string>(true, "");
                }
            }
            catch (Exception ex)
            {
                LOGGET.Error(ex);
                return new Tuple<bool, string>(false, ex.Message);
            }


        }

        /// <summary>
        /// 接单
        /// </summary>
        /// <param name="_doOrder"></param>
        /// <returns></returns>
        public Tuple<bool, string> ConfirmOrder(DoOrder _doOrder)
        {
            //zhangy 2020-03-14 Add 订单保存数据库后，要修改isHaveUpLoadTicket=true     
            bool isException = false;

            try
            {
                GuoPanRequest<ConfirmGetRequest, ConfirmPostRequest> guoPan = new GuoPanRequest<ConfirmGetRequest, ConfirmPostRequest>();

                guoPan.action = new Actions() { action = "do_confirm" };
                guoPan.get = new ConfirmGetRequest()
                {
                    id = _doOrder.id,
                    bzid = _doOrder.id,
                    state = "2",
                    table = _doOrder.table
                };
                guoPan.post = new ConfirmPostRequest()
                {
                    info = "",
                    hint = "",
                    rider_phone = _doOrder.rider_phone,
                    rider_name = _doOrder.rider_phone,
                    package_num = _doOrder.package_num

                };

                var _data = Request<ConfirmReception>(guoPan.ToJson(), FunctionType.接单);

                if (!_data.Item1)
                {
                    return new Tuple<bool, string>(false, _data.Item2);
                }

                if (_data.Item3.status.Equals("1"))
                {
                    return new Tuple<bool, string>(true, "成功");
                }
                else
                {
                    return new Tuple<bool, string>(false, _data.Item3.info);
                }
            }
            catch (Exception ex)
            {
                //有异常发生
                isException = true;

                LOGGET.Error(ex);
                return new Tuple<bool, string>(false, ex.Message);
            }
            finally
            {
                //没有异常发生
                if (!isException)
                {
                    //更新是否有订单需要上传的状态
                    Global.isHaveUpLoadTicket = true;
                    Global.isHaveBurdenTicket = true;
                    Global.isHaveCenterTicket = true;
                }
            }
        }

        /// <summary>
        /// 拒单
        /// </summary>
        /// <param name="_doOrder"></param>
        /// <returns></returns>
        public Tuple<bool, string> CancelOrder(DoOrder _doOrder)
        {
            try
            {
                GuoPanRequest<CancelRequest, CancelRequest> guoPan = new GuoPanRequest<CancelRequest, CancelRequest>();

                guoPan.action = new Actions() { action = "do_cancel" };
                guoPan.get = new CancelRequest()
                {
                    id = _doOrder.id,
                    op = Global.Instance.Worker.No
                };


                var _data = Request<ConfirmReception>(guoPan.ToJson(), FunctionType.拒单);

                if (!_data.Item1)
                {
                    return new Tuple<bool, string>(false, _data.Item2);
                }

                if (_data.Item3.status.Equals("1"))
                {
                    return new Tuple<bool, string>(true, "成功");
                }
                else
                {
                    return new Tuple<bool, string>(false, _data.Item3.info);
                }
            }
            catch (Exception ex)
            {
                LOGGET.Error(ex);
                return new Tuple<bool, string>(false, ex.Message);
            }
        }

        public Tuple<bool, string> IsConfirm(string _id)
        {
            try
            {
                using (var _db = Global.Instance.OpenDataBase)
                {
                    var _sql = string.Format("select * from pos_order where tradeNo = '{0}'", _id);

                    var _data = _db.FirstOrDefault<OrderObject>(_sql);

                    if (_data == null)
                    {
                        return new Tuple<bool, string>(false, "");
                    }
                    else
                    {
                        return new Tuple<bool, string>(true, "");
                    }
                }
            }
            catch (Exception ex)
            {
                LOGGET.Error(ex);
                return new Tuple<bool, string>(false, ex.Message);
            }
        }

        /// <summary>
        /// 获取订单明细
        /// </summary>
        /// <param name="_id"></param>
        /// <returns></returns>
        public Tuple<bool, string, DoOrder> SelectOrder(string _id)
        {
            try
            {
                GuoPanRequest<GetOrderRequest, GetOrderRequest> guoPan = new GuoPanRequest<GetOrderRequest, GetOrderRequest>();
                guoPan.action = new Actions() { action = "do_get_order" };
                guoPan.get = new GetOrderRequest() { id = _id };

                var _data = Request<DoOrder>(guoPan.ToJson(), FunctionType.订单明细);

                if (!_data.Item1)
                {
                    return new Tuple<bool, string, DoOrder>(false, _data.Item2, null);
                }

                if (_data.Item3.status.Equals("1"))
                {
                    return new Tuple<bool, string, DoOrder>(true, "成功", _data.Item3);
                }
                else
                {
                    return new Tuple<bool, string, DoOrder>(false, "", null);
                }
            }
            catch (Exception)
            {

                throw;
            }
        }


        /// <summary>
        /// 获取某天数据
        /// </summary>
        /// <returns></returns>
        public Tuple<bool, string, ListOrderReception> SelectData(string _date)
        {
            try
            {
                if (string.IsNullOrEmpty(_date))
                {
                    _date = DateTime.Now.ToString("yyyyMMdd");
                }

                GuoPanRequest<ListOrderRequest, ListOrderRequest> guoPan = new GuoPanRequest<ListOrderRequest, ListOrderRequest>();
                guoPan.action = new Actions() { action = "do_list_bydate" };
                guoPan.get = new ListOrderRequest() { date = _date };

                var _data = Request<ListOrderReception>(guoPan.ToJson(), FunctionType.当天订单);

                if (!_data.Item1)
                {
                    return new Tuple<bool, string, ListOrderReception>(false, _data.Item2, null);
                }

                if (_data.Item3.status.Equals("1"))
                {
                    return new Tuple<bool, string, ListOrderReception>(true, "成功", _data.Item3);
                }
                else
                {
                    var _info = GetData<ConfirmReception>(1.ToString());
                    if (_info.info.Contains("过期"))
                    {
                        return new Tuple<bool, string, ListOrderReception>(false, _info.info, null);
                    }
                    return new Tuple<bool, string, ListOrderReception>(false, _data.Item3.info, null);
                }
            }
            catch (Exception ex)
            {
                LOGGET.Error(ex);

                LOGGET.Error(ex.HelpLink);
                return new Tuple<bool, string, ListOrderReception>(false, ex.Message, null);
            }

        }

        /// <summary>
        ///数据转换
        /// </summary>
        /// <param name="_doOrder"></param>
        /// <returns></returns>
        public Tuple<bool, string, OrderObject> ToOrderData(DoOrder doOrder)
        {
            try
            {
                //复制
                DoOrder _doOrder = JsonConvert.DeserializeObject<DoOrder>(JsonConvert.SerializeObject(doOrder));

                OrderObject _order = new OrderObject();
                _order.AddPoint = 0;
                _order.Address = _doOrder.addr;
                _order.AftPoint = 0;
                _order.Amount = (_doOrder.list.Sum(f => f.amt) + _doOrder.other_pay_item.Sum(f => f.amt));
                _order.ChangeAmount = 0;
                _order.CreateDate = _doOrder.time;
                _order.CreateUser = Global.Instance.Worker.CreateUser;
                _order.DeviceName = DeviceUtils.Instance.ComputerName;
                _order.Id = IdWorkerUtils.Instance.NextId();
                _order.IpAddress = DeviceUtils.Instance.IPAddress;//本地IP地址
                _order.IsMember = 0;
                _order.MacAddress = DeviceUtils.Instance.MacAddress;//MAC地址

                _order.ObjectId = ObjectId.GenerateNewStringId();
                _order.TradeNo = _doOrder.id;
                _order.OrderNo = _doOrder.srcnum.Split('#')[1];
                _order.OrderStatus = OrderStatus.已完成;
                _order.OrderType = OrderType.美团外卖;
                _order.OrgTradeNo = "";
                _order.PaidAmount = _order.Amount;
                _order.PaymentStatus = OrderPaymentStatus.已付款;

                int i = 0;
                bool _Ps = true;

                //果盘订单是否包含配送费用
                bool otherWaimaiSet = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_MEITUANEXPRESSCOST, false);

                if (otherWaimaiSet)
                {
                    var _ps = _doOrder.other_pay_item.FirstOrDefault(f => f.name.Equals("配送费"));

                    if (_ps != null)
                    {
                        OrdetItem ordet = new OrdetItem();
                        ordet.id = "1003";
                        ordet.memo = "";
                        ordet.name = _ps.name;
                        ordet.price = _ps.price;
                        ordet.amt = _ps.amt;
                        ordet.dgid = "1003";
                        ordet.qty = _ps.qty;
                        ordet.refid = "1003";
                        ordet.unit = "";
                        _doOrder.list.Add(ordet);
                    }
                }

                foreach (var _item in _doOrder.list)
                {
                    ProductExt product = null;
                    if (product == null)//找不到商品跳过
                    {
                        product = new ProductExt();
                        product.Chuda = "";//厨打ID
                        product.ChudaFlag = "1";//是否厨打
                        product.Chupin = "";//出品ID
                        product.ChupinFlag = "1";//是否出品
                        product.ChuDaLabel = string.Empty;//厨打标签ID
                        product.ChuDaLabelFlag = "0";//是否厨打标签
                        product.KdsFlag = 1;
                        product.Chuxian = "";//厨显ID
                        product.ChuxianFlag = "1";//是否厨显
                        product.ChuxianTime = 0;//厨显超时时间 
                        product.CurrentFlag = 0;//是否可以议价
                        product.DiscountFlag = 0;//是否可折扣
                        product.GiveFlag = 0;//允许赠送 
                        product.LabelPrintFlag = 1;//标签打印
                        product.MebDiscountFlag = 0;//会员折上折
                        product.MinPrice = 0.00M;//最低售价 
                        product.Name = _item.name;//商品名称
                        //product.Id = string.Format("{0}", _item.dgid);//商品ID

                        //zhangy 2020-04-02 Add 果盘订单无法获取到productId,通过Hash算法根据品名生成ID，确保分类统计的正确性
                        product.Id = HashUtils.Hash1(string.IsNullOrEmpty(product.Name) ?"":product.Name)+"";

                        product.No = string.Format("{0}", _item.dgid);//商品编号
                        product.UnitId = "0";//商品单位ID
                        product.UnitName = "份";//商品单位名称
                        product.PromotionFlag = 0;//是否允许促销
                        product.ShortName = _item.name;//简称
                        product.SpecId = string.Format("{0}", _item.id);//规格ID
                        product.SuitFlag = 0;
                        product.StockFlag = 0;//是否管理库存
                        product.TapleFlag = 0;//是否主食
                        product.TypeId = "4";//商品类别ID
                        product.TypeName = "美团菜品";//商品类别名称
                        product.WeighFlag = 0;//是否称重
                    }

                    OrderItem order = new OrderItem();
                    order.Id = IdWorkerUtils.Instance.NextId();
                    order.Amount = decimal.Parse(_item.amt + _item.rebate);//单品消费
                    order.Chuda = product.Chuda;//厨打ID
                    order.ChudaFlag = product.ChudaFlag;//是否厨打
                    order.ChudaQty = 0;//厨打次数
                    order.Chupin = product.Chupin;//出品ID
                    order.ChupinFlag = product.ChupinFlag;//是否出品
                    order.ChupinQty = 0;//出品次数
                    order.ChuDaLabel = product.ChuDaLabel;//厨打标签
                    order.ChuDaLabelFlag = product.ChuDaLabelFlag;//是否厨打标签
                    order.ChuDaLabelQty = 0;//厨打标签数量
                    order.Chuxian = product.Chuxian;//厨显ID
                    order.ChuxianFlag = product.ChuxianFlag;//是否厨显
                    order.ChuxianQty = 0;//厨显次数
                    order.ChuxianTime = product.ChuxianTime;//厨显超时时间
                    order.KdsChupin = product.KdsChupin;//厨显出品ID
                    order.KdsChupinFlag = product.KdsChupinFlag;//厨显是否出品
                    order.KdsChupinQty = 0;
                    order.KdsChupinTime = product.KdsChupinTime;//厨显出品超时时间
                    order.CreateDate = _order.CreateDate;//创建时间
                    order.CreateUser = "GuoPan";//创建人
                    order.CurrentFlag = product.CurrentFlag;//是否可以议价
                    order.Discount = 0.00M;//折扣金额
                    order.DiscountFlag = product.DiscountFlag;//是否可折扣
                    order.DispatchPrice = _item.price;//批发价
                    order.DisplayName = _item.name;//打印名称
                    order.Flavor = 1;//是否包含做法
                    order.FlavorAmount = 0.00M;//餐盒费
                    order.FlavorCount = 1;
                    order.FlavorDiscountAmount = 0.00M;//做法优惠金额
                    order.FlavorReceivableAmount = 0.00M;//餐盒应收金额


                    string[] flavor = _item.memo.Split(',');

                    //if (_Ps)
                    //    foreach (var _flavoritem in _doOrder.other_pay_item.Where(f => !f.name.Contains("优惠")))
                    //    {
                    //        _Ps = false;
                    //        //if (_flavoritem.name.Equals("打包费"))
                    //        //{
                    //        //    continue;
                    //        //}
                    //        FlavorItem flavorItem = new FlavorItem();
                    //        flavorItem.BaseQuantity = 0;//做法计价
                    //        flavorItem.isWaiMaiTicket = true;
                    //        flavorItem.Code = "";
                    //        flavorItem.Color = "";
                    //        flavorItem.CreateDate = _order.CreateDate;//创建时间
                    //        flavorItem.CreateUser = "GuoPan";//创建人
                    //        flavorItem.Description = _flavoritem.name;//备注说明
                    //        flavorItem.DiscountAmount = 0.00M;//折扣金额
                    //        flavorItem.DiscountPrice = 0.00M;
                    //        flavorItem.Group = "";
                    //        flavorItem.Hand = 0;
                    //        flavorItem.IsRadio = 0;
                    //        flavorItem.Id = IdWorkerUtils.Instance.NextId();
                    //        flavorItem.ItemId = order.Id;//行ID
                    //        flavorItem.MakeId = "";//做法ID
                    //        flavorItem.Name = _flavoritem.name;//备注说明
                    //        flavorItem.OrderId = _order.Id;//
                    //        flavorItem.OrderItemQuantity = 1;
                    //        flavorItem.Price = _flavoritem.qty;//餐盒费用
                    //        flavorItem.QtyFlag = 0;
                    //        flavorItem.RefundQuantity = 0.00M;
                    //        flavorItem.TenantId = Global.Instance.Authc.TenantId;//租户ID
                    //        flavorItem.TradeNo = _order.TradeNo;
                    //        flavorItem.Type = 1;
                    //        flavorItem.Price = _flavoritem.price;
                    //        if (order.Flavors == null)
                    //        {
                    //            order.Flavors = new List<FlavorItem>();
                    //        }
                    //        order.Flavors?.Add(flavorItem);
                    //    }


                    foreach (var _flavoritem in flavor)
                    {
                        if (string.IsNullOrEmpty(_flavoritem))
                        {
                            continue;
                        }
                        FlavorItem flavorItem = new FlavorItem();
                        flavorItem.BaseQuantity = 0;//做法计价
                        flavorItem.isWaiMaiTicket = true;
                        flavorItem.Code = "";
                        flavorItem.Color = "";
                        flavorItem.CreateDate = _order.CreateDate;//创建时间
                        flavorItem.CreateUser = "GuoPan";//创建人
                        flavorItem.Description = _flavoritem;//备注说明
                        flavorItem.DiscountAmount = 0.00M;//折扣金额
                        flavorItem.DiscountPrice = 0.00M;
                        flavorItem.Group = "";
                        flavorItem.Hand = 0;
                        flavorItem.IsRadio = 0;
                        flavorItem.Id = IdWorkerUtils.Instance.NextId();
                        flavorItem.ItemId = order.Id;//行ID
                        flavorItem.MakeId = "";//做法ID
                        flavorItem.Name = _flavoritem;//备注说明
                        flavorItem.OrderId = _order.Id;//
                        flavorItem.OrderItemQuantity = 1;
                        flavorItem.Price = 0.00M;//餐盒费用
                        flavorItem.QtyFlag = 0;
                        flavorItem.RefundQuantity = 0.00M;
                        flavorItem.TenantId = Global.Instance.Authc.TenantId;//租户ID
                        flavorItem.TradeNo = _order.TradeNo;
                        flavorItem.Type = 1;
                        if (order.Flavors == null)
                        {
                            order.Flavors = new List<FlavorItem>();
                        }
                        order.Flavors?.Add(flavorItem);
                    }

                    order.GiveFlag = product.GiveFlag;//允许赠送
                    order.Group = "";//分组
                    order.LabelPrintFlag = product.LabelPrintFlag;//标签打印
                    order.MebDiscountFlag = product.MebDiscountFlag;//会员折上折
                    order.MemberPrice = _item.price;//会员价
                    order.MinPrice = product.MinPrice;//最低售价
                    order.Name = product.Name;//商品名称
                    order.OrderId = _order.Id;//订单ID
                    order.OrderNo = i++;
                    order.OtherPrice = _item.price;//第三方价
                    order.Price = _item.price;//售价
                    order.ProductExt = product;//商品信息
                    order.ProductId = product.Id;//商品ID
                    order.ProductNo = product.No;//商品编号
                    order.ProductUnitId = product.UnitId;//商品单位ID
                    order.ProductUnitName = product.UnitName;//商品单位名称
                    // order.ProductId = _item.id;//product.Id;//商品ID
                    // order.ProductNo = _item.id;//product.No;//商品编号
                    //order.ProductUnitId = product.UnitId;//商品单位ID
                    //order.ProductUnitName = _item.unit;// product.UnitName;//商品单位名称
                    order.PromotionFlag = product.PromotionFlag;//是否允许促销
                    order.Quantity = StringUtils.GetDecimal(_item.qty);//商品数量
                    order.RefundQuantity = 0.00M;//退菜数量
                    order.Remark = "美团外卖";

                    if (product.SuitFlag == 0)
                    {
                        order.RowState = OrderRowState.普通;
                    }
                    else
                    {
                        order.RowState = OrderRowState.套餐主;
                    }
                    order.SaleDate = _order.CreateDate;//创建时间
                    order.SalePrice = _item.price;//售价
                    order.ShortName = product.ShortName;//简称
                    order.SpecId = product.SpecId;//规格ID
                    order.SpecName = product.SpecName;//规格名称
                    order.StockFlag = product.StockFlag;//是否管理库存
                    order.TapleFlag = product.TapleFlag;//是否主食
                    order.TenantId = Global.Instance.Authc.TenantId;//租户ID
                    order.TotalAmonut = order.Amount;
                    order.TradeNo = _order.TradeNo;//营业模式订单编号
                    order.TypeId = product.TypeId;//商品类别ID
                    order.TypeName = product.TypeName;//商品类别名称
                    order.WeighFlag = product.WeighFlag;//是否称重

                    order.DispatchPrice = order.Amount;
                    order.MemberPrice = order.Amount;//会员价
                    order.OtherPrice = order.Amount;//第三方价
                                                    //order.Price = order.Amount;//售价
                                                    //order.SalePrice = order.Amount;//售价
                                                    //order.Promotions = promotionsList;

                    //zhangy 2020-03-13 Add 果盘订单不再统计优惠
                    order.Promotions = new List<PromotionItem>();

                    if (_order.Items == null)
                    {
                        _order.Items = new List<OrderItem>();
                    }
                    _order.Items.Add(order);

                }

                //zhangy 2020-03-13 Edit 注释以下代码，果盘订单不再统计优惠
                //var _discount_amt = _doOrder.other_pay_item.Where(f => f.name.Contains("优惠")).Sum(f => f.amt);

                //i = 0;
                //foreach (var order in _order.Items)
                //{
                //    if (i == _order.Items.Count() - 1)
                //    {
                //        order.Discount = Math.Abs(_discount_amt) - _order.DiscountAmount;
                //    }
                //    else
                //    {
                //        order.Discount = (order.Amount / _order.Amount) * Math.Abs(_discount_amt);
                //    }
                //    if (order.Promotions == null)
                //    {
                //        order.Promotions = new List<PromotionItem>();
                //    }
                //    i++;
                //    PromotionItem promotionItem = new PromotionItem();
                //    promotionItem.Amount = order.Amount;
                //    promotionItem.DiscountAmount = order.Discount;//优惠金额
                //    if (promotionItem.DiscountAmount != 0)
                //    {
                //        promotionItem.DiscountRate = DecimalUtils.ToRound(promotionItem.DiscountAmount / promotionItem.Amount, 2);//优惠率
                //    }


                //    promotionItem.Enabled = true;
                //    promotionItem.FinishDate = _order.CreateDate;//完成时间
                //    promotionItem.Id = IdWorkerUtils.Instance.NextId();
                //    promotionItem.ItemId = order.Id;//行ID
                //    promotionItem.OrderId = _order.Id;//
                //    promotionItem.PlanName = "外卖扣费";//班次编号
                //    promotionItem.PromotionType = PromotionType.外卖扣费;
                //    promotionItem.ReceivableAmount = order.ReceivableAmount;
                //    promotionItem.RelationId = "";
                //    promotionItem.TenantId = Global.Instance.Authc.TenantId;//租户ID
                //    promotionItem.TradeNo = _order.TradeNo;//订单编号
                //    promotionItem.CreateDate = _order.CreateDate;//创建时间
                //    promotionItem.CreateUser = "meituan";//创建人
                //    order.Promotions.Add(promotionItem);

                //}

                PayItem payItem = new PayItem();
                payItem.Amount = _order.ReceivableAmount;//已收金额 
                payItem.ChangeAmount = 0.00M;//找零金额
                payItem.CreateDate = _doOrder.time;
                payItem.CreateUser = "GuoPan";//创建人 
                payItem.Memo = "美团数据转换";//支付备注   
                payItem.Name = "美团外卖";//付款方式名称
                payItem.No = "22";//付款方式编码

                payItem.PointFlag = 0;//是否参与积分 
                payItem.Order = 1;//支付序号
                payItem.OrderId = _order.Id;//随机
                payItem.OutTradeNo = "";//单据编号
                payItem.OverAmount = 0.00M;//溢出金额
                payItem.PaidAmount = _order.ReceivableAmount;//实收金额
                payItem.PayNo = "6" + _order.Id;//支付编号
                payItem.PayTime = _doOrder.time;//支付时间
                payItem.ShiftName = Global.Instance.BusinessPlanLog.Name;//班次编号
                payItem.ShiftNo = Global.Instance.BusinessPlanLog.No;//班次名称
                payItem.Status = 1;
                payItem.StatusDesc = "已支付";
                payItem.TenantId = Global.Instance.Authc.TenantId;//租户ID
                payItem.TradeNo = _order.TradeNo;//支付编号
                payItem.TradeVoucherNo = "";
                payItem.Id = IdWorkerUtils.Instance.NextId();

                _order.Pays = new List<PayItem>();

                _order.Pays?.Add(payItem);

                var _amt = _doOrder.other_pay_item.FirstOrDefault(f => f.name.Equals("配送费"));
                if (_amt != null)
                {
                    _order.DeliverFee = _amt.amt;

                }

                _order.BoxFee = _doOrder.list.Where(f => f.name.Contains("打包")).Sum(f => f.amt);
                _order.Ext1 = _doOrder.memo;
                _order.wishtime = _doOrder.wishtime;
                _order.BusMode = "美团订单";
                _order.People = int.Parse(_doOrder.pscount);
                _order.Phone = _doOrder.phone;
                _order.Recipients = _doOrder.cust;
                _order.PosNo = Global.Instance.Authc.PosNo;//POS号
                _order.PrintType = 0;
                _order.ProductAmount = _order.Amount;
                _order.ReceivableAmount = _order.Amount;
                _order.ReceivedAmount = _order.Amount;
                _order.SaleDate = _order.CreateDate;
                _order.SalesCode = Global.Instance.Worker.No;//营业员编码
                _order.SalesName = Global.Instance.BusinessPlanLog.Name;
                _order.ShiftNo = Global.Instance.BusinessPlanLog.No;
                _order.StoreId = Global.Instance.BusinessPlanLog.StoreId;
                _order.StoreName = Global.Instance.Worker.StoreInfo.Name;
                _order.StoreNo = Global.Instance.Worker.StoreInfo.No;
                _order.SyncStatus = 0;
                _order.TableName = _doOrder.table;
                _order.TenantId = Global.Instance.BusinessPlanLog.TenantId;
                _order.WorkerName = Global.Instance.BusinessPlanLog.WorkerName;
                _order.WorkerNo = Global.Instance.BusinessPlanLog.WorkerNo;
                return new Tuple<bool, string, OrderObject>(true, "", _order);
            }
            catch (Exception ex)
            {
                LOGGET.Error(ex);
                return new Tuple<bool, string, OrderObject>(false, ex.Message, null);
            }
        }

        /// <summary>
        /// 打印
        /// </summary>
        /// <param name="_orderdata"></param>
        /// <param name="isRprint"></param>
        /// <returns></returns>
        public Tuple<bool, string> Print(OrderObject _orderdata, bool isRprint)
        {

            System.Threading.Tasks.Task.Factory.StartNew(() =>
            {
                try
                {
                    //打印入库
                    //构建收银小票模版参数打印
                    var vars = WaiMaiHelper.BuilderWeiXinVariable(_orderdata, isRprint);

                    //自动切纸
                    bool cutPager = Global.Instance.GlobalConfigBoolValue(ConfigConstant.PERIPHERAL_CASHIER_ALLOW_CUT_PAGER, false);
                    //是否允许打开钱箱 补打单、退单不开钱箱
                    bool openCashbox = false;
                    //票头空白行
                    int headerLine = Global.Instance.GlobalConfigIntValue(ConfigConstant.PERIPHERAL_CASHIER_HEADER_EMPTY, 0);
                    //票尾空白行
                    int footerLine = Global.Instance.GlobalConfigIntValue(ConfigConstant.PERIPHERAL_CASHIER_FOOTER_EMPTY, 0);
                    //打印机
                    var pobject = WaiMaiHelper.GetTicketPrinterObject("收银台打印机", cutPager, false);

                    //zhangy 2020-04-09 Edit 果盘订单采用独立打印模版
                    WaiMaiHelper.PrinterTicket(pobject, "果盘外卖", vars, cutPager, openCashbox, headerLine, footerLine);

                    if (isRprint)
                    {
                        _orderdata.RPrint = true;
                    }
                    //打印标签
                    LabelPrintHelper.PrintOrderLabel(_orderdata);
                    //执行厨打
                    ChuDaHelper.KitchenPrinter(_orderdata);
                    //执行厨打标签
                    ChuDaHelper.KitchenLabelPrinter(_orderdata);
                    //执行出品
                    ChuDaHelper.MadePrinter(_orderdata);
                    //通知厨显
                    UploadSCNewOrder.UploadNewOrder2SC4KDS(_orderdata);

                }
                catch (Exception ex)
                {
                    LOGGET.Info(ex);
                }
            }); 

            return new Tuple<bool, string>(true, "");
        }

        /// <summary>
        /// 补单
        /// </summary>
        /// <param name="_order"></param>
        /// <returns></returns>
        public Tuple<bool, string> ReplacementOrder(OrderObject _order)
        {
            //zhangy 2020-03-14 Add 订单保存数据库后，要修改isHaveUpLoadTicket=true     
            bool isException = false;

            try
            {
                //禁止美团订单转成本地销售
                var _save = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_ENABLEMEITUANORDERSAVE, false);//禁止美团订单转成本地销售;
                if (_save)
                {
                    return new Tuple<bool, string>(true, "禁止美团订单转成本地销售");
                }


                if (_order != null)
                {
                    using (var _db = Global.Instance.OpenDataBase)
                    {
                        using (var _tran = _db.GetTransaction())
                        {

                            var _or = _db.FirstOrDefault<OrderObject>("where tradeNo = '" + _order.TradeNo + "'");

                            if (_or != null)
                            {
                                return new Tuple<bool, string>(false, "订单已存在");
                            }

                            _db.Insert(_order);

                            if (_order.Items != null)
                                foreach (var Orderitem in _order.Items)
                                {
                                    Orderitem.ChuxianQty = 0;
                                    _db.Insert(Orderitem);
                                    if (Orderitem.Flavors != null)
                                        foreach (var _Flavor in Orderitem.Flavors)
                                        {
                                            _db.Insert(_Flavor);
                                        }
                                    if (Orderitem.Promotions != null)
                                        foreach (var Promotions in Orderitem.Promotions)
                                        {
                                            _db.Insert(Promotions);
                                        }

                                }
                            if (_order.Pays != null)
                                foreach (var orderPay in _order.Pays)
                                {
                                    _db.Insert(orderPay);
                                }
                            if (_order.Promotions != null)
                                _db.Insert(_order.Promotions);
                            if (_order.Delivery != null)
                                _db.Insert(_order.Delivery);
                            _tran.Complete();
                        }
                    }
                }

                return new Tuple<bool, string>(true, "");
            }
            catch (Exception ex)
            {
                //有异常发生
                isException = true;

                return new Tuple<bool, string>(true, ex.Message);
            }
            finally
            {
                //没有异常发生
                if (!isException)
                {
                    //更新是否有订单需要上传的状态
                    Global.isHaveUpLoadTicket = true;
                    Global.isHaveBurdenTicket = true;
                    Global.isHaveCenterTicket = true;
                }
            }

        }

        /// <summary>
        /// 自动接单
        /// </summary>
        /// <param name="_fileId"></param>
        /// <returns></returns>
        public static Tuple<bool, string> AutoConfirmOrder(int _fileId)
        {
            bool isException = false;
            try
            {
                var _en = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_ENABLEMEITUANORDER, false);//禁止使用;
               

                if (_en)
                {
                    return new Tuple<bool, string> (false,"已设置禁止使用");
                }

              

                GuoPanProxy guoPanProxy = new GuoPanProxy();
                var _jsonfile = string.Format("{0}\\Tx{1}.json", System.Environment.CurrentDirectory, _fileId);
                var _data = GetData<MqOrder>("", _jsonfile);


                if (guoPanProxy.IsConfirm(_data.data.id).Item1)
                {
                    return new Tuple<bool, string>(false, "已经接过单了");
                }

                //自动转单
                var _order = guoPanProxy.ToOrderData(_data.data);

                

                //转单失败，提示消息
                if (!_order.Item1)
                {
                    return new Tuple<bool, string>(false, _order.Item2);
                }
                
                //存储到本地
                var _rep = guoPanProxy.ReplacementOrder(_order.Item3);

                if (!_rep.Item1)
                {
                    return new Tuple<bool, string>(false, _rep.Item2);
                }

                guoPanProxy.Print(_order.Item3, false);

                if (!_rep.Item1)
                {
                    return new Tuple<bool, string>(false, _order.Item2);
                }
                else
                {
                    return new Tuple<bool, string>(true, _order.Item2);
                }

                
            }
            catch (Exception ex)
            {
                isException = true;

                LOGGET.Error(ex);
                return new Tuple<bool, string>(false, ex.Message);
            }
            finally
            {
                if (!isException)
                {

                   

                    //ConfirmOrder

                    apiCall(_fileId);
                }
            }
        }

        /// <summary>
        /// 调用果盘 DLL
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="_data"></param>
        /// <param name="functionType"></param>
        /// <returns></returns>
        private Tuple<bool, string, T> Request<T>(string _data, FunctionType functionType) where T : class
        {
            try
            {
                SetData(_data, ((int)functionType).ToString());

                var _int = apiCall(((int)functionType));

                return new Tuple<bool, string, T>(true, "", GetData<T>(_int.ToString()));
            }
            catch (Exception ex)
            {
                LOGGET.Error(ex, "请求发生异常");
                return new Tuple<bool, string, T>(false, ex.Message, null);
            }
        }


        #region Json

        /// <summary>
        /// 读取JSON文件
        /// </summary>
        /// <param name="key">JSON文件中的key值</param>
        /// <returns>JSON文件中的value值</returns>
        private static T GetData<T>(string number, string _file = null) where T : class
        {
            try
            {
                string jsonfile = string.Empty;
                if (!string.IsNullOrEmpty(_file))
                {
                    jsonfile = _file;
                }
                else
                {
                    jsonfile = string.Format("{0}\\T{1}.json", System.Environment.CurrentDirectory, number);
                }


                using (StreamReader sr = new StreamReader(jsonfile, Encoding.UTF8))
                {
                    string data = sr.ReadToEnd();

                    return JsonConvert.DeserializeObject<T>(data);
                }
            }
            catch (Exception EX)
            {
                LOGGET.Error(EX, "GuoPan解析数据异常");
                return null;
            }


        }

        /// <summary>
        /// 写JSON文件
        /// </summary>
        /// <param name="_data"></param>
        /// <param name="number"></param>
        private static void SetData(string _data, string number)
        {
            try
            {
                string jsonfile = string.Format("{0}\\R{1}.json", System.Environment.CurrentDirectory, number);

                if (File.Exists(jsonfile))
                {
                    File.Delete(jsonfile);
                }

                using (FileStream file = new FileStream(jsonfile, FileMode.Append, FileAccess.Write))
                {
                    file.Seek(0, SeekOrigin.Begin);
                    var by = Encoding.UTF8.GetBytes(_data);
                    file.Write(by, 0, by.Length);
                    file.Close();
                };
            }
            catch (Exception e)
            {
                LOGGET.Error(e, "GuoPan写数据异常");
            }
            finally
            {

            }
        }

        #endregion

    }

    public enum FunctionType
    {
        接单 = 111,
        拒单 = 222,
        订单明细 = 333,
        当天订单 = 444
    }
}