using LinqToDB;
using LinqToDB.SqlQuery;
using log4net;
using log4net.Util;
using MasaBlazorApp3.DataAccess.Dao;
using MasaBlazorApp3.Pages;
using MasaBlazorApp3.Pojo;
using MasaBlazorApp3.Pojo.Config;
using MasaBlazorApp3.Pojo.Vo;
using MasaBlazorApp3.Port;
using Microsoft.Extensions.Options;
using Mysqlx.Crud;
using Radzen.Blazor.Rendering;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MasaBlazorApp3.DataAccess.Impl
{
    public class OrderInfoDao : IOrderInfoDao
    {

        private readonly SettingConfig _setting;
        private AppDataConnection _connection;
        private GlobalStateService _globalStateService;
        private readonly ILog logger = LogManager.GetLogger(typeof(OrderInfoDao));
        private readonly PortUtil _portUtil;

        public OrderInfoDao(AppDataConnection connection, IOptions<SettingConfig> setting, GlobalStateService globalStateService, PortUtil portUtil)
        {
            _connection = connection;
            _setting = setting.Value;
            _globalStateService = globalStateService;
            _portUtil = portUtil;
        }

        public async Task<PageData<OrderInfo>> GetAllOrderInfo(string OrderrNo, DateTime OrderDate, int? take, int? skip)
        {
            //var query = _connection.OrderInfo.AsQueryable();

            //query.InnerJoin<OrderDetail>((oi, od) => oi.OrderNo == od.OrderNo);

            var query2 = from od in _connection.OrderDetail
                         from cl in _connection.ChannelStock.Where(c => c.MachineId == _setting.machineId).InnerJoin(c => c.DrugId == od.DrugId)
                         group od by od.OrderNo into temp
                         select new { temp.Key };
            var query = from oi in _connection.OrderInfo
                        from od in query2.InnerJoin(od => od.Key == oi.OrderNo)
                        select oi;

            if (!String.IsNullOrEmpty(OrderrNo))
            {
                query = query.Where(oi => oi.OrderNo.Equals(OrderrNo));
            }
            if (OrderDate != null && OrderDate != DateTime.MinValue)
            {
                query = query.Where(oi => oi.OrderDate.Date.Equals(OrderDate.Date));
            }

            query = query.Where(oi => oi.Status == 0);
            query = query.Where(oi => oi.HisDispFlag == 0);
            query = query.Where(oi => oi.CancelFlag == 0);


            int pagedData = await query.CountAsync();

            List<OrderInfo> list = await query
                //.LoadWith(oi => oi.Detail)
                //.LoadWith(oi => oi.Detail.Drug)
                .OrderBy((oi) => oi.RecvDate)
                .ThenBy((oi => oi.OrderNo))
                .Skip((int)skip)
                .Take((int)take)
                .ToListAsync();


            return new PageData<OrderInfo>()
            {
                TotalDesserts = pagedData,
                Desserts = list
            };
        }

        public async Task<List<OrderDetail>> getDetailByOrderNo(string OrderrNo)
        {
            var query2 = from cl in _connection.ChannelStock
                         where cl.MachineId == _setting.machineId
                         group cl by cl.DrugId into temp
                         select new { temp.Key };
            ;


            var query = from od in _connection.OrderDetail.Where(od => od.OrderNo == OrderrNo)
                        from cl in query2.InnerJoin(c => c.Key == od.DrugId)
                        orderby od.DrugId
                        select od;

            query = query.LoadWith(od => od.Drug);

            return await query.ToListAsync();
        }

        public async Task<List<ChannelStock>> GetChannelStockByDrugId(string DrugId, String ManuNo, int quantity = 0)
        {
            var query = _connection.ChannelStock.AsQueryable();


            query = query.Where(cs => cs.MachineId.Equals(_setting.machineId)).Where(cs => cs.DrawerType == 1)
                .Where(cs => cs.Quantity > 0)
                .Where(cs => cs.DrugId.Equals(DrugId));

            if (quantity > 0)
            {
                if (!String.IsNullOrEmpty(ManuNo))
                {
                    query = query.Where(cs => cs.ManuNo.Equals(ManuNo));
                }
            }
            else
            {
                if (!String.IsNullOrEmpty(ManuNo))
                {
                    query = query.Where(cs => cs.ManuNo.Equals(ManuNo) || cs.Quantity == 0);
                }
            }


            return await query.OrderBy((cs) => cs.EffDate)
                        .ThenBy((cs) => cs.DrawerNo)
                        .ThenBy((cs) => cs.ColNo)
                        .ToListAsync();
        }

        public async Task<List<OrderTakeVo>> getTakeInfoByOrderNo(string OrderrNo)
        {
            List<OrderTakeVo> tempData = new();
            List<OrderTakeVo> tempData2 = new();
            List<OrderDetail> details = await this.getDetailByOrderNo(OrderrNo);
            var flag = true;
            for (var i = 0; i < details.Count; i++)
            {
                //List<IDictionary<string, object>> tempData = new();
                OrderDetail detail = details[i];
                // 当前detail取药数量
                var Quantity = detail.Quantity;
                List<ChannelStock> stockList = await this.GetChannelStockByDrugId(detail.DrugId, detail.SetManuNo, Quantity);

                // 当前药品的库存总量
                var total = stockList.Sum(current => current.Quantity);

                tempData2.Add(new OrderTakeVo()
                {
                    Drug = detail.Drug,
                    OrderDetail = detail,
                    StockQuantity = total,
                    Quantity = Quantity
                });

                if (flag)
                {
                    // 盘点库存是否足够
                    if (total > Quantity)
                    {

                        for (var j = 0; Quantity > 0; j++)
                        {
                            ChannelStock stock = stockList[j];
                            if (Quantity > stock.Quantity)
                            {
                                // 取药数量大于库存
                                tempData.Add(new OrderTakeVo()
                                {
                                    Drug = detail.Drug,
                                    OrderDetail = detail,
                                    ChannelStock = stock,
                                    StockQuantity = total,
                                    Quantity = stock.Quantity,
                                });
                                Quantity -= stock.Quantity;
                            }
                            else
                            {
                                //取药数量小于库存
                                tempData.Add(new OrderTakeVo()
                                {
                                    Drug = detail.Drug,
                                    OrderDetail = detail,
                                    ChannelStock = stock,
                                    StockQuantity = total,
                                    Quantity = Quantity,
                                });
                                Quantity = 0;
                            }
                        }
                    }
                    else
                    {
                        // 库存不足
                        flag = false;
                    }
                }

            }
            if (flag)
            {
                return tempData;
            }
            else
            {
                return tempData2;
            }
        }

        public async Task<bool> OrderTakeFinish(List<OrderTakeVo> datas)
        {

            try
            {
                _connection.BeginTransaction();
                var flag = true;
                // 更新处方状态
                int r1 = _connection.OrderInfo.Where(oi => oi.OrderNo == datas.First().OrderDetail.OrderNo)
                        .Set(oi => oi.Status, 1)
                        .Update();
                if (!(r1 > 0))
                {
                    flag = false;
                    logger.Error("处方取药完成更新处方状态失败");
                    _connection.RollbackTransaction();
                    return flag;
                }
                for (var i = 0; i < datas.Count; i++)
                {
                    var orderTakeVo = datas[i];
                    var EffDate = orderTakeVo.ChannelStock.EffDate;
                    if (!DateTime.TryParse(orderTakeVo.ChannelStock.EffDate, out DateTime dEffDate))
                    {
                        //效期转换出错
                        if (orderTakeVo.ChannelStock.EffDate != null)
                        {
                            string[] idate = orderTakeVo.ChannelStock.EffDate.Split('/');
                            foreach (string iS in idate)
                            {
                                if (!string.IsNullOrEmpty(iS.Trim()))
                                {
                                    switch (iS.Trim().Length)
                                    {
                                        case 4:
                                            EffDate = iS.Trim();
                                            break;
                                        case 2:
                                            EffDate += "-" + iS.Trim();
                                            break;
                                        case 1:
                                            EffDate += "-0" + iS.Trim();
                                            break;
                                    }
                                }
                            }


                        }
                    }
                    else
                    {
                        EffDate = dEffDate.ToString("yyyy-MM-dd");
                    }
                    // 出库记录
                    int mid = _connection.InsertWithInt32Identity(new MachineRecord()
                    {
                        MachineId = _setting.machineId,
                        DrawerNo = orderTakeVo.ChannelStock.DrawerNo,
                        ColNo = orderTakeVo.ChannelStock.ColNo,
                        DrugId = orderTakeVo.ChannelStock.DrugId,
                        ManuNo = orderTakeVo.ChannelStock.ManuNo,
                        EffDate = !String.IsNullOrEmpty(EffDate) ? DateTime.ParseExact(EffDate, "yyyy-MM-dd", System.Globalization.CultureInfo.CurrentCulture) : null,
                        OperationTime = DateTime.Now,
                        Type = 2,
                        Quantity = orderTakeVo.GetQuantity,
                        Operator = _globalStateService.Operator.Id,
                        Reviewer = _globalStateService.Reviewer?.Id ?? _globalStateService.Operator.Id,
                        InvoiceId = orderTakeVo.OrderDetail.Id.ToString(),
                    });
                    // 更新库存
                    int r = _connection.ChannelStock.Where(cs => cs.Id == orderTakeVo.ChannelStock.Id)
                        .Set(cs => cs.Quantity, orderTakeVo.ChannelStock.Quantity - orderTakeVo.GetQuantity)
                        .Update();
                    // 获取更新完库存之后的药品库存
                    List<ChannelStock> list = await _connection.ChannelStock.AsQueryable()
                         .InnerJoin(
                             _connection.ChannelList.Where(cl => cl.MachineId.Equals(_setting.machineId)).Where(cl => cl.DrawerType == 1),
                             (cs, cl) => cs.ListId == cl.Id,
                             (cs, cl) => cs
                         )
                         .Where(cs => cs.DrugId.Equals(orderTakeVo.ChannelStock.DrugId))
                         .ToListAsync();
                    // 保存账册
                    int acid = _connection.InsertWithInt32Identity(new AccountBook()
                    {
                        MachineId = _setting.machineId,
                        DrugId = orderTakeVo.ChannelStock.DrugId,
                        ManuNo = orderTakeVo.ChannelStock.ManuNo,
                        EffDate = !String.IsNullOrEmpty(EffDate) ? DateTime.ParseExact(EffDate, "yyyy-MM-dd", System.Globalization.CultureInfo.CurrentCulture) : null,
                        OperationTime = DateTime.Now,
                        Type = 2,
                        OutQuantity = orderTakeVo.GetQuantity,
                        AddQuantity = 0,
                        Operator = _globalStateService.Operator.Id,
                        Reviewer = _globalStateService.Reviewer?.Id ?? _globalStateService.Operator.Id,
                        ManuStock = list.Where(it => it.ManuNo == orderTakeVo.ChannelStock.ManuNo).Sum(it => it.Quantity),
                        TotalStock = list.Sum(it => it.Quantity),
                        InvoiceId = orderTakeVo.OrderDetail.Id.ToString()
                    });
                    if (mid > 0 && r > 0 && acid > 0)
                    {
                        if (orderTakeVo.ChannelStock.BoardType.ToString().Contains("5"))
                        {
                            await _portUtil.WriteQuantityMethod(orderTakeVo.ChannelStock.Quantity - orderTakeVo.GetQuantity, orderTakeVo.ChannelStock.DrawerNo, orderTakeVo.ChannelStock.ColNo);
                        }

                    }
                    else
                    {
                        flag = false;
                        break;
                    }
                }
                if (flag)
                {
                    _connection.CommitTransaction();
                }
                else
                {
                    _connection.RollbackTransaction();
                }
                return flag;

            }
            catch (Exception ex)
            {
                logger.Error("处方取药完成保存数据库失败，错误：" + ex.Message);
                _connection.RollbackTransaction();
                return false;
            }
        }

        public async Task<PageData<OrderInfo>> GetAllCanReturnOrderInfo(string OrderrNo, DateTime OrderDate, int? take, int? skip)
        {
            var query2 = from od in _connection.OrderDetail
                         from cl in _connection.ChannelStock.Where(c => c.MachineId == _setting.machineId).InnerJoin(c => c.DrugId == od.DrugId)
                         group od by od.OrderNo into temp
                         select new { temp.Key };
            var query = from oi in _connection.OrderInfo
                        from od in query2.InnerJoin(od => od.Key == oi.OrderNo)
                        select oi;

            if (!String.IsNullOrEmpty(OrderrNo))
            {
                query = query.Where(oi => oi.OrderNo.Equals(OrderrNo));
            }
            if (OrderDate != null && OrderDate != DateTime.MinValue)
            {
                query = query.Where(oi => oi.OrderDate.Date.Equals(OrderDate.Date));
            }

            query = query.Where(oi => oi.Status == 1);
            query = query.Where(oi => oi.CancelFlag == 1);


            int pagedData = await query.CountAsync();

            List<OrderInfo> list = await query
                .OrderBy((oi) => oi.RecvDate)
                .ThenBy((oi => oi.OrderNo))
                .Skip((int)skip)
                .Take((int)take)
                .ToListAsync();


            return new PageData<OrderInfo>()
            {
                TotalDesserts = pagedData,
                Desserts = list
            };
        }

        public async Task<List<MachineRecord>> GetMachineRecordByOrderNo(string OrderrNo)
        {
            var query = _connection.MachineRecord.AsQueryable();
            query = query.InnerJoin(
                    _connection.OrderDetail.Where(od => od.OrderNo.Equals(OrderrNo)),
                    (mr, od) => mr.InvoiceId.Equals(od.Id),
                    (mr, od) => mr
                    )
                    .Where(md => md.Type == 2)
                    .LoadWith(md => md.Drug)
                ;
            return await query.ToListAsync();
        }

        public async Task<List<OperationVo<MachineRecord>>> getReturnInfoByOrderNo(string OrderrNo)
        {
            List<OperationVo<MachineRecord>> tempData = new();
            List<MachineRecord> details = await this.GetMachineRecordByOrderNo(OrderrNo);
            for (var i = 0; i < details.Count; i++)
            {
                //List<IDictionary<string, object>> tempData = new();
                MachineRecord detail = details[i];
                List<ChannelStock> stockList = await this.GetChannelStockByDrugId(detail.DrugId, detail.ManuNo);


                // 当前药品的库存总量
                var total = stockList.Sum(current => current.Quantity);
                // 当前detail出库数量
                var Quantity = detail.Quantity;

                stockList.First().AddQuantity = Quantity;

                tempData.Add(new OperationVo<MachineRecord>()
                {
                    Drug = detail.Drug,
                    data = detail,
                    StockQuantity = total,
                    Quantity = Quantity,
                    ChannelStocks = stockList,
                });

            }
            return tempData;
        }

        public async Task<DrugManuNo> GetDrugManuNo(string drugId, string manuNo)
        {
            var query = _connection.DrugManuNo.AsQueryable();

            return await query.Where(m => m.DrugId.Equals(drugId))
                .Where(m => m.ManuNo.Equals(manuNo))
                .FirstAsync();
        }

        public async Task<bool> OrderReturnFinish(List<OperationVo<MachineRecord>> datas, string OrderNo)
        {
            try
            {
                _connection.BeginTransaction();
                var flag = true;
                // 更新处方状态
                int r1 = _connection.OrderInfo.Where(oi => oi.OrderNo == OrderNo)
                        .Set(oi => oi.Status, 0)
                        .Update();
                if (!(r1 > 0))
                {
                    flag = false;
                    logger.Error("处方取药完成更新处方状态失败");
                    _connection.RollbackTransaction();
                    return flag;
                }
                for (var i = 0; i < datas.Count; i++)
                {
                    var operationVo = datas[i];

                    List<ChannelStock> stocks = operationVo.ChannelStocks.Where(cs => cs.ReturnQuantity > 0).ToList();

                    // 更新取出记录状态
                    var r2 = _connection.MachineRecord.Where(cs => cs.Id == operationVo.data.Id)
                    .Set(cs => cs.Status, 2)
                    .Set(cs => cs.ReturnQuantity1, operationVo.data.Quantity).Update();

                    if (r2 > 0)
                    {

                    }
                    else
                    {
                        flag = false;
                        break;
                    }

                    for (var j = 0; j < stocks.Count; j++)
                    {
                        var channelStock = stocks[j];

                        // 更新库存
                        var q = _connection.ChannelStock.Where(cs => cs.Id == channelStock.Id)
                        .Set(cs => cs.Quantity, channelStock.Quantity + channelStock.ReturnQuantity);
                        if (String.IsNullOrEmpty(channelStock.ManuNo) || (channelStock.Quantity == 0 && !channelStock.ManuNo.Equals(operationVo.data.ManuNo)))
                        {
                            DrugManuNo drugManuNo = await GetDrugManuNo(channelStock.DrugId, operationVo.data.ManuNo);

                            channelStock.Dmnguid = drugManuNo.Id;
                            channelStock.ManuNo = drugManuNo.ManuNo;
                            channelStock.EffDate = drugManuNo.EffDate.ToString();

                            q = q.Set(cs => cs.Dmnguid, drugManuNo.Id)
                                .Set(cs => cs.ManuNo, drugManuNo.ManuNo)
                                .Set(cs => cs.EffDate, drugManuNo.EffDate.ToString());
                        }
                        int r = q.Update();
                        // 退回记录
                        int mid = _connection.InsertWithInt32Identity(new MachineRecord()
                        {
                            MachineId = _setting.machineId,
                            DrawerNo = channelStock.DrawerNo,
                            ColNo = channelStock.ColNo,
                            DrugId = channelStock.DrugId,
                            ManuNo = channelStock.ManuNo,
                            EffDate = !String.IsNullOrEmpty(channelStock.EffDate) ? DateTime.ParseExact(channelStock.EffDate, "yyyy-MM-dd", System.Globalization.CultureInfo.CurrentCulture) : null,
                            OperationTime = DateTime.Now,
                            Type = 31,
                            Quantity = channelStock.ReturnQuantity,
                            Operator = _globalStateService.Operator.Id,
                            Reviewer = _globalStateService.Reviewer?.Id ?? _globalStateService.Operator.Id,
                            InvoiceId = operationVo.data.InvoiceId.ToString(),
                            GetId = operationVo.data.Id
                        });

                        // 获取更新完库存之后的药品库存
                        List<ChannelStock> list = await _connection.ChannelStock.AsQueryable()
                             .InnerJoin(
                                 _connection.ChannelList.Where(cl => cl.MachineId.Equals(_setting.machineId)).Where(cl => cl.DrawerType == 1),
                                 (cs, cl) => cs.ListId == cl.Id,
                                 (cs, cl) => cs
                             )
                             .Where(cs => cs.DrugId.Equals(channelStock.DrugId))
                             .ToListAsync();
                        // 保存账册
                        int acid = _connection.InsertWithInt32Identity(new AccountBook()
                        {
                            MachineId = _setting.machineId,
                            DrugId = channelStock.DrugId,
                            ManuNo = channelStock.ManuNo,
                            EffDate = !String.IsNullOrEmpty(channelStock.EffDate) ? DateTime.ParseExact(channelStock.EffDate, "yyyy-MM-dd", System.Globalization.CultureInfo.CurrentCulture) : null,
                            OperationTime = DateTime.Now,
                            Type = 2,
                            OutQuantity = channelStock.ReturnQuantity,
                            AddQuantity = 0,
                            Operator = _globalStateService.Operator.Id,
                            Reviewer = _globalStateService.Reviewer?.Id ?? _globalStateService.Operator.Id,
                            ManuStock = list.Where(it => it.ManuNo == channelStock.ManuNo).Sum(it => it.Quantity),
                            TotalStock = list.Sum(it => it.Quantity),
                            InvoiceId = operationVo.data.InvoiceId
                        });
                        if (mid > 0 && r > 0 && acid > 0)
                        {
                            if (channelStock.BoardType.ToString().Contains("5"))
                            {
                                await _portUtil.WriteQuantityMethod(channelStock.Quantity - channelStock.ReturnQuantity, channelStock.DrawerNo, channelStock.ColNo);
                            }
                        }
                        else
                        {
                            flag = false;
                            break;
                        }

                    }


                }
                if (flag)
                {
                    _connection.CommitTransaction();
                }
                else
                {
                    _connection.RollbackTransaction();
                }
                return flag;

            }
            catch (Exception ex)
            {
                logger.Error("处方取药完成保存数据库失败，错误：" + ex.Message);
                _connection.RollbackTransaction();
                return false;
            }
        }


        /// <summary>
        /// 获取药箱中的用药信息
        /// </summary>
        /// <param name="OrderrNo"></param>
        /// <param name="OrderDate"></param>
        /// <param name="take"></param>
        /// <param name="skip"></param>
        /// <returns></returns>
        public async Task<PageData<OrderInfo>> GetAllOrderInfoByBox(int box, string OrderrNo, DateTime OrderDate, int? take, int? skip)
        {
            var query2 = from od in _connection.OrderDetail
                         from cl in _connection.ChannelStock.Where(c => c.MachineId == _setting.machineId).InnerJoin(c => c.DrugId == od.DrugId)
                         group od by od.OrderNo into temp
                         select new { temp.Key };
            var query = from oi in _connection.OrderInfo
                        from od in query2.InnerJoin(od => od.Key == oi.OrderNo)
                        select oi;
            if (!String.IsNullOrEmpty(OrderrNo))
            {
                query = query.Where(oi => oi.OrderNo.Equals(OrderrNo));
            }
            if (OrderDate != null && OrderDate != DateTime.MinValue)
            {
                query = query.Where(oi => oi.OrderDate.Date.Equals(OrderDate.Date));
            }

            query = query.Where(oi => oi.Status == 0);
            query = query.Where(oi => oi.HisDispFlag == 0);
            query = query.Where(oi => oi.CancelFlag == 0);
            //query = query.Where(oi => oi.DoctorCode == box);

            int pagedData = await query.CountAsync();

            List<OrderInfo> list = await query
                //.LoadWith(oi => oi.DetailList)
                .OrderBy((oi) => oi.RecvDate)
                .ThenBy((oi => oi.OrderNo))
                .Skip((int)skip)
                .Take((int)take)
                .ToListAsync();
            if (list != null && list.Count > 0)
            {
                for (int i = 0; i < list.Count; i++)
                {
                    for (int j = 0; j < list[i].DetailList.Count; j++)
                    {
                        list[i].DetailList[j].Drug = await _connection.DrugInfo.AsQueryable().Where(d => d.DrugId == list[i].DetailList[j].DrugId).FirstOrDefaultAsync();
                    }
                }
            }


            //var query2 = from od in _connection.OrderDetail
            //             from cl in _connection.ChannelStock.Where(c => c.MachineId == _setting.machineId).InnerJoin(c => c.DrugId == od.DrugId)
            //             group od by od.OrderNo into temp
            //             select new { temp.Key };
            //var query = from oi in _connection.OrderInfo
            //            from od in query2.InnerJoin(od => od.Key == oi.OrderNo)
            //            select oi;

            //if (!String.IsNullOrEmpty(OrderrNo))
            //{
            //    query = query.Where(oi => oi.OrderNo.Equals(OrderrNo));
            //}
            //if (OrderDate != null && OrderDate != DateTime.MinValue)
            //{
            //    query = query.Where(oi => oi.OrderDate.Date.Equals(OrderDate.Date));
            //}

            //query = query.Where(oi => oi.Status == 0);
            //query = query.Where(oi => oi.HisDispFlag == 0);
            //query = query.Where(oi => oi.CancelFlag == 0);
            ////query = query.Where(oi => oi.DoctorCode == box);

            //int pagedData = await query.CountAsync();

            //List<OrderInfo> list = await query
            //    .LoadWith(oi => oi.Detail)
            //    .LoadWith(oi => oi.Detail.Drug)
            //    .OrderBy((oi) => oi.RecvDate)
            //    .ThenBy((oi => oi.OrderNo))
            //    .Skip((int)skip)
            //    .Take((int)take)
            //    .ToListAsync();
            //if (list != null && list.Count > 0)
            //{
            //    for (int i = 0; i < list.Count; i++)
            //    {
            //        //list[i].Detail = await _connection.OrderDetail.AsQueryable()
            //        //    .Where(od => od.OrderNo == list[i].OrderNo)
            //        //    .LoadWith(od => od.Drug)
            //        //    .ToListAsync();
            //    }
            //}

            return new PageData<OrderInfo>()
            {
                TotalDesserts = pagedData,
                Desserts = list
            };
        }
        /// <summary>
        /// 获取所有药箱号
        /// </summary>
        /// <param name="machineId"></param>
        /// <returns></returns>
        public async Task<int[]> GetDrawerNum(string machineId)
        {
            int[] ints = _connection.ChannelStock.Where(cs => cs.MachineId == machineId).GroupBy(cs => cs.DrawerNo).Select(cs => cs.Key).ToArray();
            return ints;
        }
        //核对处方
        public async Task<bool> CheckOrderInfo(IList<OrderInfo> selectedOrderInfos, int DrawerNo)
        {
            try
            {
                _connection.BeginTransaction();
                bool bFlag = true;
                logger.Info($"管理员{_globalStateService.Operator.NickName}开始确认手麻单");


                string empChannelStock = string.Empty;

                for (int i = 0; i < selectedOrderInfos.Count; i++)
                {
                    OrderInfo oi = selectedOrderInfos[i];

                    //更新处方状态
                    if (oi.Status == 1)
                    {
                        int iUpdate = _connection.OrderInfo.Where(o => o.OrderNo == oi.OrderNo).Set(o => o.Status, 2).Update();
                        _connection.Insert(new OrderFinish()
                        {
                            OrderNo = oi.OrderNo,
                            PatientId = oi.PatientId,
                            Pharmacy = oi.Pharmacy,
                            State = 2,
                            //WinNo = DrawerNo + 1 + "号手术间",
                            Operator = _globalStateService.Operator.NickName,
                        });
                    }
                    int drawerNo = DrawerNo;
                    if (oi.DetailList != null && oi.DetailList.Count > 0)
                    {
                        for (int j = 0; j < oi.DetailList.Count; j++)
                        {
                            ChannelStock cs = _connection.ChannelStock.AsQueryable()
                                             .Where(cs => cs.DrugId == oi.DetailList[j].DrugId
                                                    && cs.ManuNo == oi.DetailList[j].SetManuNo
                                                    // && cs.EffDate == oi._OrderDetail.SetEffDate
                                                    && cs.MachineId.Equals(_setting.boxMachineId)
                                                    && cs.DrawerNo == drawerNo
                                                    && cs.Quantity >= oi.DetailList[j].Quantity).First();
                            if (cs == null)
                            {
                                logger.Info($"手麻单{oi.OrderNo}对药品批次{oi.DetailList[j].DrugId}-{oi.DetailList[j].SetManuNo}在{drawerNo}药箱无库存");
                                continue;
                            }
                            cs.Quantity = cs.Quantity - oi.DetailList[j].Quantity;
                            //cs.NeedNum = cs.NeedNum > 0 ? cs.NeedNum + oi._OrderDetail.Quantity : oi._OrderDetail.Quantity;
                            logger.Info($"更新手术间{cs.DrawerNo}药品{cs.DrugId}批次{cs.ManuNo}库存为{cs.Quantity}，需补药数量为{oi.DetailList[j].Quantity}");
                            // 更新数据 库存信息
                            _connection.Update(cs);

                            //更新ChannelList对应的总库存
                            ChannelList channelList = _connection.ChannelList.AsQueryable().Where(cl => cl.MachineId.Equals(cs.MachineId) && cl.Id.Equals(cs.ListId) && cl.DrawerNo.Equals(cs.DrawerNo)).FirstOrDefault();
                            channelList.TotalQuantity = channelList.TotalQuantity - oi.DetailList[j].Quantity;
                            _connection.Update(channelList);

                            // 获取更新完库存后的药品库存
                            List<ChannelStock> nowChannels = _connection.ChannelStock.AsQueryable()
                                .Where(it => it.MachineId.Equals(cs.MachineId) || it.MachineId.Equals(_setting.machineId))
                                .Where(it => it.DrugId.Equals(cs.DrugId))
                                .Where(it => it.ManuNo.Equals(cs.ManuNo))
                                .Where(it => it.DrawerType == 1)
                                .ToList();

                            if (cs != null)
                            {
                                _connection.Insert(new MachineRecord()
                                {
                                    MachineId = _setting.machineId,
                                    DrawerNo = cs.DrawerNo,
                                    ColNo = cs.ColNo,
                                    DrugId = cs.DrugId,
                                    ManuNo = cs.ManuNo,
                                    EffDate = !String.IsNullOrEmpty(cs.EffDate) ? DateTime.ParseExact(cs.EffDate, "yyyy-MM-dd", System.Globalization.CultureInfo.CurrentCulture) : null,
                                    Operator = _globalStateService.Operator?.Id,
                                    Reviewer = _globalStateService.Reviewer?.Id,
                                    OperationTime = DateTime.Now,
                                    Quantity = oi.DetailList[j].Quantity,
                                    Type = 2,
                                    InvoiceId = oi.OrderNo
                                    //, StockQuantity = nowChannels.Sum(it => it.Quantity)
                                });


                                //查询上一条账册中的空瓶数
                                AccountBookG2 accountBookEmpty = _connection.AccountBookG2.AsQueryable()
                                .Where(ab => ab.MachineId.Equals(_setting.machineId))
                                .Where(ab => ab.Type == 1 || ab.Type == 2)
                                .Where(ab => ab.DrugId == oi.DetailList[j].DrugId)
                                .Where(ab => ab.ManuNo == cs.ManuNo).OrderByDescending(ab => ab.Id).First();
                                //保存账册
                                int iInsertResult = _connection.Insert(new AccountBookG2()
                                {
                                    DrugId = oi.DetailList[j].DrugId,
                                    Type = 2,
                                    Department = oi.DeptName,
                                    OrderNo = oi.OrderNo,
                                    ManuNo = cs.ManuNo,
                                    EffDate = cs.EffDate,
                                    OutQuantity = oi.DetailList[j].Quantity,
                                    UserId1 = _globalStateService.Operator?.Id,
                                    UserId2 = _globalStateService.Reviewer?.Id,
                                    MachineId = _setting.machineId,
                                    CreateDate = DateTime.Now.ToString("yyyy-MM-dd"),
                                    CreateTime = DateTime.Now,
                                    InvoiceNo = oi.OrderNo,
                                    ManuStock = nowChannels.Sum(it => it.Quantity),
                                    TotalStock = (accountBookEmpty != null ? (accountBookEmpty.TotalStock > 0 ? accountBookEmpty.TotalStock : 0) : 0) + oi.DetailList[j].Quantity,
                                    ShoushuJian = drawerNo.ToString()
                                });
                                //修改凌晨生成的日结存与总结存数据
                                AccountBookG2 accountBookG2Day = _connection.AccountBookG2.AsQueryable()
                                .Where(ab => ab.MachineId.Equals(_setting.machineId))
                                .Where(ab => ab.Type == 3)
                                .Where(ab => ab.DrugId == oi.DetailList[j].DrugId)
                                .Where(ab => ab.ManuNo == cs.ManuNo)
                                .Where(ab => ab.CreateDate == DateTime.Now.ToString("yyyy-MM-dd")).First();
                                if (accountBookG2Day != null)
                                {
                                    accountBookG2Day.ManuStock = accountBookG2Day.ManuStock - oi.DetailList[j].Quantity;
                                    _connection.Update(accountBookG2Day);
                                }
                                else
                                {
                                    //生成日结存时可能没有该库位的绑定信息，需要写入日结存
                                    int iDayResult = _connection.Insert(new AccountBookG2()
                                    {
                                        DrugId = oi.DetailList[j].DrugId,
                                        Type = 3,
                                        ManuNo = cs.ManuNo,
                                        EffDate = cs.EffDate,
                                        YQuantity = 0,
                                        ManuStock = oi.DetailList[j].Quantity,
                                        TotalStock = oi.DetailList[j].Quantity,
                                        UserId1 = _globalStateService.Operator?.Id,
                                        UserId2 = _globalStateService.Reviewer?.Id,
                                        MachineId = _setting.machineId,
                                        CreateDate = DateTime.Now.ToString("yyyy-MM-dd"),
                                        InvoiceNo = "日结存"
                                    });
                                    if (iDayResult <= 0)
                                    {
                                        logger.Info($"未写入日结存数据{oi.DetailList[j].DrugId}-{cs.ManuNo}-{cs.EffDate}-{cs.Quantity}");
                                    }
                                }
                                //修改凌晨生成的日结存与总结存数据
                                AccountBookG2 accountBookG2Total = _connection.AccountBookG2.AsQueryable()
                                .Where(ab => ab.MachineId.Equals(_setting.machineId))
                                .Where(ab => ab.Type == 4)
                                .Where(ab => ab.DrugId == oi.DetailList[j].DrugId)
                                .Where(ab => ab.CreateDate == DateTime.Now.ToString("yyyy-MM-dd")).First();
                                if (accountBookG2Total != null)
                                {
                                    accountBookG2Total.TotalStock = accountBookG2Total.TotalStock - oi.DetailList[j].Quantity;
                                    _connection.Update(accountBookG2Total);
                                }
                                else
                                {
                                    //生成总结存时可能没有该库位的绑定信息，需要写入总结存
                                    int iTotalResult = _connection.Insert(new AccountBookG2()
                                    {
                                        DrugId = oi.DetailList[j].DrugId,
                                        Type = 4,
                                        YQuantity = 0,
                                        ManuStock = oi.DetailList[j].Quantity,
                                        TotalStock = oi.DetailList[j].Quantity,
                                        UserId1 = _globalStateService.Operator?.Id,
                                        UserId2 = _globalStateService.Reviewer?.Id,
                                        MachineId = _setting.machineId,
                                        CreateDate = DateTime.Now.ToString("yyyy-MM-dd"),
                                        InvoiceNo = "总结存"
                                    });
                                    if (iTotalResult <= 0)
                                    {
                                        logger.Info($"未写入总结存数据{oi.DetailList[j].DrugId}-{oi.DetailList[j].Quantity}");
                                    }
                                }

                            }

                        }
                    }
                }

                return true;

                logger.Info($"管理员{_globalStateService.Operator.NickName}结束确认手麻单");

                if (bFlag)
                {
                    _connection.CommitTransaction();
                    return true;
                }
            }
            catch (Exception ex)
            {
                _connection.RollbackTransaction();
                logger.Info($"核对处方异常{ex.Message}");
                return false;
            }
        }

    }
}