using LinqToDB;
using LinqToDB.SqlQuery;
using log4net;
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
                .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];
                    // 出库记录
                    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(orderTakeVo.ChannelStock.EffDate) ? DateTime.ParseExact(orderTakeVo.ChannelStock.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(orderTakeVo.ChannelStock.EffDate) ? DateTime.ParseExact(orderTakeVo.ChannelStock.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;
            }
        }
    }
}