using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Volo.Abp.AspNetCore.Mvc;
using Win_in.Sfs.Wms.Dashboard.Host.Models;
using System;
using System.Linq;
using Win_in.Sfs.Basedata.Application.Contracts;
using Win_in.Sfs.Shared.Domain.Shared;
using Win_in.Sfs.Wms.Store.Application.Contracts;

namespace Win_in.Sfs.Wms.Dashboard.Host.Controllers
{

    [ApiController]
    [Route($"{PdaHostConst.ROOT_ROUTE}plan-and-actual")]

    public class PlanAndActualController : AbpController
    {
        private readonly ISupplierAsnAppService _supplierAsnApp;
        private readonly IPurchaseReceiptNoteAppService _purchaseReceiptNoteApp;
        private readonly IPutawayNoteAppService _putawayNoteApp;
        private readonly ISupplierAppService _supplierApp;
        private readonly IItemSafetyStockAppService _itemSafetyStockApp;
        private readonly IPurchaseOrderAppService _purchaseOrderApp;
        private readonly IPurchaseReceiptJobAppService _purchaseReceiptJobApp;

        public PlanAndActualController(ISupplierAsnAppService supplierAsnApp, IPurchaseReceiptNoteAppService purchaseReceiptNoteApp, IPutawayNoteAppService putawayNoteApp, ISupplierAppService supplierApp, IItemSafetyStockAppService itemSafetyStockApp, IPurchaseOrderAppService purchaseOrderApp, IPurchaseReceiptJobAppService purchaseReceiptJobApp)
        {
            _supplierAsnApp = supplierAsnApp;
            _purchaseReceiptNoteApp = purchaseReceiptNoteApp;
            _putawayNoteApp = putawayNoteApp;
            _supplierApp = supplierApp;
            _itemSafetyStockApp = itemSafetyStockApp;
            _purchaseOrderApp = purchaseOrderApp;
            _purchaseReceiptJobApp = purchaseReceiptJobApp;
        }

        /// <summary>
        /// 纳入计划与实际
        /// </summary>
        /// <returns></returns>
        [HttpGet("plan-actual-list")]
        public virtual async Task<List<PlanAndActualDashboardDto>> GetPlanAndActualListAsync()
        {
            return await GetPlanAndActualDashboardsAsync().ConfigureAwait(false);
        }

        private async Task<List<PlanAndActualDashboardDto>> GetPlanAndActualDashboardsAsync()
        {
            var supplierAsns = await this.GetSupplierAsnsAsync().ConfigureAwait(false);

            var supplierCodes = supplierAsns.Select(t => t.SupplierCode).Distinct();

            var suppliers = await GetSuppliersAsync(supplierCodes).ConfigureAwait(false);

            var asnNumbers = supplierAsns.Select(t => t.Number);

            var purchaseReceiptNotes = await GetPurchaseReceiptNotesAsync(asnNumbers).ConfigureAwait(false);

            var putawayNotes = await this.GetPutawayNotesAsync(asnNumbers).ConfigureAwait(false);

            var itemSafetyStorks = await this.GetItemSafetyStocksAsync(supplierAsns).ConfigureAwait(false);

            return await this.ConvertToPlanAndActualDashboards(
                supplierAsns,
                suppliers,
                purchaseReceiptNotes,
                putawayNotes,
                itemSafetyStorks).ConfigureAwait(false);
        }

        private async Task<List<PlanAndActualDashboardDto>> ConvertToPlanAndActualDashboards(List<SupplierAsnDTO> supplierAsns, List<SupplierDTO> suppliers, List<PurchaseReceiptNoteDTO> purchaseReceiptNotes, List<PutawayNoteDTO> putawayNotes, List<ItemSafetyStockDTO> itemSafetyStorks)
        {
            var dtos = new List<PlanAndActualDashboardDto>();
            var poNumberList = supplierAsns.Select(p => p.PoNumber).ToList();
            foreach (var supplierAsn in supplierAsns)
            {
                var purchaseReceipts = purchaseReceiptNotes.FindAll(t => t.AsnNumber == supplierAsn.Number);
                var putaways = putawayNotes.FindAll(t => t.AsnNumber == supplierAsn.Number);

                var supplierName = string.Empty;
                var supplierShortName = string.Empty;

                var supplier = suppliers.FirstOrDefault(t => t.Code == supplierAsn.SupplierCode);

                if (supplier == null)
                {
                    continue;
                }

                supplierName = supplier.Name;
                supplierShortName = supplier.ShortName;

                foreach (var detail in supplierAsn.Details)
                {
                    var dto = dtos.FirstOrDefault(t => t.SupplierName == supplierName && t.ItemCode == detail.ItemCode);

                    if (dto == null)
                    {
                        dto = new PlanAndActualDashboardDto();

                        dto.SupplierName = supplier.Name;
                        dto.SupplierShortName = supplierShortName;
                        dto.ItemCode = detail.ItemCode;
                        dto.ItemDesc1 = detail.ItemDesc1;
                        dto.ItemName = detail.ItemName;

                        var itemSafetyStork = itemSafetyStorks.FirstOrDefault(t => t.ItemCode == detail.ItemCode);

                        if (itemSafetyStork != null)
                        {
                            dto.MaxQty = itemSafetyStork.MaxStock;
                            dto.MinQty = itemSafetyStork.MinStock;
                        }

                        var purchaseOrderDtos = await _purchaseOrderApp.GetListBySupplierCodeAsync(supplierAsn.SupplierCode, detail.ItemCode).ConfigureAwait(false);
                        //var supllierAsn = await _supplierAsnApp.GetForTodayListAsync().ConfigureAwait(false);
                        //var poNumberList = supllierAsn.Select(p => p.PoNumber).ToList();

                        purchaseOrderDtos = purchaseOrderDtos.Where(p => poNumberList.Contains(p.Number)).ToList();

                        decimal allPutawayQty = 0;
                        decimal allReceiptQty = 0;
                        decimal allPlanArriveQty = 0;
                        decimal allArriveQty = 0;

                        foreach (var purchaseOrderDTO in purchaseOrderDtos)
                        {
                            allPutawayQty += purchaseOrderDTO.Details.Where(p => p.ItemCode == detail.ItemCode).Sum(p => p.PutAwayQty);
                            allReceiptQty += purchaseOrderDTO.Details.Where(p => p.ItemCode == detail.ItemCode).Sum(p => p.PutAwayQty);
                            allPlanArriveQty += purchaseOrderDTO.Details.Where(p => p.ItemCode == detail.ItemCode).Sum(p => p.Qty);
                            allArriveQty += purchaseOrderDTO.Details.Where(p => p.ItemCode == detail.ItemCode).Sum(p => p.ShippedQty);
                        }

                        dto.PutawayQty = allPutawayQty;
                        dto.PlanArriveQty = allPlanArriveQty;
                        dto.ReceiptQty = allReceiptQty;
                        dto.ArriveQty = allArriveQty;
                        dto.DifferQty = dto.PlanArriveQty - dto.ReceiptQty;

                        dtos.Add(dto);
                    }

                    var purchaseReceiptJobDtos = await _purchaseReceiptJobApp.GetListBySupplierCodeOnTodayAsync(supplierAsn.SupplierCode).ConfigureAwait(false);

                    dto.ReceiptNoteCount = purchaseReceiptJobDtos.Count(p => p.JobStatus == EnumJobStatus.Done);

                    dto.SupplierAsnCount = purchaseReceiptJobDtos.Count();
                }
            }

            return dtos.OrderBy(t => t.SupplierName).ToList();
        }

        private decimal CountReceiptQty(List<PurchaseReceiptNoteDTO> purchaseReceipts, string itemCode)
        {
            return purchaseReceipts.Sum(t => t.Details.Where(t => t.ItemCode == itemCode).Sum(t => t.Qty));
        }

        private int CountReceiptNoteCount(List<PurchaseReceiptNoteDTO> purchaseReceipts, string itemCode)
        {
            return purchaseReceipts.Sum(t => t.Details.Count(t => t.ItemCode == itemCode));
        }
        /// <summary>
        /// 显示7天数据
        /// </summary>
        /// <returns></returns>
        private async Task<List<SupplierAsnDTO>> GetSupplierAsnsAsync()
        {
            var startTime = DateTime.Today.AddDays(-6).AddHours(DashboardConst.AsnReceiptTimeLimitHour);

            var endTime = startTime.AddDays(7).AddSeconds(-1);


            if (DateTime.Now.Hour < DashboardConst.AsnReceiptTimeLimitHour)
            {
                startTime.AddDays(-1);
                endTime.AddDays(-1);
            }

            return await this._supplierAsnApp.GetByStartTimeEndTimeAsync(startTime, endTime).ConfigureAwait(false);
        }

        private async Task<List<SupplierDTO>> GetSuppliersAsync(IEnumerable<string> codes)
        {
            return await this._supplierApp.GetByCodesAsync(codes).ConfigureAwait(false);
        }

        private async Task<List<PurchaseReceiptNoteDTO>> GetPurchaseReceiptNotesAsync(IEnumerable<string> asnNumbers)
        {
            return await this._purchaseReceiptNoteApp.GetListByAsnNumbers(asnNumbers).ConfigureAwait(false);
        }

        private async Task<List<PutawayNoteDTO>> GetPutawayNotesAsync(IEnumerable<string> asnNumbers)
        {
            return await this._putawayNoteApp.GetListByAsnNumbers(asnNumbers);
        }
        private async Task<List<ItemSafetyStockDTO>> GetItemSafetyStocksAsync(List<SupplierAsnDTO> supplierAsns)
        {
            var itemCodes = new List<string>();

            supplierAsns.ForEach(t => { itemCodes.AddRange(t.Details.Select(t => t.ItemCode).ToList()); });

            var itemSafetyStorks = await this._itemSafetyStockApp.GetByItemCodesAsync(itemCodes);
            return itemSafetyStorks;
        }
    }
}