using POSV.Business;
using POSV.Cef.Client.ClientComm;
using POSV.Entity;
using POSV.Shift;
using POSV.ShoppingCart;
using POSV.Utils;
using POSV;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using POSV.Component;
using POSV.MsgCenter;
using POSV.MessageEvent;
using System.Collections.ObjectModel;
using Newtonsoft.Json;
using POSV.Cef.FastTemplate.PayMent;

namespace POSV.Cef.FastTemplate
{
    public partial class FastTemplate : BaseForm
    {
        //================= construct function ==================
        #region construct function
        public FastTemplate()
        {
            CheckForIllegalCrossThreadCalls = false;
            this.InitializeComponent();
            this.Initialize();


            //zhangy 2020-03-13 Add 添加小程序订单支持
            Proxy.Mqtt.MqttClientUtils.Instance.Startup();

            ////初始化推送事件
            Proxy.Mqtt.MqttClientUtils.Instance.OnMessageReceived += OnMessageReceived;

        }
        #endregion

        //zhangy 2020-03-13 Add 添加小程序订单支持
        private void OnMessageReceived(object sender, Proxy.Mqtt.MessageEventArgs e)
        {
            try
            {
                var _data = JsonUtils.Deserialize<Dictionary<string, string>>(e.Message);

                if (_data == null)
                {
                    this.ShowToastNotify(this, "订单推送数据解析可能出现问题");
                    return;
                }

                LOGGER.Info("接收到巨为小程序订单:{0}",e.Message);

                if (_data.ContainsKey("program") && _data.ContainsKey("date") && !"".Equals(_data["program"]))
                {
                    //如果发送的时间和本机相差15分钟,证明是无效消息
                    if (DateTimeUtils.ExecDateDiff(DateTime.Now, DateTime.Parse(_data["date"])) < 15)
                    {

                        Dictionary<string, string> messageMap = JsonUtils.Deserialize<Dictionary<string, string>>(e.Message);
                        if (messageMap.ContainsKey("program") && !"".Equals(messageMap["program"]))
                        {
                            //订单数量
                            string[] orderIds = _data["program"].Split(',');

                            //是否开启小程序订单
                            var enableAppletOrder = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_ENABLEAPPLETORDER,false);

                            var data = new Dictionary<string, object>();

                            data.Add("enable", enableAppletOrder ? 1:0);
                            data.Add("count", orderIds.Length);

                            //发送界面通知
                            this.m_CefClient.CallbackJsfunction("ShowWxProgramOrderNotify", JsonConvert.SerializeObject(data));
                        }
                    }
                    else
                    {

                    }
                        
                }
                else
                {
                    LOGGER.Info("巨为小程序接收的数据不合法");
                }
            }
            catch (Exception ex)
            {
                LOGGER.Error(ex, "巨为小程序订单异常");
            }
        }

        //================== private fields ===================== 
        #region fields   

        //当前订单对象
        private OrderObject _orderObject = new OrderObject();

        //当前选中的单品行记录
        private OrderItem _orderItem = null;

        //当前支付订单
        private List<OrderObject> orderObjects = new List<OrderObject>();

        //当前取消支付订单
        private List<OrderObject> m_cancelorders = new List<OrderObject>();
        //
        private List<string> IsPayList = new List<string>();
        /// <summary>
        /// cef
        /// </summary>
        private CefClientModule<FastTemplate> m_CefClient = null;

        /// <summary>
        /// 全局重新结账表示
        /// </summary>
        public bool m_IsAnewPay = false;

        /// <summary>
        /// 加载界面
        /// </summary>
        private Loading loading = null;

        #endregion



        //================== public function =======================

        /// <summary>
        /// 输入金额更新行数据
        /// </summary>
        /// <param name="price"></param>
        public void OnInputValueChanged(string strprice)
        {
            try
            {
                decimal price = 0;

                decimal.TryParse(strprice, out price);

                if (price > 0)
                {
                    if (this._orderItem != null && this._orderItem.RowState == OrderRowState.普通)
                    {

                        this._orderItem.Price = price;
                        this._orderItem.MemberPrice = price;
                        this._orderItem.SalePrice = this._orderItem.Price - (this._orderItem.Price - this._orderItem.MemberPrice);
                        //食堂自动加菜逻辑
                        if (!this.MaxSaleMoney(_orderItem))
                        {
                            return;
                        }
                         
                        /* 显示数据 */
                        this.m_CefClient.CallbackJsfunction("UpdateShoppingRow", JsonConvert.SerializeObject(this._orderItem));
                        //通知副屏，选中指定行
                        if (Global.Instance.EnableVice)
                        {
                            MsgEvent.Send(Constant.VICE_ORDER_NOTIFY, new Tuple<ViceNotifyType, object>(ViceNotifyType.UPDATEORDERITEM, this._orderItem));
                        }
                    }
                    else
                    {
                        var product = this.BuilderProductExt(price);

                        // 商品点餐逻辑判断
                        var _data = this.IsOrderItemRule(product);

                        //查询购物车最大值加1
                        _data.OrderNo = (this._orderObject.Items == null || this._orderObject.Items.Count == 0) ? 1 : this._orderObject.Items.Max(f => f.OrderNo) + 1;
                        _data.Quantity = 1;
                        _data.SalePrice = _data.Price;


                        //食堂自动加菜逻辑
                        this.MaxSaleMoney(_data);
                        this._orderItem = _data;


                        /* 显示数据 */
                        this.m_CefClient.CallbackJsfunction("AddNewShoppintRow", JsonConvert.SerializeObject(_data));
                        
                        //通知副屏
                        if (Global.Instance.EnableVice)
                        {
                            MsgEvent.Send(Constant.VICE_ORDER_NOTIFY, new Tuple<ViceNotifyType, object>(ViceNotifyType.ADDORDERITEM, this._orderItem));
                        }

                        ////通知副屏，选中指定行
                        //if (Global.Instance.EnableVice)
                        //{
                        //    MsgEvent.Send(Constant.VICE_ORDER_NOTIFY, new Tuple<ViceNotifyType, object>(ViceNotifyType.UPDATEORDERITEM, this._orderItem));
                        //}
                    }
                    
                }
                else
                {
                    //金额为0删除行
                    this.m_CefClient.CallbackJsfunction("DeleteShoppintRow", JsonConvert.SerializeObject(this._orderItem));
                    //通知副屏
                    if (Global.Instance.EnableVice)
                    {
                        MsgEvent.Send(Constant.VICE_ORDER_NOTIFY, new Tuple<ViceNotifyType, object>(ViceNotifyType.DELETESINGLEITEM, this._orderItem));
                    }
                    this._orderItem = null;
                }

            }
            finally
            {

            }
        }

        /// <summary>
        /// 订单操作统一方法
        /// </summary>
        /// <param name="name"></param>
        public void OrderOperateBtn_Click(string name)
        {
            //是否启用授权窗口
            var isAuthz = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_AUTO_LOCK_DISABLE, false);

            //模块授权控制
            if (!this.IsAccredit(name))
            {
                return;
            }
            this.Invoke((EventHandler)delegate
            {
                switch (name)
                {
                    case "消单":
                        this.m_CefClient.CallbackJsfunction("DeleteAllShoppintRow", "true");
                        break;
                    case "微信订单"://zhangy 2020-03-13 Add 小程序订单
                        {
                            var form = Application.OpenForms["JwWeiXinOrderFrom"];
                            if (form == null)
                            {
                                form = new JwWeiXinOrder.JwWeiXinOrderFrom();
                            }
                            form.WindowState = FormWindowState.Maximized;

                            TransparentForm trans = new TransparentForm(this, 0.30, form as BusinessForm);
                            trans.ShowDialog();
                        }
                        break;
                   
                    case "功能":
                        {
                            var form = Application.OpenForms["MoreDialogForm"];
                            if (form == null)
                            {
                                form = new MoreDialogForm();
                            }
                            TransparentForm trans = new TransparentForm(this, 0.30, form as BusinessForm);
                            trans.ShowDialog();
                        }
                        break;
                    case "交班":
                        {
                            //是否是盲交模式
                            bool ShiftMode = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_SHIFTMODE, false);
                            if (ShiftMode)
                            {
                                var dialogForm = new FastShitBlindForm();
                                dialogForm.AcceptButtonClick += (o, args) =>
                                {

                                };
                                dialogForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, 0.30, dialogForm);
                                trans.ShowDialog();
                                if (Global.Instance.Restart)
                                {
                                    OrderOperateBtn_Click("退出");
                                    return;
                                }
                            }
                            else
                            {
                                var dialogForm = new FastShitForm();
                                dialogForm.AcceptButtonClick += (o, args) =>
                                {

                                };
                                dialogForm.CancelButtonClick += (o, args) => { };
                                TransparentForm trans = new TransparentForm(this, 0.30, dialogForm);
                                trans.ShowDialog();
                                if (Global.Instance.Restart)
                                {
                                    OrderOperateBtn_Click("退出");
                                    return;
                                }
                            }
                        }
                        break;
                    case "注销":
                        {
                            //重启收银程序
                            Global.Instance.Restart = true;
                            this.m_CefClient.CloseBrowser();
                            Application.ExitThread();
                        }
                        break;
                    case "最小化":
                        {
                            this.WindowState = FormWindowState.Minimized;
                        }
                        break;
                    case "退出":
                        {
                            this.Invoke((EventHandler)delegate
                            {
                                LOGGER.Info("手动退出系统");
                                this.m_CefClient.CloseBrowser();
                            });
                        }
                        break;
                    case "AddItem"://添加点菜项
                        {
                            this.AddOrderItem();
                        }
                        break;
                    default:
                        break;
                }
            });

        }

        /// <summary>
        /// 结账
        /// </summary>
        /// <param name="name"></param>
        public void FunctionBtn_Click(string name)
        {
            this.AddOrderItem();


            this._orderObject =  PromotionDispose();
            if (this._orderObject.Items.Count == 0)
            {
                this.ShowToastNotify(this, "请先点餐");
                return;
            }

            //是否启用授权窗口
            var isAuthz = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_AUTO_LOCK_DISABLE, false);

            //模块授权控制
            if (!this.IsAccredit(name))
            {
                return;
            }


            //支付失败强提示
            //if (Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_ISPAYDEFEATEDREMING))
            //{
            //    //判断是否有挂起的订单
            //    var _data = this.orderObjects.Select(f => f.Id);
            //    var _paydata = this.IsPayList.Where(f => _data.Contains(f));


            //    if (this.orderObjects.Count > 0)
            //    {
            //        if (this.orderObjects.Count > _paydata.Count())
            //        {
            //            this.ShowToastNotify(this, "请稍等,上一单还未支付成功。");
            //            return;
            //        }
            //    }
            //}
            //else
            //{
            //    if (this.orderObjects == null)
            //    {
            //        return;
            //    }
            //    int _count = this.orderObjects.Count;

            //    if (_count > 2)
            //    {
            //        this.ShowToastNotify(this, "已超过3单没有支付成功，请处理后操作");
            //        return;
            //    }

            //}

            this.m_IsAnewPay = false;
            switch (name)
            {
                case "现金":
                    {
                        this.ShowCashPay();
                    }
                    break;
                case "离线支付":
                    {
                        this.ShowOfflinePay();
                    }
                    break;
                case "会员卡":
                    {
                        this.ShowMemberPay();
                    }
                    break;
                case "扫码支付":
                    {
                        this.ShowScanCodePay();
                    }
                    break;
                default:
                    break;
            }
        }

        /// <summary>
        /// 删除选中项
        /// </summary>
        /// <param name="OrderNo"></param>
        public bool OrderNoDeleteShoppintRow(string OrderNo)
        {
            if (string.IsNullOrEmpty(OrderNo))
            {
                this.ShowToastNotify(this, "传入的订单号为null");
                return false;
            }

            int _no = 0;

            if (!int.TryParse(OrderNo, out _no))
            {
                this.ShowToastNotify(this, string.Format("传入的订单号不正确 [{0}]", OrderNo));
                return false;
            }

            if (this._orderItem?.OrderNo == _no)
            {
                //通知副屏
                if (Global.Instance.EnableVice)
                {
                    MsgEvent.Send(Constant.VICE_ORDER_NOTIFY, new Tuple<ViceNotifyType, object>(ViceNotifyType.DELETESINGLEITEM, this._orderItem));
                }
                this._orderItem = null;
                return true;
            }

            var _data = this._orderObject.Items.Where(f => f.OrderNo == _no).FirstOrDefault();
            if (_data == null)
            {
                this.ShowToastNotify(this, string.Format("传入的订单号未集合中"));
                return false;
            }
            this._orderObject.Items.Remove(_data);

            //通知副屏
            if (Global.Instance.EnableVice)
            {
                MsgEvent.Send(Constant.VICE_ORDER_NOTIFY, new Tuple<ViceNotifyType, object>(ViceNotifyType.DELETESINGLEITEM, _data));
            }

            return true;
        }

        /// <summary>
        /// 消单
        /// </summary>
        public bool DeleteAllShoppintRow(bool isDialogForm = true)
        {
            bool _return = true;
            this.Invoke((EventHandler)delegate
            {
                if (isDialogForm)
                {
                    if (Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_ORDER_CANCEL_NOTIFY))
                    {
                        MDialogForm dialog = new MDialogForm("操作提醒", "您确定是要进行取消全单操作吗?", MessageBoxIcon.Warning, MessageBoxButtons.OKCancel);

                        if (DialogResult.OK != dialog.ShowDialog(this))
                        {
                            _return = false;
                        }
                       
                    }
                }

                if(_return)
                {
                    this._orderItem = null;
                    this._orderObject.Items = new List<OrderItem>();

                    //通知副屏
                    if (Global.Instance.EnableVice)
                    {
                        MsgEvent.Send(Constant.VICE_ORDER_NOTIFY, new Tuple<ViceNotifyType, object>(ViceNotifyType.CLEARALLITEMS, null));
                    }
                }

            });
            return _return;
        }

        /// <summary>
        /// 模块授权控制
        /// </summary>
        public bool IsAccredit(string permissionName)
        {
            var permissionCode = this.ToPermissionCode(permissionName);
            if (Global.Instance.HasPermission(permissionCode))
            {
                return true;
            }


            var authForm = new AuthDialogForm(permissionName, permissionCode, this._orderObject);
            authForm.ExpectValidate(permissionCode);
            authForm.ShowDialog(this);

            if (authForm.IsAccredit)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 查询当前订单
        /// </summary>
        /// <returns></returns>
        public string GetOrderObject()
        {
            if (this._orderObject == null)
            {
                return null;
            }

            try
            {
                decimal _val = 0M;

                if (_orderItem != null)
                {
                    _val = _orderItem.Amount;
                }


                GuestShowUtils.Instance.DisplayData(CustomerDisplayType.Total, (_val + this._orderObject.Amount).ToString("#.00"));
            }
            catch (Exception e)
            {
                LOGGER.Error(e);
            }

            var _order = PromotionDispose();
            foreach (var item in _order.Items)
            {

                this.m_CefClient.CallbackJsfunction("UpdateShoppingRow", JsonConvert.SerializeObject(item));
            }
            return JsonConvert.SerializeObject(_order);
        }

        /// <summary>
        /// 查询当前项
        /// </summary>
        public string GetThisItme()
        {
            if (this._orderItem == null)
            {
                return null;
            }


            return JsonConvert.SerializeObject(GetOrderItemPromotion(this._orderItem));
        }

        /// <summary>
        /// 重新结账
        /// 注意：该方法可以调起支付界面 也可以调起扣款逻辑，主要通过 payCode参数判断
        /// </summary>
        /// <param name="TradeNo">重新结账单号</param>
        /// <param name="payCode">支付码，可以用来辨别重新结账方式，具体请看代码</param>
        public void AnewPay(string TradeNo, string payCode = null)
        {
            LOGGER.Info("" + payCode);
            if (string.IsNullOrEmpty(TradeNo))
            {
                this.ShowToastNotify(this, "订单号为空，如果无法操作请重新点单操作！");
                return;
            }

            //查询挂起订单
            var _data = this.orderObjects.FirstOrDefault(f => f.TradeNo == TradeNo);

            if (_data == null)
            {
                this.ShowToastNotify(this, "该订单已经不在挂起集合中，请重新点单操作！");
                return;
            }

            if (_data.PayQueryQuantity > 0)
            {
                this.ShowToastNotify(this, "订单还在查询中请稍等再试！");
                return;
            }

            //调起支付界面
            if (this.ShowAnewPay(_data, payCode))
            {
                return;
            }
        }

        /// <summary>
        /// 订单号支付
        /// </summary>
        /// <param name="TradeNo"></param>
        public void TradeNoAnewPay(string TradeNo)
        {
            if (string.IsNullOrEmpty(TradeNo))
            {
                this.ShowToastNotify(this, "订单号为空，如果无法操作请重新点单操作！");
                return;
            }

            //查询挂起订单
            var _data = this.orderObjects.FirstOrDefault(f => f.TradeNo == TradeNo);

            if (_data == null)
            {
                return;
            }

            if (_data.PayQueryQuantity > 0)
            {
                return;
            }

            if (_data.ErrorMessage.Contains("支付中"))
            {
                if (_data.PayCountDown.Day == 1)
                {
                    _data.PayCountDown = DateTime.Now;
                }
                var _midTime = DateTime.Now - _data.PayCountDown;
                var _InPayMentData = new
                {
                    _data.TradeNo,
                    Date = 60 - _midTime.Seconds
                };
                //用户正在输入密码提示
                this.m_CefClient.CallbackJsfunction("ShowInPayMent", JsonConvert.SerializeObject(_InPayMentData));

            }
            else
            {
                var _json = new
                {
                    _data.ErrorMessage,
                    _data.TradeNo
                };
                this.m_CefClient.CallbackJsfunction("ShowAnewPayView", JsonConvert.SerializeObject(_json));
            }
        }

        public bool GetIsAnewPay()
        {
            return this.m_IsAnewPay;
        }

        /// <summary>
        /// html调用的支付
        /// </summary> 
        public void InitiatePay(string PayCode)
        {
            string message = "";

            if (string.IsNullOrEmpty(PayCode))
            {
                message = "支付码错误！";
            }

            if (this._orderItem != null)
            {
                this._orderObject.Items.Add(this._orderItem);
            }

            if (this._orderObject.Items == null || this._orderObject.Items.Count == 0)
            {
                message = "无商品数据";
            }

            //以上判断有错误信息则提示
            if (!string.IsNullOrEmpty(message))
            {
                this.m_CefClient.CallbackJsfunction("SetPayViewMessage", message);
                return;
            }

            PayOperation pay = new PayOperation(this._orderObject, PayCode);

            if (!pay.VerifyParameter())
            {

                this.m_CefClient.CallbackJsfunction("SetPayViewMessage", pay.m_Message);
                return;
            }
            pay.AsyncPayResult = this.PayResultAsyncCallBack;
            this.orderObjects.Add(this._orderObject);
            pay.AsyncPayStart();

            var _paylistjson = new
            {
                no = this._orderObject.TradeNo,
                Time = this._orderObject.SaleDate,
                Money = this._orderObject.ReceivableAmount,
                PayType = pay.m_CurrentPayMode == null ? "移动支付" : pay.m_CurrentPayMode.Name
            };
            this.m_CefClient.CallbackJsfunction("AddOrderPayList", JsonConvert.SerializeObject(_paylistjson));
            this.m_CefClient.CallbackJsfunction("PayViewClose", JsonConvert.SerializeObject(_paylistjson));
            this.DestoryOrderObject(false);
            this.InitOrderData();
        }

        /// <summary>
        /// 初始化
        /// </summary>
        public void Init()
        {
            this.InitOrderData();

            //副屏
            this.LoadingViceScreen();

            this.DestoryOrderObject(false);

            //登录班次
            BusinessUtils.Instance.WorkerLogin();

            //初始化收银员权限
            BusinessUtils.Instance.InitPermission();

            //当前未登录状态
            Global.Instance.IsLogin = true;

            //初始化底部门店信息
            var _StoreInfoName = Global.Instance.Worker.StoreInfo.Name;
            var _posNo = Global.Instance.Authc.PosNo;
            var _No = Global.Instance.Worker.No;
            var _loginDate = Global.Instance.Worker.LastDate;

            var _StaffData = new
            {
                StoreInfoName = Global.Instance.Worker.StoreInfo.Name,
                posNo = Global.Instance.Authc.PosNo,
                No = Global.Instance.Worker.No,
                loginDate = Global.Instance.Worker.LastDate
            };
            this.m_CefClient.CallbackJsfunction("StaffData", JsonConvert.SerializeObject(_StaffData));


            //zhangy 2020-03-13 Add 
            //是否开启小程序订单
            var enableAppletOrder = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_ENABLEAPPLETORDER, false);

            var data = new Dictionary<string, object>();
            data.Add("enable", enableAppletOrder ? 1 : 0);
            data.Add("count", 0);
            //发送界面通知
            this.m_CefClient.CallbackJsfunction("ShowWxProgramOrderNotify", JsonConvert.SerializeObject(data));

#if DEBUG
            this.m_CefClient.ShowDevTools();
#endif
        }

        /// <summary>
        /// 打开核销
        /// </summary>
        public void ShowPayTicket(string _TradeNo = null)
        {
            this.Invoke((EventHandler)delegate
            {
                OrderObject oj = new OrderObject();
                if (_TradeNo == null)
                {
                    oj = this._orderObject;
                }
                else
                {
                    oj = this.orderObjects.FirstOrDefault(f => f.TradeNo == _TradeNo);

                    if (oj == null)
                    {
                        return;
                    }
                }

                //打开提示界面
                var form = new FastMPayChckForm(oj, oj.ReceivableAmount - oj.ReceivedAmount);
                TransparentForm trans = new TransparentForm(this, 0.08, form);
                trans.ShowDialog();

                if (oj.Pays.Count > 0)
                {
                    //保存数据
                    var _result = BusinessUtils.Instance.OrderFinished(oj);
                    if (_result.Item1)
                    {
                        oj.PayState = "支付成功";
                        var _json = new
                        {
                            orderObject = oj,
                            Message = "核销成功",
                            PayType = oj.Pays.FirstOrDefault().Name
                        };
                        //修改界面状态
                        this.m_CefClient.CallbackJsfunction("UpdateAddOrderPayList", JsonConvert.SerializeObject(_json));
                        this.orderObjects.Remove(this.orderObjects.FirstOrDefault(f => f.TradeNo == oj.TradeNo));
                    }
                    else
                    {
                        oj.PayState = "支付失败";
                        var _json = new
                        {
                            orderObject = oj,
                            Message = "核销成功但数据保存失败",
                            PayType = oj.Pays.FirstOrDefault().Name
                        };
                        //修改界面状态
                        this.m_CefClient.CallbackJsfunction("UpdateAddOrderPayList", JsonConvert.SerializeObject(_json));
                    }


                }
            });
        }

        /// <summary>
        /// 网络连接状态
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        protected override void NetworkEventNotify(object sender, MsgEventArgs args)
        {
            base.NetworkEventNotify(sender, args);

            if (IsDisposed || !this.IsHandleCreated) return;

            this.m_CefClient.CallbackJsfunction("ChangNetworkStatus", this.ChangNetworkStatus());
        }

        /// <summary>
        /// 当前网络状态
        /// </summary>
        /// <returns></returns>
        public string ChangNetworkStatus()
        {
            return Global.Instance.Online ? "网络正常" : "网络异常";
        }


        #region 商品信息

        public string GetItemData()
        {

            //var _data = new
            //{
            //    size,
            //    current,
            //    total = (int)Math.Ceiling((decimal)(Global.Product._productList.Count / size)),
            //    data = Global.Product._productList.Skip((current - 1) * size).Take(size)
            //};

            return JsonConvert.SerializeObject(Global.Product._productList);
        }

        public string AddItemData(string id)
        {
            if (string.IsNullOrEmpty(id))
            {
                return null;
            }
            var _data = Global.Product._productList.FirstOrDefault(f => f.Id == id);

            if (_data == null)
            {
                return null;
            }

            IsOrderItemRule(_data);

            var _item = BusinessUtils.Instance.NewOrderItem(this._orderObject, _data, OrderRowState.普通);

            _item.OrderNo = (this._orderObject.Items == null || this._orderObject.Items.Count == 0) ? 1 : this._orderObject.Items.Max(f => f.OrderNo) + 1;
            _item.Quantity = 1;
            _item.SalePrice = _item.Price;

            this._orderObject.Items.Add(_item);
             
            /* 显示数据 */
            this.m_CefClient.CallbackJsfunction("AddNewShoppintRow", JsonConvert.SerializeObject(_item));

            //通知副屏，选中指定行
            if (Global.Instance.EnableVice)
            {
                MsgEvent.Send(Constant.VICE_ORDER_NOTIFY, new Tuple<ViceNotifyType, object>(ViceNotifyType.UPDATEORDERITEM, this._orderItem));
            }
            return "";


        }
        #endregion

        /// <summary>
        /// 用户关闭用户支付界面
        /// </summary>
        /// <param name="id"></param>
        public void IsPayOrderList(string id)
        {
            if (string.IsNullOrEmpty(id))
            {
                return;
            }

            var _data = this.orderObjects.FirstOrDefault(f => f.TradeNo == id);

            if (_data == null)
            {
                return;
            }

            this.IsPayList.Add(_data.Id);
        }
        //================== private function ======================
        /// <summary>
        /// 显示支付界面
        /// </summary>
        /// <param name="_order"></param>
        /// <param name="payCode"></param>
        /// <returns></returns>
        private bool ShowAnewPay(OrderObject _order, string payCode)
        {
            var _Is = false;
            this.m_IsAnewPay = true;
            switch (payCode)
            {
                case "现金":
                    {
                        this.ShowCashPay(_order);
                    }
                    _Is = true;
                    break;
                case "会员卡":
                    {
                        this.ShowMemberPay(_order);
                        _Is = true;
                    }
                    break;
                case "取消订单":
                    {
                        var _data = this.orderObjects.FirstOrDefault(f => f.TradeNo == _order.TradeNo);
                        this.m_IsAnewPay = false;
                        this.PayResultAsyncCallBack(_data, null, "", "订单取消", 0);

                        if (_data != null)
                        {
                            this.m_cancelorders.Add(_data);
                            this.orderObjects.Remove(_data);
                        }
                        _Is = true;

                    }
                    break;
                case null:
                    {
                        //显示扫码支付界面
                        this.m_CefClient.CallbackJsfunction("ShowPayView", JsonConvert.SerializeObject(_order));
                        _Is = true;
                    }
                    break;
                default:
                    {
                        this.ShowScanCodePay(_order, payCode);
                    }
                    break;
            }
            return _Is;
        }

        /// <summary>
        /// 初始化销售数据
        /// </summary>
        private void InitOrderData()
        {
            //初始化订单对象
            this._orderObject = BusinessUtils.Instance.NewOrderObject();
            this._orderObject.TradeNo = OrderUtils.Instance.GenerateTicketNo();

            if (this._orderObject.Pays == null)
                this._orderObject.Pays = new List<PayItem>();
            if (this._orderObject.Items == null)
                this._orderObject.Items = new List<OrderItem>();
            if (this._orderObject.Promotions == null)
                this._orderObject.Promotions = new List<PromotionOrder>();

            this._orderItem = null;
            this.m_CefClient.CallbackJsfunction("DeleteAllShoppintRow", "false");



        }

        /// <summary>
        /// 初始化控件
        /// </summary>
        private void Initialize()
        {
            //登录班次
            BusinessUtils.Instance.WorkerLogin();

            //初始化收银员权限
            BusinessUtils.Instance.InitPermission();

            //窗口初始化
            this.WindowState = FormWindowState.Maximized;

            //初始化cef
            m_CefClient = new CefClientModule<FastTemplate>(this);
            m_CefClient.LoadingStateEvent += this.LoadingStateEvent;

        }

        /// <summary>
        /// 根据金额初始化商品数据
        /// </summary>
        /// <param name="price">金额</param>
        /// <returns></returns>
        private ProductExt BuilderProductExt(decimal price)
        {
            var json = "{\"typeName\":\"自选快餐\",\"unitName\":\"份\",\"specName\":\"\",\"specId\":\"999999\",\"chuda\":\"\",\"chudaFlag\":\"1\",\"chupin\":\"\",\"chupinFlag\":\"0\",\"chuDaLabelFlag\":\"0\",\"chuDaLabel\":\"\",\"chuxianTime\":0,\"kdsChupinTime\":0,\"tenantId\":\"\",\"brandId\":\"\",\"typeId\":\"999999\",\"typePath\":\"999999\",\"no\":\"999999\",\"name\":\"自选快餐\",\"shortName\":\"自选快餐\",\"spell\":\"ZXKC\",\"assistNo\":\"\",\"otherNo\":\"\",\"barCode\":\"999999\",\"english\":\"\",\"unitId\":\"\",\"description\":\"\",\"commissionType\":0,\"commissionValue\":0.0,\"discountFlag\":1,\"suitFlag\":0,\"tapleFlag\":1,\"weighFlag\":1,\"currentFlag\":0,\"mebDiscountFlag\":0,\"giveFlag\":1,\"labelPrintFlag\":1,\"promotionFlag\":0,\"type\":0,\"stockFlag\":1,\"pointType\":0,\"pointValue\":0.0,\"purchaseTax\":17.0,\"saleTax\":0.0,\"lyRate\":0.0,\"stopFlag\":0,\"groupName\":\"\",\"picture\":\"\",\"price\":12.0,\"memberPrice\":11.0,\"costPrice\":8.0,\"otherPrice\":0.0,\"purchasePrice\":8.0,\"minPrice\":11.0,\"dispatchPrice\":8.0,\"specCount\":1,\"kdsFlag\":1,\"ext1\":\"\",\"ext2\":\"\",\"ext3\":\"\",\"id\":\"999999\",\"createUser\":\"sync\",\"createDate\":\"2019-01-25 09:41:12\",\"modifyUser\":\"sync\",\"modifyDate\":\"2019-01-25 09:41:17\"}";

            var product = JsonUtils.Deserialize<ProductExt>(json);

            product.TenantId = Global.Instance.Worker.TenantId;

            product.Price = price;

            product.MemberPrice = price;

            return product;
        }

        /// <summary>
        /// 现金结账
        /// </summary>
        private void QuickPay(OrderObject order, decimal inputMoney = -9999)
        {
            LOGGER.Info("操作现金结账");

            //食堂版本的速结不采用数据金额模式，直接按单结账
            if (inputMoney == -9999)
            {
                inputMoney = order.ReceivableAmount;
            }

            if (!this.m_IsAnewPay)
            {
                var _paylistjson = new
                {
                    no = order.TradeNo,
                    Time = order.SaleDate,
                    Money = order.ReceivableAmount,
                    PayType = "现金支付"
                };
                this.m_CefClient.CallbackJsfunction("AddOrderPayList", JsonConvert.SerializeObject(_paylistjson));
                this.DestoryOrderObject(false);
            }
            var result = BusinessUtils.Instance.QuickPay(order, inputMoney);

            //现金支付成功
            if (result.Item1)
            {
                #region 通知界面 

                order.PayState = "支付成功";
                //通知界面
                var _json = new
                {
                    orderObject = order,
                    Message = "支付成功",
                    PayType = order.Pays.FirstOrDefault()?.Name
                };

                //关闭重新结账标识
                this.m_IsAnewPay = false;


                this.orderObjects.Remove(this.orderObjects.FirstOrDefault(f => f.OrderNo == order.OrderNo));


                //修改界面状态
                this.m_CefClient.CallbackJsfunction("UpdateAddOrderPayList", JsonConvert.SerializeObject(_json));
                #endregion

                this.DestoryOrderObject(false);

                this.InitOrderData();
            }
            else
            {
                #region 通知界面 
                order.PayState = "支付失败";
                //通知界面
                var _json = new
                {
                    orderObject = order,
                    Message = result.Item2,
                    PayType = "人民币"
                };

                //修改界面状态
                this.m_CefClient.CallbackJsfunction("UpdateAddOrderPayList", JsonConvert.SerializeObject(_json));
                #endregion

                this.ShowToastNotify(this, result.Item2);
            }
        }

        /// <summary>
        /// 离线支付结账
        /// </summary>
        private void OfflinePay(OrderObject order, decimal inputMoney = -9999)
        {
            LOGGER.Info("操作离线支付");

            //自动弹出桌号
            if (!ProcessAutoDeskNo())
            {
                return;
            }

            //食堂版本的离线支付
            inputMoney = _orderObject.ReceivableAmount;


            var result = BusinessUtils.Instance.OfflinePay(_orderObject, inputMoney);

            if (result.Item1)
            {
                #region 通知界面 
                var _paylistjson = new
                {
                    no = order.TradeNo,
                    Time = order.SaleDate,
                    Money = order.ReceivableAmount,
                    PayType = "离线支付"
                };
                this.m_CefClient.CallbackJsfunction("AddOrderPayList", JsonConvert.SerializeObject(_paylistjson));

                order.PayState = "支付成功";
                //通知界面
                var _json = new
                {
                    orderObject = order,
                    Message = "支付成功",
                    PayType = order.Pays.FirstOrDefault()?.Name
                };

                //关闭重新结账标识
                this.m_IsAnewPay = false;
                this.orderObjects.Remove(this.orderObjects.FirstOrDefault(f => f.OrderNo == order.OrderNo));
                //修改界面状态
                this.m_CefClient.CallbackJsfunction("UpdateAddOrderPayList", JsonConvert.SerializeObject(_json));
                #endregion

                this.DestoryOrderObject(false);

                this.InitOrderData();
            }
            else
            {
                this.ShowToastNotify(this, result.Item2);
            }
        }

        /// <summary>
        /// 自动弹出桌号
        /// </summary>
        /// <returns></returns>
        private bool ProcessAutoDeskNo()
        {
            if (!string.IsNullOrEmpty(this._orderObject.TableNo))
            {
                //有桌号，不弹
                return true;
            }
            ///自动弹出桌号
            var autoDeskNo = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_CHECKAUTOOPENDESKNO, false);
            if (autoDeskNo)
            {
                var result = SetDeskNo();
                if (result == DialogResult.OK)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return true;
            }
        }

        #region private SetDeskNo 显示选择桌台
        /// <summary>
        /// 显示桌台
        /// </summary>
        /// <returns></returns>
        private DialogResult SetDeskNo()
        {
            var form = new DeskNoForm(this._orderObject);
            form.AcceptButtonClick += (o, args) =>
            {
                var desk = args.Data as Tuple<string, string, string>;
                this._orderObject.TableNo = desk.Item1;
                this._orderObject.TableName = desk.Item2;
                this._orderObject.Ext1 = desk.Item3;
                if (this._orderObject.TableNo != null)
                {
                    //显示桌号
                    MsgEvent.Send(Constant.MSGCENTER_NOTIFY, new MsgEntity() { Subject = Constant.MENU_TITLE_CHANGED_NOTIFY, SubSubject = ModuleKeyCode.桌号.ToString(), Operate = MsgEntityOperate.发布, Data = new Tuple<ModuleKeyCode, MenuTileNotifyType, string>(ModuleKeyCode.桌号, MenuTileNotifyType.数量, _orderObject.TableName) });
                }
            };
            return form.ShowDialog(this);
        }
        #endregion

        #region private DestoryOrderObject 结账完成后流出
        /// <summary>
        /// 结账完成后流出
        /// 1、推送 关闭会员优惠通知
        /// 2、清理副屏
        /// 3、默认初始化订单列表
        /// </summary>
        /// <param name="forced">强制清除结账后数据</param>
        /// <param name="newOrder"></param>
        /// <returns></returns>
        private void DestoryOrderObject(bool forced, bool newOrder = true)
        {
            //关闭会员优惠提醒
            MsgEvent.Send(Constant.HISTORY_CHANGED_NOTIFY, new Tuple<HistoryMsgType, object>(HistoryMsgType.会员优惠, 0));

            //禁止交易完成后立即清除单据信息，显示已结账
            bool allowShowPreOrder = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_NOT_ALLOW_SHOW_PREORDER);

            MsgEvent.Send(Constant.VICE_ORDER_NOTIFY, new Tuple<ViceNotifyType, object>(ViceNotifyType.CLEARALLITEMS, null));
            MsgEvent.Send(Constant.VICE_ORDER_NOTIFY, new Tuple<ViceNotifyType, object>(ViceNotifyType.FINISHEDORDER, null));
            MsgEvent.Send(Constant.VICE_ORDER_NOTIFY, new Tuple<ViceNotifyType, object>(ViceNotifyType.CREATEORDER, this._orderObject));
        }
        #endregion

        #region private NewOrderObject 创建一个订单对象，本单交易完成前，对象唯一存在
        /// <summary>
        ///  创建一个订单对象，本单交易完成前，对象唯一存在
        /// </summary>
        /// <returns></returns>
        private OrderObject NewOrderObject()
        {

            if (this._orderObject == null)
            {
                this._orderObject = BusinessUtils.Instance.NewOrderObject();

                //会员卡号
                //this.lblMemberCardNo.Text = string.Format(this.lblMemberCardNo.Tag.ToString(), string.Empty);
                //会员余额
                //this.lblMemberAmount.Text = string.Format(this.lblMemberAmount.Tag.ToString(), string.Empty);
                //会员积分
                //this.lblMemberPoint.Text = string.Format(this.lblMemberPoint.Tag.ToString(), string.Empty);

                //刷新桌号
                MsgEvent.Send(Constant.MSGCENTER_NOTIFY, new MsgEntity() { Subject = Constant.MENU_TITLE_CHANGED_NOTIFY, SubSubject = ModuleKeyCode.桌号.ToString(), Operate = MsgEntityOperate.发布, Data = new Tuple<ModuleKeyCode, MenuTileNotifyType, string>(ModuleKeyCode.桌号, MenuTileNotifyType.数量, _orderObject.TableName) });

                //默认营业模式
                bool ts = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_ORDERTYPEDEFAULTTS, true);
                if (ts)
                {
                    this._orderObject.OrderType = OrderType.堂食;
                    MsgEvent.Send(Constant.MSGCENTER_NOTIFY, new MsgEntity() { Subject = Constant.MENU_TITLE_CHANGED_NOTIFY, SubSubject = ModuleKeyCode.外带.ToString(), Operate = MsgEntityOperate.发布, Data = new Tuple<ModuleKeyCode, MenuTileNotifyType, string>(ModuleKeyCode.外带, MenuTileNotifyType.名称, OrderType.堂食.ToString()) });
                }
                else
                {
                    this._orderObject.OrderType = OrderType.外带;
                    MsgEvent.Send(Constant.MSGCENTER_NOTIFY, new MsgEntity() { Subject = Constant.MENU_TITLE_CHANGED_NOTIFY, SubSubject = ModuleKeyCode.外带.ToString(), Operate = MsgEntityOperate.发布, Data = new Tuple<ModuleKeyCode, MenuTileNotifyType, string>(ModuleKeyCode.外带, MenuTileNotifyType.名称, OrderType.外带.ToString()) });
                }
            }

            this._orderItem = null;

            return this._orderObject;
        }
        #endregion

        #region private IsOrderItemRule 点菜逻辑过滤方法
        /// <summary>
        /// 商品业务逻辑过滤
        /// 该方法决定本次点的菜是否成功
        /// </summary> 
        private OrderItem IsOrderItemRule(ProductExt product)
        {
            //1、允许销售售价为零的商品
            var allowPriceZero = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_ALLOW_PRICE_ZERO, false);
            if (product.Price <= 0 && !allowPriceZero)
            {
                this.ShowToastNotify(this, "不允许售卖价格为零的商品");
                return null;
            }

            //2、售价为零的商品时提示
            var priceZeroNotify = Global.Instance.GlobalConfigBoolValue(ConfigConstant.CASHIER_PRICE_ZERO_NOTIFY, false);
            if (product.Price <= 0 && priceZeroNotify)
            {
                var dialog = new MDialogForm("提示信息", "您是否要售卖零售价的单品", MessageBoxIcon.Warning, MessageBoxButtons.YesNo);
                //操作员选择了 是
                if (DialogResult.Yes != dialog.ShowDialog(this))
                    return null;
            }

            //创建新的OrderItem
            var master = BusinessUtils.Instance.NewOrderItem(this._orderObject, product, OrderRowState.普通);
            return master;
        }
        #endregion

        #region private AddOrderItem 累加菜品项
        /// <summary>
        /// 累加点菜项
        /// </summary>
        private void AddOrderItem()
        {
            if (this._orderItem == null)
            {
                return;
            }

            if (this._orderObject.Items == null)
            {
                this._orderObject.Items = new List<OrderItem>();
            }

            this._orderItem.OrderId = this._orderObject.Id;
            this._orderObject.Items.Add(this._orderItem);
            this._orderItem = null;
        }
        #endregion

        #region private LoadingViceScreen 加载副屏
        /// <summary>
        /// 加载副屏
        /// </summary>
        private void LoadingViceScreen()
        {
            try
            {
                var enableVice = Global.Instance.GlobalConfigBoolValue(ConfigConstant.DEVICE_VICE_ENABLE);
                if (enableVice)
                {
                    Screen[] sc = Screen.AllScreens;
                    if (sc.Count() > 1)
                    {
                        for (int i = 0; i < sc.Count(); i++)
                        {
                            if (!sc[i].Primary)
                            {
                                this.Invoke((EventHandler)delegate
                                {
                                    ViceScreenForm vice = new ViceScreenForm();
                                    vice.FormBorderStyle = FormBorderStyle.None;
                                    vice.StartPosition = FormStartPosition.Manual;
                                    Point p = new Point(sc[i].Bounds.Location.X, sc[i].Bounds.Location.Y);
                                    vice.Location = p;
                                    vice.WindowState = FormWindowState.Maximized;
                                    vice.Show();
                                });
                                break;
                            }
                        }
                    }
                    else
                    {
                        enableVice = false;
                        LOGGER.Info("设置启用了副屏，但是当前机器只有一块屏幕，不能启动副屏显示");
                    }
                }
                else
                {
                    LOGGER.Info("未启用副屏");
                }
                Global.Instance.EnableVice = enableVice;
            }
            catch (Exception ex)
            {
                LOGGER.Error(ex, "副屏显示异常");
            }
        }
        #endregion

        #region private ToPermissionCode 功能名称转换授权编码
        /// <summary>
        /// 功能名称转换授权编码
        /// </summary>
        /// <param name="permissionName"></param>
        /// <returns></returns>
        private string ToPermissionCode(string permissionName)
        {
            switch (permissionName)
            {
                case "现在找零":
                    return "10019";
                case "现金":
                    return "10019";
                case "会员卡":
                    return "10023";//会员卡查询
                case "营业单据":
                    return "30001";//销售流水
                case "销售汇总":
                    return "30002";
                case "收银报表":
                    return "30003";
                case "营业日报":
                    return "30005";
                case "时段报表":
                    return "30004";
                case "交班查询":
                    return "30008";
                case "会员开户":
                    return "20001";
                case "会员充值":
                    return "20002";
                case "会员信息":
                    return "20005";
                case "会员换卡":
                    return "20004";
                case "开钱箱":
                    return "10020";
                case "设置":
                    return "40001";
                case "交班":
                    return "10036";
                case "消单":
                    return "10001";
                case "删菜":
                    return "10002";
                default:
                    return "";
            }
        }
        #endregion

        #region private MaxSaleMoney 限制最大金额

        /// <summary>
        /// 限制最大金额
        /// </summary>
        /// <param name="_orderItem"></param>
        /// <returns></returns>
        private bool MaxSaleMoney(OrderItem _orderItem)
        {
            var _maxMoney = Global.Instance.GlobalConfigStringValue(ConfigConstant.CONFIG_CASHIER_MAXSALEMONEY);

            decimal Money = 0.00M;
            if (string.IsNullOrEmpty(_maxMoney))
            {
                return true;
            }
            decimal.TryParse(_maxMoney, out Money);


            if (Money == 0)
            {
                return true;
            }

            if (_orderItem.Price > Money)
            {
                this.ShowToastNotify(this, "已超出最大金额,当前设置的最大金额数是:[" + Money.ToString("0.00") + "]");
                _orderItem.MemberPrice = Money;
                _orderItem.Price = Money;
                _orderItem.SalePrice = _orderItem.Price - (_orderItem.Price - _orderItem.MemberPrice);
                this.m_CefClient.CallbackJsfunction("UpdateShoppingRow", JsonConvert.SerializeObject(_orderItem));
                this.m_CefClient.CallbackJsfunction("SetTxt", Money.ToString());
                return false;
            }
            return true;

        }

        #endregion


        #region 支付回掉
        /// <summary>
        /// 异步通知方法
        /// </summary>
        /// <param name="_orderObject"></param>
        /// <param name="_paymodel"></param>
        /// <param name="_payCode"></param>
        /// <param name="message"></param>
        /// <param name="_QueryQuantity"></param>
        private void PayResultAsyncCallBack(OrderObject _orderObject, PayItem _paymodel, string _payCode, string message, int _QueryQuantity)
        {
            if (this.orderObjects == null || this.orderObjects.Count == 0)
            {
                //提示
                return;
            }

            //查询挂起集合
            OrderObject orderdata = this.orderObjects.FirstOrDefault(f => f.TradeNo == _orderObject.TradeNo);

            if (orderdata == null)
            {
                orderdata = this.m_cancelorders.FirstOrDefault(f => f.TradeNo == _orderObject.TradeNo);
            }

            if (orderdata == null)
            {
                LOGGER.Info("有支付成功，但在内存集合中找不到相关订单！");
                return;
            }

            //修改剩余查询次数
            if (this.orderObjects.Remove(orderdata))
            {
                orderdata.PayQueryQuantity = _QueryQuantity;
                orderdata.ErrorMessage = message;
                this.orderObjects.Add(orderdata);
            }

            //支付结果
            if (_paymodel != null)
            {
                //整单状态
                orderdata.OrderStatus = OrderStatus.已完成;

                //整单支付状态
                orderdata.PaymentStatus = OrderPaymentStatus.已付款;

                _paymodel.OrderId = orderdata.Id;

                if (_paymodel.No == "02")
                {
                    //会员卡支付特殊处理，因为调用了原来的会员卡支付逻辑，支付数据在原来的逻辑里生成了，所以无需再此再生成一次
                    var _Pay = orderdata.Pays.FirstOrDefault(f => f.No == "02");

                    if (_Pay == null)
                    {
                        //插入
                        orderdata.Pays.Add(_paymodel);
                    }
                }
                else
                {
                    orderdata.Pays.Add(_paymodel);
                }



                //关闭重新结账标识
                this.m_IsAnewPay = false;


                if (Global.Instance.IsStudyMode())
                {
                    this.ShowToastNotify(this, "注意：练习模式不会保存销售流水！");
                    return;
                }

                //保存数据
                var _result = BusinessUtils.Instance.OrderFinished(orderdata);

                //界面信息 
                if (_result.Item1)
                {
                    _QueryQuantity = 0;
                    orderdata.PayState = "支付成功";
                    message = "支付成功";
                    this.orderObjects.Remove(orderdata);
                }
                else
                {
                    //报错订单失败
                    orderdata.PayState = "保存失败";

                    message += "\\t\\n已支付成功，但数据保存失败！";
                }
            }
            else
            {
                //按钮文案
                {
                    if (message.Contains("支付中"))
                    {
                        orderdata.PayState = "正在支付";
                    }
                    else if (message.Contains("订单取消"))
                    {
                        orderdata.PayState = "订单取消";
                    }
                    else
                    {
                        orderdata.PayState = "支付失败";
                    }
                }

                //强行提示
                {
                    if (Global.Instance.GlobalConfigBoolValue(ConfigConstant.CONFIG_CASHIER_ISPAYDEFEATEDREMING))
                    {
                        if (!message.Contains("支付中"))
                        {
                            this.m_CefClient.CallbackJsfunction("InPayMentHide", orderdata.TradeNo);
                            if (orderdata.PayState != "订单取消")
                            {
                                this.IsPayList.Remove(orderdata.Id);
                                //重新结账 
                                this.m_CefClient.CallbackJsfunction("ShowAnewPayView", JsonConvert.SerializeObject(new
                                {
                                    ErrorMessage = message,
                                    orderdata.TradeNo
                                }));
                            }
                        }
                    }

                    //用户需要输入密码，直到支付渠道关闭支付
                    if (message.Contains("支付中"))
                    {
                        if (this.IsPayList.FirstOrDefault(l => l == orderdata.Id) == null)
                        {

                            if (orderdata.PayCountDown.Day == 1)
                            {
                                orderdata.PayCountDown = DateTime.Now;
                            }
                            var _midTime = DateTime.Now - orderdata.PayCountDown;
                            var _InPayMentData = new
                            {
                                orderdata.TradeNo,
                                Date = 60 - _midTime.Seconds
                            };
                            //用户正在输入密码提示
                            this.m_CefClient.CallbackJsfunction("ShowInPayMent", JsonConvert.SerializeObject(_InPayMentData));
                        }
                    }
                }

                //浮动提示文案
                {
                    if (message.Contains("支付中"))
                    {
                        message = "用户正在输入密码";
                    }
                    else
                    {
                        if (!message.Equals("订单已被取消"))
                        {
                            message += (_QueryQuantity == 0 ? "" : " \\t\\n查询剩余次数：" + _QueryQuantity);
                        }
                    }
                }
            }

            var _json = new
            {
                orderObject = orderdata,
                Message = message,
                PayType = _paymodel?.Name
            };


            //修改当前弹出正在支付界面的状态，无弹出不是该订单则不会影响
            this.m_CefClient.CallbackJsfunction("InPayMentStatusUpdate", JsonConvert.SerializeObject(_json));

            //修改界面状态
            this.m_CefClient.CallbackJsfunction("UpdateAddOrderPayList", JsonConvert.SerializeObject(_json));
        }
        #endregion 

        private OrderObject PromotionDispose()
        {
            var _amy1 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_PROMOTION_ORDER_AMOUNT1, "");
            var _amy2 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_PROMOTION_ORDER_AMOUNT2, "");
            var _amy3 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_PROMOTION_ORDER_AMOUNT3, "");
            var _amy4 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_PROMOTION_ORDER_AMOUNT4, "");
            var _amy5 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_PROMOTION_ORDER_AMOUNT5, "");
            var _amy6 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_PROMOTION_ORDER_AMOUNT6, "");
            var _oi = JsonConvert.DeserializeObject<OrderObject>(JsonConvert.SerializeObject(_orderObject));
            if (!string.IsNullOrEmpty(_amy1) || !string.IsNullOrEmpty(_amy2) || !string.IsNullOrEmpty(_amy3))
            {
                var _kta1 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_KNOCK_THE_AMOUNT1, "");
                var _kta2 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_KNOCK_THE_AMOUNT2, "");
                var _kta3 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_KNOCK_THE_AMOUNT3, "");
                 
                Dictionary<decimal, decimal> _ktas = new Dictionary<decimal, decimal>();

                if (!string.IsNullOrEmpty(_amy1))
                {
                    _ktas.Add(decimal.Parse(_amy1), decimal.Parse(_kta1));
                }
                if (!string.IsNullOrEmpty(_amy2))
                {
                    _ktas.Add(decimal.Parse(_amy2), decimal.Parse(_kta2));
                }
                if (!string.IsNullOrEmpty(_amy3))
                {
                    _ktas.Add(decimal.Parse(_amy3), decimal.Parse(_kta3));
                }



                _ktas = _ktas.OrderByDescending(f => f.Key).ToDictionary(f => f.Key, o => o.Value);
                if (_orderItem != null)
                {
                    _oi.Items.Add(_orderItem);
                }
                foreach (var item in _ktas)
                {
                    if (item.Key <= _oi.Amount)
                    {
                        //满足促销
                        KnocktheAmountDispose(_oi, item.Value, PromotionType.整单立减);

                        return _oi;
                    }
                }
            }
            else if(!string.IsNullOrEmpty(_amy4) || !string.IsNullOrEmpty(_amy5) || !string.IsNullOrEmpty(_amy6))
            {
                var _da1 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_PROMOTION_DISCOUNT_AMOUNT1, "");
                var _da2 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_PROMOTION_DISCOUNT_AMOUNT2, "");
                var _da3 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_PROMOTION_DISCOUNT_AMOUNT3, "");

                Dictionary<decimal, decimal> _ktas = new Dictionary<decimal, decimal>();

                if (!string.IsNullOrEmpty(_amy4))
                {
                    _ktas.Add(decimal.Parse(_amy4), decimal.Parse(_da1));
                }
                if (!string.IsNullOrEmpty(_amy5))
                {
                    _ktas.Add(decimal.Parse(_amy5), decimal.Parse(_da2));
                }
                if (!string.IsNullOrEmpty(_amy6))
                {
                    _ktas.Add(decimal.Parse(_amy6), decimal.Parse(_da3));
                }

                _ktas = _ktas.OrderByDescending(f => f.Key).ToDictionary(f => f.Key, o => o.Value);
                if (_orderItem != null)
                {
                    _oi.Items.Add(_orderItem);
                }
                foreach (var item in _ktas)
                { 
                    if (item.Key <= _oi.Amount)
                    { 
                        //满足促销
                        KnocktheAmountDispose(_oi, _oi.Amount - ((_oi.Amount ) * (item.Value / 100)) , PromotionType.整单折扣);

                        return _oi;
                    }
                }
            }

            return _oi;
        }

        private OrderItem GetOrderItemPromotion(OrderItem _item)
        {
            var _oi = JsonConvert.DeserializeObject<OrderItem>(JsonConvert.SerializeObject(_item));

            var _amy1 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_PROMOTION_ORDER_AMOUNT1, "");
            var _amy2 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_PROMOTION_ORDER_AMOUNT2, "");
            var _amy3 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_PROMOTION_ORDER_AMOUNT3, "");
            var _amy4 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_PROMOTION_ORDER_AMOUNT4, "");
            var _amy5 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_PROMOTION_ORDER_AMOUNT5, "");
            var _amy6 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_PROMOTION_ORDER_AMOUNT6, "");

            if (!string.IsNullOrEmpty(_amy1) || !string.IsNullOrEmpty(_amy2) || !string.IsNullOrEmpty(_amy3))
            {
                var _kta1 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_KNOCK_THE_AMOUNT1, "");
                var _kta2 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_KNOCK_THE_AMOUNT2, "");
                var _kta3 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_KNOCK_THE_AMOUNT3, "");

                Dictionary<decimal, decimal> _ktas = new Dictionary<decimal, decimal>();

                if (!string.IsNullOrEmpty(_amy1))
                {
                    _ktas.Add(decimal.Parse(_amy1), decimal.Parse(_kta1));
                }
                if (!string.IsNullOrEmpty(_amy2))
                {
                    _ktas.Add(decimal.Parse(_amy2), decimal.Parse(_kta2));
                }
                if (!string.IsNullOrEmpty(_amy3))
                {
                    _ktas.Add(decimal.Parse(_amy3), decimal.Parse(_kta3));
                }



                _ktas = _ktas.OrderByDescending(f => f.Key).ToDictionary(f => f.Key, o => o.Value);

                foreach (var item in _ktas)
                { 
                    if (item.Key <= _oi.Amount + _orderObject.Amount)
                    {
                        if (_orderObject.Items.Sum(f=>f.DiscountAmount) >= item.Value )
                        {
                            return _oi;
                        }

                        PromotionItem promotionItem = new PromotionItem();
                        promotionItem.Amount = _oi.Amount + _orderObject.Amount;
                        promotionItem.DiscountAmount = item.Value;//优惠金额
                        if (promotionItem.DiscountAmount != 0)
                        {
                            promotionItem.DiscountRate = DecimalUtils.ToRound(promotionItem.DiscountAmount / promotionItem.Amount, 2);//优惠率
                        }

                        promotionItem.Enabled = true;
                        promotionItem.FinishDate = _orderObject.CreateDate;//完成时间
                        promotionItem.Id = IdWorkerUtils.Instance.NextId();
                        promotionItem.ItemId = _orderObject.Id;//行ID
                        promotionItem.OrderId = _orderObject.Id;//
                        promotionItem.PlanName = "促销立减";//班次编号
                        promotionItem.PromotionType = PromotionType.外卖扣费;
                        promotionItem.ReceivableAmount = _orderObject.ReceivableAmount;
                        promotionItem.RelationId = "";
                        promotionItem.TenantId = Global.Instance.Authc.TenantId;//租户ID
                        promotionItem.TradeNo = _orderObject.TradeNo;//订单编号
                        promotionItem.CreateDate = _orderObject.CreateDate;//创建时间
                        promotionItem.CreateUser = "1001";//创建人
                        _oi.Promotions.Add(promotionItem);
                        return _oi;
                    }
                }
            }
            else if (!string.IsNullOrEmpty(_amy4) || !string.IsNullOrEmpty(_amy5) || !string.IsNullOrEmpty(_amy6))
            {
                var _da1 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_PROMOTION_DISCOUNT_AMOUNT1, "");
                var _da2 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_PROMOTION_DISCOUNT_AMOUNT2, "");
                var _da3 = Global.Instance.GlobalConfigStringValue(ConfigConstant.CASHIER_PROMOTION_DISCOUNT_AMOUNT3, "");

                Dictionary<decimal, decimal> _ktas = new Dictionary<decimal, decimal>();

                if (!string.IsNullOrEmpty(_amy4))
                {
                    _ktas.Add(decimal.Parse(_amy4), decimal.Parse(_da1));
                }
                if (!string.IsNullOrEmpty(_amy5))
                {
                    _ktas.Add(decimal.Parse(_amy5), decimal.Parse(_da2));
                }
                if (!string.IsNullOrEmpty(_amy6))
                {
                    _ktas.Add(decimal.Parse(_amy6), decimal.Parse(_da3));
                }

                _ktas = _ktas.OrderByDescending(f => f.Key).ToDictionary(f => f.Key, o => o.Value);

                foreach (var item in _ktas)
                {

                    if (item.Key <= this._orderObject.Amount + _orderItem.Amount)
                    {
                        if (item.Key <= _oi.Amount + _orderObject.Amount)
                        {
                            if (_orderObject.Items.Sum(f => f.DiscountAmount) >= item.Value )
                            {
                                return _oi;
                            }

                            PromotionItem promotionItem = new PromotionItem();
                            promotionItem.Amount = _oi.Amount + _orderObject.Amount;
                            promotionItem.DiscountAmount =( _oi.Amount + _orderObject.Amount) - ((this._orderObject.Amount + _orderItem.Amount) * (item.Value / 100));//优惠金额
                            if (promotionItem.DiscountAmount != 0)
                            {
                                promotionItem.DiscountRate = DecimalUtils.ToRound(promotionItem.DiscountAmount / promotionItem.Amount, 2);//优惠率
                            }

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

            return _oi;
        }

        private void KnocktheAmountDispose(OrderObject orderObject, decimal _amy, PromotionType promotionType)
        {
            var i = 0;
            orderObject.Items.ForEach(f => f.Promotions = new List<PromotionItem>());


            foreach (var order in orderObject.Items)
            {
                if (i == orderObject.Items.Count() - 1)
                {
                    order.Discount = Math.Abs(_amy) - orderObject.DiscountAmount;
                }
                else
                {
                    order.Discount = (order.Amount / orderObject.Amount) * Math.Abs(_amy);
                }
                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 = orderObject.CreateDate;//完成时间
                promotionItem.Id = IdWorkerUtils.Instance.NextId();
                promotionItem.ItemId = order.Id;//行ID
                promotionItem.OrderId = orderObject.Id;//
                promotionItem.PlanName = "促销立减";//班次编号
                promotionItem.PromotionType = promotionType;
                promotionItem.ReceivableAmount = order.ReceivableAmount;
                promotionItem.RelationId = "";
                promotionItem.TenantId = Global.Instance.Authc.TenantId;//租户ID
                promotionItem.TradeNo = orderObject.TradeNo;//订单编号
                promotionItem.CreateDate = orderObject.CreateDate;//创建时间
                promotionItem.CreateUser = "ShiTan";//创建人
                order.Promotions.Add(promotionItem);

            }
        }

        //================== 会员、现金、扫码支付 ===================== 

        #region 支付接口
        private void ShowMemberPay(OrderObject order = null)
        {
            this.Invoke((EventHandler)delegate
            {

                OrderObject _data = null;
                if (order != null)
                {
                    _data = order;
                }
                else
                {
                    _data = ObjectUtils.Copy(this._orderObject);
                }

                var dialogForm = new MCardDialogForm(_data);
                dialogForm.AcceptButtonClick += (o, args) =>
                {
                    if (order == null)
                    {
                        if (this.orderObjects.FirstOrDefault(f => f.TradeNo == _data.TradeNo) == null)
                        {
                            this.orderObjects.Add(_data);
                            var _paylistjson = new
                            {
                                no = _data.TradeNo,
                                Time = _data.SaleDate,
                                Money = _data.ReceivableAmount,
                                PayType = "会员卡"
                            };
                            this.m_CefClient.CallbackJsfunction("AddOrderPayList", JsonConvert.SerializeObject(_paylistjson));

                            this.DestoryOrderObject(false);
                            this.InitOrderData();
                        }
                    }
                };

                dialogForm.CancelButtonClick += (o, args) => { };

                TransparentForm trans = new TransparentForm(this, 0.08, dialogForm);
                trans.ShowDialog();
                var _paymodel = _data.Pays.FirstOrDefault(f => f.No == "02");
                if (_paymodel != null)
                {
                    #region 通知界面  
                    _data.PayState = "支付成功";
                    //通知界面
                    var _json = new
                    {
                        orderObject = _data,
                        Message = "支付成功",
                        PayType = "会员卡"
                    };
                    //关闭重新结账标识
                    this.m_IsAnewPay = false;
                    this.PayResultAsyncCallBack(_data, _paymodel, "", "", 0);
                    //修改界面状态
                    this.m_CefClient.CallbackJsfunction("UpdateAddOrderPayList", JsonConvert.SerializeObject(_json));
                    this.orderObjects = new List<OrderObject>();
                    this.InitOrderData();
                    #endregion
                }
                else
                {
                    #region 通知界面  
                    _data.PayState = "支付失败";
                    //通知界面
                    var _json = new
                    {
                        orderObject = _data,
                        Message = "支付失败",
                        PayType = "会员卡"
                    };

                    //修改界面状态
                    this.m_CefClient.CallbackJsfunction("UpdateAddOrderPayList", JsonConvert.SerializeObject(_json));
                    #endregion
                }
            });
        }

        private void ShowCashPay(OrderObject order = null)
        {
            OrderObject _data = null;
            if (order != null)
            {
                _data = order;
            }
            else
            {
                _data = ObjectUtils.Copy(this._orderObject);
            }

            //var dialogForm = new CashDialogForm(_data);
            //dialogForm.AcceptButtonClick += (o, args) =>
            //{
            //decimal inputMoney = Convert.ToDecimal(args.Data);

            if (order == null)
                this.orderObjects.Add(_data);

            if (Global.Instance.IsStudyMode())
            {
                this.ShowToastNotify(this, "注意：练习模式不会保存销售流水！");
            }

            this.QuickPay(_data);
            //};

            //dialogForm.CancelButtonClick += (o, args) => { };

            //TransparentForm trans = new TransparentForm(this, 0.08, dialogForm);
            //trans.ShowDialog(this);
        }

        private void ShowOfflinePay(OrderObject order = null)
        {
            this.OfflinePay(this._orderObject);
        }

        private void ShowScanCodePay(OrderObject _data = null, string payCode = null)
        {
            if (_data == null)
            {
                this.m_CefClient.CallbackJsfunction("ShowPayView", JsonConvert.SerializeObject(this._orderObject));
                return;
            }

            PayOperation pay = new PayOperation(_data, payCode);
            if (!pay.VerifyParameter())
            {
                this.m_CefClient.CallbackJsfunction("SetPayViewMessage", pay.m_Message);
                return;
            }
            pay.AsyncPayResult = this.PayResultAsyncCallBack;
            pay.AsyncPayStart();

            var _paylistjson = new
            {
                no = _data.TradeNo,
                Money = _data.ReceivableAmount,
                PayType = pay.m_CurrentPayMode == null ? "移动支付" : pay.m_CurrentPayMode.Name
            };
            this.m_CefClient.CallbackJsfunction("PayViewClose", JsonConvert.SerializeObject(_paylistjson));

        }
        #endregion

        #region 加载界面动画
        private void LoadingStateEvent(bool IsLoadStatus, string Message)
        {
            this.Invoke((EventHandler)delegate
            {
                try
                {
                    if (loading == null)
                    {
                        loading = new Loading();
                    }


                    if (IsLoadStatus)
                    {
                        loading.BringToFront();
                        loading.Show(this);
                    }
                    else
                    {
                        loading.Dispose();
                        loading.Close();
                    }
                }
                catch
                {

                }
            });
        }
        #endregion

    }
}