using CAPI.Custom.Data;
using CAPI.Custom.Entities;
using CAPI.Custom.Entities.publ.PurchaseOrders;
using framework_business;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;

namespace CAPI.Custom.Services
{
    public class InventoryService
    {

        private readonly QuotesContext db = QuotesContext.Create();
        private readonly QuoteService quoteService = new QuoteService();
        private readonly string INVENTORY_MANAGEMENT_TOTAL_ON_HAND_FIELD = "198";
        private readonly string INVENTORY_MANAGEMENT_TOTAL_COMMITTED_FIELD = "199";
        private readonly string INVENTORY_MANAGEMENT_TOTAL_AVAILABLE_FIELD = "200";

        public bool InventoryAutomationUpdate(int quoteItemID, pNums.InventoryAutomationType automationType)
        {
            try
            {
                Quote quote = quoteService.GetByItemId(quoteItemID); // db.Quotes.GetFirstByItemId(quoteItemID);
                List<QuoteItemsFinal> quoteItemsFinalList = quoteService.GetFinalStockItems(quoteItemID).ToList();

                foreach (QuoteItemsFinal finalItem in quoteItemsFinalList)
                {
                    if (finalItem.UniqueNumber.IsEmpty())
                    {
                        // doesn't come from inventory
                        continue;
                    }

                    var uniqueNumber = finalItem.UniqueNumber;
                    var binLocation = finalItem.Location;
                    var uniqueManagementNumber = $"{uniqueNumber}-{binLocation}";

                    var inventoryManagementItem = db.InventoryManagement.FirstOrDefault(p =>
                        p.isActive.Value
                        && p.UniqueNumber == uniqueNumber
                        && p.BinLocation == binLocation
                    );

                    if (inventoryManagementItem.IsNull())
                    {
                        // nothing to do
                        continue;
                    }

                    InventoryItem inventoryItem = db.InventoryItems.FirstOrDefault(i => i.isActive.Value && i.UniqueNumber == uniqueNumber);

                    PartsMaster partsMaster = db.PartsMasters.FirstOrDefault(m => m.isActive.Value
                        && m.MasterNumber == finalItem.PartNumber
                    ) ?? (from a in db.PartsAlternates
                          join m in db.PartsMasters
                          on a.AlternateNumber equals m.PartNumber
                          select m).FirstOrDefault();

                    int newCommittedCount = 0, newAvailableCount = 0, newOnHandCount = 0;

                    switch (automationType)
                    {
                        case pNums.InventoryAutomationType.Quote_Accepted:
                            newCommittedCount = Convert.ToInt32(inventoryManagementItem.Committed) + finalItem.QuantityAvailable.Value;
                            newAvailableCount = Convert.ToInt32(inventoryManagementItem.OnHand) - newCommittedCount;
                            inventoryManagementItem.Committed = newCommittedCount;
                            inventoryManagementItem.Available = newAvailableCount;

                            inventoryItem.TotalCommitted += finalItem.QuantityAvailable.Value;
                            break;
                        case pNums.InventoryAutomationType.StockPick_Picked:
                            PurchaseOrderPickingSlipQuoteItemFinal pickingSlipItem = db.PurchaseOrderPickingSlipQuoteItemFinalProxy.FirstOrDefault(x => x.QuoteItemFinalId == finalItem.itemID);
                            newOnHandCount = Convert.ToInt32(inventoryManagementItem.OnHand) - pickingSlipItem.Picked;
                            newCommittedCount = Convert.ToInt32(inventoryManagementItem.Committed) - pickingSlipItem.Picked;
                            newAvailableCount = newOnHandCount - newCommittedCount;
                            inventoryManagementItem.OnHand = newOnHandCount;
                            inventoryManagementItem.Committed = newCommittedCount;
                            inventoryManagementItem.Available = newAvailableCount;

                            inventoryItem.TotalOnHand -= pickingSlipItem.Picked;
                            inventoryItem.TotalCommitted -= pickingSlipItem.Picked;
                            break;
                    }

                    inventoryItem.TotalAvailable = inventoryItem.TotalOnHand.Value - inventoryItem.TotalCommitted.Value;
                    partsMaster.TotalAvailable = inventoryItem.TotalAvailable;

                    db.SaveChanges();
                    SetTotalsByPartMasterId(partsMaster.itemID);
                }
                return true;
            }
            catch (Exception ex)
            {
                throw new Exception(MethodBase.GetCurrentMethod().Name + ":" + ex.Message);
            }

        }

        public InventoryItem GetItemByItemId(int itemId)
        {
            return db.InventoryItems.GetFirstByItemId(itemId);
        }

        public InventoryItem SetTotals(int inventoryItemId)
        {
            var item = GetItemByItemId(inventoryItemId);
            return SetTotals(item);
        }

        public void SetTotalsByPartMasterId(int masterId)
        {
            using (var ctx = new QuotesContext())
            {
                var partMaster = db.PartsMasters.GetFirstByItemId(masterId);
                var inventoryItems = db.InventoryItems.GetByParentId(masterId).ToList();

                foreach (var item in inventoryItems)
                {
                    var childItems = db.InventoryManagement.GetByParentId(item.itemID).ToList();

                    foreach (var cItem in childItems)
                    {
                        cItem.Available = cItem.OnHand.GetValueOrDefault() - cItem.Committed.GetValueOrDefault();
                    }

                    item.AverageCost = childItems.Select(p => p.AverageUnitCost ?? 0).DefaultIfEmpty(0).Average();
                    item.TotalAvailable = childItems.Select(p => p.Available ?? 0).DefaultIfEmpty(0).Sum();
                    item.TotalCommitted = childItems.Select(p => p.Committed ?? 0).DefaultIfEmpty(0).Sum();
                    item.TotalOnHand = childItems.Select(p => p.OnHand ?? 0).DefaultIfEmpty(0).Sum();
                    item.TotalOnOrder = childItems.Select(p => p.OnOrder ?? 0).DefaultIfEmpty(0).Sum();

                    item.TotalAvailable = item.TotalOnHand.GetValueOrDefault() - item.TotalCommitted.GetValueOrDefault();
                    item.TotalValue = item.TotalOnHand.GetValueOrDefault() * item.AverageCost.GetValueOrDefault();
                }

                partMaster.TotalAvailable = inventoryItems.Select(p => p.TotalAvailable ?? 0).DefaultIfEmpty(0).Sum();
            }
        }

        public InventoryItem SetTotals(InventoryItem inventoryItem)
        {
            if (inventoryItem.IsNotNull())
            {
                var part = db.PartsMasters.GetFirstByItemId(inventoryItem.ParentSurfaceItemId.GetValueOrDefault());
                var childItems = db.InventoryManagement.Where(p => p.UniqueNumber == inventoryItem.UniqueNumber).ToList();

                if (childItems.Any())
                {
                    foreach (var cItem in childItems)
                    {
                        cItem.Available = cItem.OnHand.GetValueOrDefault() - cItem.Committed.GetValueOrDefault();
                    }

                    inventoryItem.AverageCost = childItems.Select(p => p.AverageUnitCost).DefaultIfEmpty(0).Average();
                    inventoryItem.TotalAvailable = childItems.Sum(p => p.Available ?? 0);
                    inventoryItem.TotalCommitted = childItems.Sum(p => p.Committed ?? 0);
                    inventoryItem.TotalOnHand = childItems.Sum(p => p.OnHand ?? 0);
                    inventoryItem.TotalOnOrder = childItems.Sum(p => p.OnOrder ?? 0);

                    inventoryItem.TotalAvailable = inventoryItem.TotalOnHand.GetValueOrDefault() - inventoryItem.TotalCommitted.GetValueOrDefault();
                    inventoryItem.TotalValue = inventoryItem.TotalOnHand.GetValueOrDefault() * inventoryItem.AverageCost.GetValueOrDefault();
                }
            }

            return inventoryItem;
        }
    }
}