prs/prs.desktop/Panels/StockSummary/OrderScreen/StockSummaryOrderingGrid.cs

using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.Wpf;
using InABox.WPF;
using NPOI.SS.Formula.Functions;
using Syncfusion.Data;
using Syncfusion.Data.Extensions;
using Syncfusion.UI.Xaml.Grid;
using Syncfusion.Windows.Shared;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Media.Imaging;

namespace PRSDesktop.Panels.StockSummary.OrderScreen;

public enum StockSummaryOrderingType
{
    StockOrder,
    JobOrder
}

public class StockSummaryOrderingItemQuantity
{
    public event Action? Changed;

    private double _stockTotal;
    public double StockTotal
    {
        get => _stockTotal;
        set
        {
            _stockTotal = value;
            Changed?.Invoke();
        }
    }

    public Dictionary<Guid, double> JobTotals { get; init; } = [];

    public void DoChanged()
    {
        Changed?.Invoke();
    }

    public double JobTotal => JobTotals.Sum(x => x.Value);

    public double GetTotal(StockSummaryOrderingType type) => type == StockSummaryOrderingType.StockOrder
        ? StockTotal
        : JobTotal;
}

public class StockSummaryOrderingItem : BaseObject
{
    [EditorSequence(1)]
    public ProductLink Product { get; set; }

    [EditorSequence(2)]
    public ProductStyleLink Style { get; set; }

    [EditorSequence(3)]
    public StockDimensions Dimensions { get; set; }

    [EditorSequence(4)]
    [DoubleEditor]
    public double RequiredQuantity { get; set; }

    private Dictionary<Guid, double> JobRequiredQuantities { get; set; } = [];

    public Dictionary<Guid, double> GetJobRequiredQuantities()
    {
        return JobRequiredQuantities;
    }
    public void SetJobRequiredQuantity(Guid jobID, double requiredQty)
    {
        JobRequiredQuantities[jobID] = requiredQty;
    }

    private StockSummaryOrderingItemQuantity[] Quantities = [];

    public StockSummaryOrderingItemQuantity GetQuantity(int i) => Quantities[i];

    public double GetTotalQuantity(StockSummaryOrderingType type) => type == StockSummaryOrderingType.StockOrder
        ? Quantities.Sum(x => x.StockTotal)
        : Quantities.Sum(x => x.JobTotal);

    public void SetQuantities(StockSummaryOrderingItemQuantity[] quantities)
    {
        Quantities = quantities;
    }
}

public class StockSummaryOrderingResult
{
    public SupplierLink Supplier { get; set; }

    public JobLink? Job { get; set; }

    public StockSummaryOrderingItem Item { get; set; }

    public SupplierProduct SupplierProduct { get; set; }

    public double Quantity { get; set; }

    public StockSummaryOrderingResult(SupplierLink supplier, JobLink? job, StockSummaryOrderingItem item, double quantity, SupplierProduct supplierProduct)
    {
        Supplier = supplier;
        Job = job;
        Item = item;
        Quantity = quantity;
        SupplierProduct = supplierProduct;
    }
}

public class StockSummaryOrderingGrid : DynamicItemsListGrid<StockSummaryOrderingItem>, ISpecificGrid
{
    private SupplierProduct[] SupplierProducts = [];
    private SupplierLink[] Suppliers = [];

    public double TotalQuantity => Items.Sum(x => x.GetTotalQuantity(OrderType));

    private DynamicActionColumn[] QuantityColumns = [];
    private DynamicActionColumn[] CostColumns = [];

    private readonly Dictionary<Guid, Job> JobDetails = [];

    private static BitmapImage _warning = PRSDesktop.Resources.warning.AsBitmapImage();

    private StockSummaryOrderingType _orderType = StockSummaryOrderingType.JobOrder;
    public StockSummaryOrderingType OrderType
    {
        get => _orderType;
        set
        {
            if(_orderType != value)
            {
                _orderType = value;

                CalculateQuantities();

                foreach(var control in QuantityControls)
                {
                    control.UpdateControl(OrderType);
                }
            }
        }
    }

    public IEnumerable<StockSummaryOrderingResult> Results
    {
        get
        {
            for(int i = 0; i < Suppliers.Length; ++i)
            {
                var supplier = Suppliers[i];
                foreach(var item in Items)
                {
                    var qty = item.GetQuantity(i);
                    var supplierProduct = GetSupplierProduct(item, supplier.ID);
                    if (supplierProduct is null)
                    {
                        // If this is true, then the quantities also will have to be true.
                        continue;
                    }

                    if(OrderType == StockSummaryOrderingType.StockOrder && qty.StockTotal > 0)
                    {
                        yield return new(supplier, null, item, qty.StockTotal, supplierProduct);
                    }
                    else
                    {
                        foreach(var (jobID, q) in qty.JobTotals)
                        {
                            if(q > 0)
                            {
                                yield return new(supplier, new() { ID = jobID }, item, q, supplierProduct);
                            }
                        }
                    }
                }
            }
        }
    }

    #region UI Component

    private Component? _uiComponent;
    private Component UIComponent
    {
        get
        {
            _uiComponent ??= new Component(this);
            return _uiComponent;
        }
    }
    protected override IDynamicGridUIComponent<StockSummaryOrderingItem> CreateUIComponent()
    {
        return UIComponent;
    }
    private class Component : DynamicGridGridUIComponent<StockSummaryOrderingItem>
    {
        private StockSummaryOrderingGrid Grid;

        public Component(StockSummaryOrderingGrid grid)
        {
            Parent = grid;
            Grid = grid;
        }

        protected override Brush? GetCellSelectionBackgroundBrush()
        {
            return null;
        }

        protected override Brush? GetCellBackground(CoreRow row, DynamicColumnBase column)
        {
            var item = Grid.LoadItem(row);
            if(column is DynamicActionColumn ac)
            {
                var qIdx = Grid.QuantityColumns.IndexOf(ac);
                var idx = Math.Max(qIdx, Grid.CostColumns.IndexOf(ac));
                if(idx != -1)
                {
                    var supplierProduct = Grid.GetSupplierProduct(item, Grid.Suppliers[idx].ID);
                    if(supplierProduct is null)
                    {
                        return new SolidColorBrush(Colors.Gainsboro);
                    }
                    //if(item.GetTotalQuantity(Grid.OrderType) < item.RequiredQuantity)
                    //{
                    //    return new SolidColorBrush(Colors.LightSalmon) { Opacity = 0.5 };
                    //}
                    //else
                    //{
                    //    return new SolidColorBrush(Colors.LightGreen) { Opacity = 0.5 };
                    //}
                }
            }
            return base.GetCellBackground(row, column);
        }
    }

    #endregion

    private bool _observing = true;
    private void SetObserving(bool observing)
    {
        _observing = observing;
    }
    public override void DoChanged()
    {
        if (_observing)
        {
            base.DoChanged();
        }
    }

    protected override void DoReconfigure(FluentList<DynamicGridOption> options)
    {
        options.Clear().Add(DynamicGridOption.FilterRows);
    }

    private void LoadData()
    {
        var supplierColumns = new Columns<SupplierProduct>(x => x.ID)
            .Add(x => x.SupplierLink.ID)
            .Add(x => x.Product.ID)
            .Add(x => x.Style.ID)
            .Add(x => x.CostPrice)
            .AddDimensionsColumns(x => x.Dimensions)
            .Add(x => x.SupplierLink.Code);

        SupplierProducts = Client.Query(
            new Filter<SupplierProduct>(x => x.Product.ID).InList(Items.Select(x => x.Product.ID).ToArray())
                .And(x => x.SupplierLink.ID).IsNotEqualTo(Guid.Empty),
            supplierColumns,
            new SortOrder<SupplierProduct>(x => x.SupplierLink.Code))
            .ToArray<SupplierProduct>();

        Suppliers = SupplierProducts.Select(x => x.SupplierLink).DistinctBy(x => x.ID).ToArray();

        foreach(var (itemIdx, item) in Items.WithIndex())
        {
            var quantities = new StockSummaryOrderingItemQuantity[Suppliers.Length];
            for(int i = 0; i < Suppliers.Length; ++i)
            {
                var qty = new StockSummaryOrderingItemQuantity();
                quantities[i] = qty;
                qty.Changed += () =>
                {
                    var row = Data.Rows[itemIdx];
                    InvalidateRow(row);
                    DoChanged();
                };
            }

            item.SetQuantities(quantities);
        }

        CalculateQuantities();
    }

    private void CalculateQuantities()
    {
        SetObserving(false);
        foreach(var item in Items)
        {
            var supplierProduct = GetSupplierProduct(item);
            for(int i = 0; i < Suppliers.Length; ++i)
            {
                var qty = item.GetQuantity(i);

                var supplier = Suppliers[i];
                if(supplierProduct is not null && supplier.ID == supplierProduct.SupplierLink.ID)
                {
                    if(OrderType == StockSummaryOrderingType.StockOrder)
                    {
                        qty.StockTotal = qty.JobTotal;
                    }
                    else
                    {
                        qty.JobTotals.Clear();
                        foreach(var (id, q) in item.GetJobRequiredQuantities())
                        {
                            qty.JobTotals[id] = q;
                        }
                    }
                }
                else
                {
                    if(OrderType == StockSummaryOrderingType.StockOrder)
                    {
                        qty.StockTotal = 0;
                    }
                    else
                    {
                        foreach(var id in qty.JobTotals.Keys)
                        {
                            qty.JobTotals[id] = 0;
                        }
                    }
                }
            }
        }
        SetObserving(true);
        DoChanged();

        InvalidateGrid();
    }

    protected override DynamicGridColumns LoadColumns()
    {
        LoadData();

        ActionColumns.Add(new DynamicImageColumn(Warning_Image) { Position = DynamicActionColumnPosition.Start });

        var columns = new DynamicGridColumns();
        columns.Add<StockSummaryOrderingItem, string>(x => x.Product.Code, 120, "Product", "", Alignment.MiddleCenter);
        columns.Add<StockSummaryOrderingItem, string>(x => x.Style.Code, 120, "Style", "", Alignment.MiddleCenter);
        columns.Add<StockSummaryOrderingItem, string>(x => x.Dimensions.UnitSize, 0, "Size", "", Alignment.MiddleLeft);
        columns.Add<StockSummaryOrderingItem, double>(x => x.RequiredQuantity, 0, "Required", "", Alignment.MiddleLeft);

        QuantityColumns = new DynamicActionColumn[Suppliers.Length];
        CostColumns = new DynamicActionColumn[Suppliers.Length];
        QuantityControls.Clear();

        for(int i = 0; i < Suppliers.Length; ++i)
        {
            InitialiseSupplierColumn(i);
        }

        return columns;
    }

    private BitmapImage? Warning_Image(CoreRow? row)
    {
        if (row is null) return _warning;

        var item = LoadItem(row);
        if(item.GetTotalQuantity(OrderType) < item.RequiredQuantity)
        {
            return _warning;
        }
        else
        {
            return null;
        }
    }

    protected override void ConfigureColumnGroups()
    {
        for(int idx = 0; idx < Suppliers.Length; ++idx)
        {
            GetColumnGrouping().AddGroup(Suppliers[idx].Code, QuantityColumns[idx], CostColumns[idx]);
        }
    }

    private void LoadJobData(IEnumerable<Guid> ids)
    {
        var neededIDs = ids.Where(x => !JobDetails.ContainsKey(x)).ToArray();
        if(neededIDs.Length > 0)
        {
            var details = Client.Query(
                new Filter<Job>(x => x.ID).InList(neededIDs),
                new Columns<Job>(x => x.ID)
                    .Add(x => x.JobNumber)
                    .Add(x => x.Name));
            foreach(var job in details.ToObjects<Job>())
            {
                JobDetails[job.ID] = job;
            }
        }
    }

    private class QuantityControl : ContentControl
    {
        private readonly StockSummaryOrderingItem Item;
        private readonly int SupplierIndex;
        private readonly StockSummaryOrderingGrid Parent;

        public QuantityControl(StockSummaryOrderingGrid parent, StockSummaryOrderingItem item, int supplierIndex, StockSummaryOrderingType mode)
        {
            Parent = parent;
            Item = item;
            SupplierIndex = supplierIndex;

            UpdateControl(mode);
        }

        public void UpdateControl(StockSummaryOrderingType mode)
        {
            var supplierProduct = Parent.GetSupplierProduct(Item, Parent.Suppliers[SupplierIndex].ID);
            if(supplierProduct is null)
            {
                Content = null;
                return;
            }

            if(mode == StockSummaryOrderingType.StockOrder)
            {
                var editor = new DoubleTextBox
                {
                    VerticalAlignment = VerticalAlignment.Stretch,
                    HorizontalAlignment = HorizontalAlignment.Stretch,
                    Background = new SolidColorBrush(Colors.LightYellow),
                    BorderThickness = new Thickness(0.0),
                    MinValue = 0.0,
                    Value = Item.GetQuantity(SupplierIndex).StockTotal
                };
                editor.ValueChanged += (o, e) =>
                {
                    Item.GetQuantity(SupplierIndex).StockTotal = editor.Value ?? default;
                };
                Content = editor;
            }
            else if(mode == StockSummaryOrderingType.JobOrder)
            {
                var grid = new Grid();
                grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
                grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(30) });

                var editor = new TextBox
                {
                    VerticalAlignment = VerticalAlignment.Stretch,
                    HorizontalAlignment = HorizontalAlignment.Stretch,
                    VerticalContentAlignment = VerticalAlignment.Center,
                    HorizontalContentAlignment = HorizontalAlignment.Center,
                    Background = new SolidColorBrush(Colors.White),
                    BorderThickness = new Thickness(0.0),
                    IsReadOnly = true,
                    Text = string.Format("{0:F2}", Item.GetQuantity(SupplierIndex).JobTotal)
                };
                Grid.SetColumn(editor, 0);
                grid.Children.Add(editor);

                var btn = new Button
                {
                    VerticalAlignment = VerticalAlignment.Stretch,
                    VerticalContentAlignment = VerticalAlignment.Center,
                    HorizontalAlignment = HorizontalAlignment.Stretch,
                    Content = "..",
                    Margin = new Thickness(1),
                    Focusable = false
                };
                btn.SetValue(Grid.ColumnProperty, 1);
                btn.SetValue(Grid.RowProperty, 0);
                btn.Click += (o, e) =>
                {
                    var qty = Item.GetQuantity(SupplierIndex);

                    Parent.LoadJobData(qty.JobTotals.Keys);

                    var items = qty.JobTotals.Select(x =>
                    {
                        var item = new StockSummaryOrderingJobItem
                        {
                            JobID = x.Key,
                            RequiredQuantity = Item.GetJobRequiredQuantities().GetValueOrDefault(x.Key),
                            Quantity = x.Value
                        };
                        if(item.JobID == Guid.Empty)
                        {
                            item.Job = "General Stock";
                        }
                        else if(Parent.JobDetails.TryGetValue(item.JobID, out var job))
                        {
                            item.Job = $"{job.JobNumber}: {job.Name}";
                        }
                        return item;
                    }).ToList();

                    var window = new StockSummaryOrderJobScreen();
                    window.Items = items;
                    if(window.ShowDialog() == true)
                    {
                        foreach(var item in items)
                        {
                            qty.JobTotals[item.JobID] = item.Quantity;
                        }
                        qty.DoChanged();
                        editor.Text = string.Format("{0:F2}", Item.GetQuantity(SupplierIndex).JobTotal);
                    }
                };
                grid.Children.Add(btn);

                Content = grid;
            }
        }
    }

    private List<QuantityControl> QuantityControls = [];

    private void InitialiseSupplierColumn(int idx)
    {
        var supplierProducts = SupplierProducts.Where(x => x.SupplierLink.ID == Suppliers[idx].ID).ToArray();

        // Making local copy of index so that the lambda can use it, and not the changed value of 'i'.
        var qtyColumn = new Tuple<DynamicActionColumn, QuantityControl?>(null!, null);
        QuantityColumns[idx] = new DynamicTemplateColumn(row =>
        {
            var instance = LoadItem(row);
            var control = new QuantityControl(this, instance, idx, OrderType);
            QuantityControls.Add(control);
            return control;
        })
        {
            HeaderText = "Qty.",
            Width = 80
        };
        CostColumns[idx] = new DynamicTextColumn(row =>
        {
            if(row is null)
            {
                return "Cost";
            }

            var instance = LoadItem(row);
            var qty = OrderType == StockSummaryOrderingType.StockOrder
                ? instance.GetQuantity(idx).StockTotal
                : instance.GetQuantity(idx).JobTotal;
            var supplierProduct = GetSupplierProduct(instance, Suppliers[idx].ID);
            if(supplierProduct is not null)
            {
                return $"{qty * supplierProduct.CostPrice:C2}";
            }
            else
            {
                return "";
            }
        })
        {
            HeaderText = "Cost",
            Width = 80,
            GetSummary = () =>
            {
                var i = idx * 2 + 1;
                var summary = new GridSummaryColumn
                {
                    Format = "{Sum:C2}",
                    SummaryType = Syncfusion.Data.SummaryType.Custom,
                    CustomAggregate = new CostAggregate(idx, this)
                };
                return summary;
            }
        };
        ActionColumns.Add(QuantityColumns[idx]);
        ActionColumns.Add(CostColumns[idx]);
    }

    private static bool Matches(StockSummaryOrderingItem item, SupplierProduct supplierProduct)
    {
        return item.Product.ID == supplierProduct.Product.ID
            && item.Style.ID == supplierProduct.Style.ID
            && item.Dimensions.Equals(supplierProduct.Dimensions);
    }
    private static bool Matches(ProductInstance instance, SupplierProduct supplierProduct)
    {
        return instance.Product.ID == supplierProduct.Product.ID
            && instance.Style.ID == supplierProduct.Style.ID
            && instance.Dimensions.Equals(supplierProduct.Dimensions);
    }

    private SupplierProduct? GetSupplierProduct(StockSummaryOrderingItem item)
    {
        var defaultSupplierProduct = SupplierProducts.FirstOrDefault(x => x.ID == item.Product.Supplier.ID);
        if(defaultSupplierProduct is not null && Matches(item, defaultSupplierProduct))
        {
            return defaultSupplierProduct;
        }
        else
        {
            return SupplierProducts.FirstOrDefault(x => Matches(item, x));
        }
    }
    private SupplierProduct? GetSupplierProduct(ProductInstance instance, Guid supplierID)
    {
        return SupplierProducts.FirstOrDefault(x => x.SupplierLink.ID == supplierID && Matches(instance, x));
    }
    private SupplierProduct? GetSupplierProduct(StockSummaryOrderingItem item, Guid supplierID)
    {
        return SupplierProducts.FirstOrDefault(x => x.SupplierLink.ID == supplierID && Matches(item, x));
    }
    //private double GetQuantity(SupplierProduct product)
    //{
    //    var instance = ProductInstances.WithIndex().Where(x => x.Value.Product.ID == product.ID)
    //}

    private class CostAggregate : ISummaryAggregate
    {
        public double Sum { get; private set; }

        private int SupplierIndex;

        private StockSummaryOrderingGrid Grid;

        public CostAggregate(int supplierIndex, StockSummaryOrderingGrid grid)
        {
            SupplierIndex = supplierIndex;
            Grid = grid;
        }

        public Action<IEnumerable, string, PropertyDescriptor> CalculateAggregateFunc()
        {
            return AggregateFunc;
        }

        private void AggregateFunc(IEnumerable items, string property, PropertyDescriptor args)
        {
            if (items is IEnumerable<DataRowView> rows)
            {
                Sum = 0;
                foreach (var dataRow in rows)
                {
                    var rowIdx = dataRow.Row.Table.Rows.IndexOf(dataRow.Row);
                    var item = Grid.LoadItem(Grid.Data.Rows[rowIdx]);
                    var supplierProduct = Grid.GetSupplierProduct(item, Grid.Suppliers[SupplierIndex].ID);
                    if(supplierProduct is not null)
                    {
                        var qty = item.GetQuantity(SupplierIndex);
                        Sum += qty.GetTotal(Grid.OrderType) * supplierProduct.CostPrice;
                    }
                }
            }
            else
            {
                Logger.Send(LogType.Error, "", $"Attempting to calculate aggregate on invalid data type '{items.GetType()}'.");
            }
        }
    }
}