prs/prs.desktop/Panels/Reservation Management/ReservationManagementPanel.xaml.cs

using Comal.Classes;
using InABox.Configuration;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Media;
using InABox.WPF.Themes;
using NPOI.SS.Formula.Functions;
using System.Collections.ObjectModel;
using System.Threading.Tasks;
using InABox.Clients;
using InABox.Wpf;
using InABox.Wpf.Reports;
using Columns = InABox.Core.Columns;
using PRSDesktop.Panels.ReservationManagement.TreatmentPO;

namespace PRSDesktop;

/// <summary>
/// Interaction logic for JobRequisitionsPanel.xaml
/// </summary>
public partial class ReservationManagementPanel : UserControl, IPanel<JobRequisitionItem>
{
    private ReservationManagementGlobalSettings _globalSettings = null!; // Initialised in Setup()

    //private DynamicSplitPanelView CurrentView;

    //private List<PurchaseOrder> PurchaseOrders = new List<PurchaseOrder>();

    public ReservationManagementPanel()
    {
        InitializeComponent();

        //CurrentView = SplitPanel.View;

        // JobRequiItems.Reconfigure(options =>
        // {
        //     var canMultiSelect = Mode != PanelMode.Reserve || SplitPanel.View == DynamicSplitPanelView.Master;
        //     if(canMultiSelect)
        //     {
        //         options.MultiSelect = true;
        //     }
        //     else
        //     {
        //         options.MultiSelect = false;
        //     }
        // });
    }

    // enum PanelMode
    // {
    //     Reserve,
    //     Purchase
    // }

    //private PanelMode Mode { get; set; }

    // private void SelectDetailButton(Button button)
    // {
    //     reserveBtn.Background = new SolidColorBrush(Colors.WhiteSmoke);
    //     reserveBtn.Foreground = new SolidColorBrush(Colors.Black);
    //     foreach(var btn in PurchaseOrderButtons.Children.OfType<Button>())
    //     {
    //         btn.Background = new SolidColorBrush(Colors.WhiteSmoke);
    //         btn.Foreground = new SolidColorBrush(Colors.Black);
    //     }
    //     AddPOButton.Background = new SolidColorBrush(Colors.WhiteSmoke);
    //     AddPOButton.Foreground = new SolidColorBrush(Colors.Black);
    //     button.Background = ThemeManager.SelectedTabItemBackgroundBrush;
    //     button.Foreground = ThemeManager.SelectedTabItemForegroundBrush;
    // }

    private void Reconfigure()
    {
        JobRequiItems.Reconfigure();
        OnUpdateDataModel?.Invoke(SectionName, DataModel(Selection.None));
    }

    // private void SelectReserved()
    // {
    //     SelectDetailButton(reserveBtn);
    //
    //     reserveCol.Width = new System.Windows.GridLength(1, System.Windows.GridUnitType.Star);
    //     purchaseCol.Width = new System.Windows.GridLength(0);
    //
    //     if(Mode != PanelMode.Reserve)
    //     {
    //         Mode = PanelMode.Reserve;
    //         Reconfigure();
    //     }
    // }
    
    // private void SelectNewPurchaseOrder()
    // {
    //     SelectDetailButton(AddPOButton);
    //
    //     reserveCol.Width = new System.Windows.GridLength(0);
    //     purchaseCol.Width = new System.Windows.GridLength(1, System.Windows.GridUnitType.Star);
    //
    //     if (Mode != PanelMode.Purchase)
    //     {
    //         Mode = PanelMode.Purchase;
    //         Reconfigure();
    //     }
    //
    //     purchasing.LoadFromRequiLine(Guid.Empty);
    // }
    
    // private void SelectPurchaseOrder(Button button, PurchaseOrder order)
    // {
    //     SelectDetailButton(button);
    //
    //     reserveCol.Width = new System.Windows.GridLength(0);
    //     purchaseCol.Width = new System.Windows.GridLength(1, System.Windows.GridUnitType.Star);
    //
    //     if (Mode != PanelMode.Purchase)
    //     {
    //         Mode = PanelMode.Purchase;
    //         Reconfigure();
    //     }
    //
    //     purchasing.LoadFromRequiLine(order.ID);
    // }

    public bool IsReady { get; set; }

    public string SectionName => "Job Requisitions";

    public event DataModelUpdateEvent? OnUpdateDataModel;

    public void CreateToolbarButtons(IPanelHost host)
    {
        ProductSetupActions.Standard(host);
        host.CreateSetupAction(new PanelAction() { Caption = "Reservation Management Settings", Image = PRSDesktop.Resources.specifications, OnExecute = ConfigSettingsClick });

        if (Security.IsAllowed<CanCreateTreatmentPO>())
          host.CreatePanelAction(new PanelAction("Treatment PO", PRSDesktop.Resources.purchase, TreatmentPO_Click));

        // if(Mode == PanelMode.Purchase && SplitPanel.IsDetailVisible())
        // {
        //     var sectionName = SupplierPurchaseOrderPanel.SectionName;
        //     var dataModel = SupplierPurchaseOrderPanel.DataModel(Array.Empty<Guid>());
        //     var reports = ReportUtils.LoadReports(sectionName, dataModel);
        //     foreach(var report in reports)
        //     {
        //         host.CreateReport(PanelHost.CreateReportAction(report, (selection) =>
        //         {
        //             Guid[] ids;
        //             if(selection == Selection.None)
        //             {
        //                 ids = Array.Empty<Guid>();
        //             }
        //             else
        //             {
        //                 ids = PurchaseOrders.Select(x => x.ID).ToArray();
        //             }
        //             return SupplierPurchaseOrderPanel.DataModel(ids);
        //         }));
        //     }
        // }
    }

    private void ConfigSettingsClick(PanelAction obj)
    {
        var grid = new DynamicItemsListGrid<ReservationManagementGlobalSettings>();
        if(grid.EditItems(new ReservationManagementGlobalSettings[] { _globalSettings }))
        {
            new GlobalConfiguration<ReservationManagementGlobalSettings>().Save(_globalSettings);
            JobRequiItems.CompanyDefaultStyle = _globalSettings.ProductStyle;
            JobRequiItems.DueDateAlert = _globalSettings.DueDateAlert;
            JobRequiItems.DueDateWarning = _globalSettings.DueDateWarning;
        }
    }

    public DataModel DataModel(Selection selection)
    {
        var ids = JobRequiItems.ExtractValues(x => x.ID, selection).ToArray();
        return new BaseDataModel<JobRequisitionItem>(new Filter<JobRequisitionItem>(x => x.ID).InList(ids));
    }

    public void Heartbeat(TimeSpan time)
    {

    }

    public void Refresh()
    {
        JobRequiItems.Refresh(false, true);
    }

    public Dictionary<string, object[]> Selected()
    {
        return new Dictionary<string, object[]>
        {
            [typeof(JobRequisitionItem).EntityName()] = JobRequiItems.SelectedRows
        };
    }

    public void Setup()
    {
        //SelectReserved();

        _globalSettings = new GlobalConfiguration<ReservationManagementGlobalSettings>().Load();
        
        JobRequiItems.DueDateAlert = _globalSettings.DueDateAlert;
        JobRequiItems.DueDateWarning = _globalSettings.DueDateWarning;
        JobRequiItems.CompanyDefaultStyle = _globalSettings.ProductStyle;
        JobRequiItems.Refresh(true, false);

        
        
        //substitutions.FreeStockOnly = JobRequiItems.UserSettings.SubstituteFreeStockOnly;
        //substitutions.UpdateStyle = JobRequiItems.UserSettings.SubstituteUpdateStyle;
        

        //holdings.OnHoldingsReviewRefresh += Holdings_OnHoldingsReviewRefresh;

        //purchasing.OnPurchaseOrderSaved += Refresh;
    }

    // private void OnJobRequiItemSelected(object sender, DynamicGridSelectionEventArgs e)
    // {
    //     if (SplitPanel.IsDetailVisible())
    //     {
    //         holdings.Item = e.Rows?.FirstOrDefault()?.ToObject<JobRequisitionItem>();
    //         RefreshPurchaseOrderButtons();
    //     }
    // }

    // private void RefreshPurchaseOrderButtons()
    // {
    //     var requiIDs = JobRequiItems.SelectedRows
    //         .Select(x => x.Get<JobRequisitionItem, Guid>(x => x.ID))
    //         .ToArray();
    //
    //     var pos = Client.Query(
    //         new Filter<PurchaseOrder>(x => x.ID).InQuery(
    //             new Filter<PurchaseOrderItemAllocation>(x => x.JobRequisitionItem.ID)
    //                 .InList(requiIDs),
    //             x => x.Item.PurchaseOrderLink.ID),
    //         Columns.None<PurchaseOrder>().Add(x => x.ID)
    //             .Add(x => x.PONumber))
    //         .ToObjects<PurchaseOrder>().ToList();
    //     PurchaseOrders = pos;
    //
    //     PurchaseOrderButtons.Children.Clear();
    //     var buttons = new List<(Button btn, PurchaseOrder po)>();
    //     foreach (var po in pos)
    //     {
    //         var button = new Button
    //         {
    //             Content = po.PONumber,
    //             Height = 30,
    //             FontWeight = FontWeights.DemiBold,
    //             BorderBrush = new SolidColorBrush(Colors.DarkGray),
    //             BorderThickness = new Thickness(1.25),
    //             Margin = new Thickness(2, 0, 0, 2),
    //             Padding = new Thickness(13, 3, 13, 3)
    //         };
    //         button.Click += (o, e) =>
    //         {
    //             SelectPurchaseOrder(button, po);
    //         };
    //         buttons.Add((button, po));
    //         PurchaseOrderButtons.Children.Add(button);
    //     }
    //     if (Mode == PanelMode.Purchase)
    //     {
    //         if (buttons.Count == 0)
    //         {
    //             SelectNewPurchaseOrder();
    //         }
    //         else
    //         {
    //             var btn = buttons[0];
    //             SelectPurchaseOrder(btn.btn, btn.po);
    //         }
    //     }
    //     else if (Mode == PanelMode.Reserve)
    //     {
    //         SelectReserved();
    //     }
    // }
    //
    // private void Holdings_OnHoldingsReviewRefresh()
    // {
    //     Refresh();
    // }

    // private void CheckSaved(CancelEventArgs cancel)
    // {
    //     if (!SplitPanel.IsDetailVisible() || !purchasing.EditorChanged)
    //     {
    //         return;
    //     }
    //     var result = MessageWindow.ShowYesNoCancel("You have changes that have not been saved; do you wish to save these changes?", "Save Changes?");
    //     if (result == MessageWindowResult.Yes)
    //     {
    //         purchasing.Editor.SaveItem(cancel);
    //         if (!cancel.Cancel)
    //         {
    //             MessageWindow.ShowMessage("Purchase Order saved.", "Success");
    //         }
    //     }
    //     else if (result == MessageWindowResult.Cancel)
    //     {
    //         cancel.Cancel = true;
    //     }
    // }

    public void Shutdown(CancelEventArgs? cancel)
    {
        // if(cancel is not null && purchasing.EditorChanged)
        // {
        //     CheckSaved(cancel);
        // }
    }

    // private void ReserveStock_Clicked(object sender, System.Windows.RoutedEventArgs e)
    // {
    //     SelectReserved();
    // }
    //
    // private void Purchasing_Drop(object sender, DragEventArgs e)
    // {
    //     if(DynamicGridUtils.TryGetDropData(e, out var type, out var table))
    //     {
    //         if(type == typeof(JobRequisitionItem))
    //         {
    //             purchasing.DropItems(table.Rows);
    //         }
    //     }
    // }

    // private void AddPOButton_Click(object sender, RoutedEventArgs e)
    // {
    //     SelectNewPurchaseOrder();
    // }

    private void TreatmentPO_Click(PanelAction action)
    {
        var jris = JobRequiItems.SelectedRows.ToObjects<JobRequisitionItem>().ToDictionary(x => x.ID);
        if(jris.Count == 0)
        {
            MessageWindow.ShowMessage("Please select at least one job requisition item.", "No items selected");
            return;
        }

        if(jris.Values.Any(x => x.TreatmentRequired - x.TreatmentOnOrder <= 0))
        {
            MessageWindow.ShowMessage("Please select only items requiring treatment.", "Already treated");
            return;
        }
        if(jris.Values.Any(x => x.Style.ID == Guid.Empty))
        {
            MessageWindow.ShowMessage("Please select only items with a style.", "No style");
            return;
        }

        Client.EnsureColumns(jris.Values, Columns.None<JobRequisitionItem>()
            .Add(x => x.Product.Code)
            .Add(x => x.Product.Name)
            .Add(x => x.Requisition.Number)
            .Add(x => x.Job.JobNumber)
            .Add(x => x.Dimensions.Value));

        // Here, we grab every stock movement for the selected JRIs, and group them per JRI. For each JRI, any stock movements that are in the wrong style
        // are grouped according to their holding key. Note that this mimics precisely the TreatmentRequired aggregate on JRI. Hence, these holdings represent
        // the TreatmentRequired amounts; the 'Units' field is equivalent to TreatmentRequired.
        var holdings = Client.Query(
            new Filter<StockMovement>(x => x.JobRequisitionItem.ID).InList(jris.Keys.ToArray()),
            Columns.None<StockMovement>()
                .Add(x => x.JobRequisitionItem.ID)
                .Add(x => x.Job.ID)
                .Add(x => x.Job.JobNumber)
                .Add(x => x.Job.Name)
                .Add(x => x.Product.ID)
                .Add(x => x.Product.Code)
                .Add(x => x.Product.Name)
                .Add(x => x.Location.ID)
                .Add(x => x.Location.Code)
                .Add(x => x.Location.Description)
                .Add(x => x.Style.ID)
                .Add(x => x.Style.Code)
                .Add(x => x.Style.Description)
                .AddDimensionsColumns(x => x.Dimensions, Dimensions.ColumnsType.Local)
                .Add(x => x.Units))
            .ToObjects<StockMovement>()
            .GroupBy(x => x.JobRequisitionItem.ID)
            .ToDictionary(x => x.Key, x =>
            {
                var jri = jris[x.Key];
                return x.Where(x => x.Style.ID != jri.Style.ID).GroupBy(x => new
                {
                    Job = x.Job.ID,
                    Product = x.Product.ID,
                    Location = x.Location.ID,
                    Style = x.Style.ID,
                    x.Dimensions
                }).ToDictionary(
                    x => x.Key,
                    x =>
                    {
                        var items = x.ToArray();
                        return new
                        {
                            Job = items[0].Job,
                            Product = items[0].Product,
                            Location = items[0].Location,
                            Style = items[0].Style,
                            Dimensions = items[0].Dimensions,
                            Units = items.Sum(x => x.Units)
                        };
                    });
            });

        var styles = Client.Query(
            new Filter<ProductStyle>(x => x.ID).InList(jris.Values.Select(x => x.Style.ID).ToArray()),
            Columns.None<ProductStyle>()
                .Add(x => x.ID)
                .Add(x => x.Code)
                .Add(x => x.StockTreatmentProduct.ID))
            .ToObjects<ProductStyle>().ToDictionary(x => x.ID);
        // We need to load the treatment product for the styles that we need.
        var treatmentProducts = Client.Query(
            new Filter<Product>(x => x.ID).InList(styles.Select(x => x.Value.StockTreatmentProduct.ID).ToArray()),
            Columns.None<Product>()
                .Add(x => x.ID)
                .Add(x => x.Code)
                .Add(x => x.Name)
                .Add(x => x.Supplier.ID)
                .Add(x => x.TreatmentType.ID)
                .Add(x => x.TreatmentType.Description)
                .Add(x => x.TreatmentType.Calculation)
                .Add(x => x.TaxCode.ID))
            .ToObjects<Product>().ToDictionary(x => x.ID);
        // Also, the ProductTreatment contains the parameter we need.
        var jriProductsParameters = Client.Query(
            new Filter<ProductTreatment>(x => x.Product.ID).InList(jris.Values.Select(x => x.Product.ID).ToArray()),
            Columns.None<ProductTreatment>()
                .Add(x => x.Product.ID)
                .Add(x => x.TreatmentType.ID)
                .Add(x => x.Parameter))
            .ToObjects<ProductTreatment>().ToDictionary<ProductTreatment, (Guid product, Guid treatmentType)>(x => (x.Product.ID, x.TreatmentType.ID));

        var items = new List<ReservationManagementTreatmentPOItem>();

        foreach(var (id, jri) in jris)
        {
            if (!styles.TryGetValue(jri.Style.ID, out var style))
            {
                continue;
            }
            if(!treatmentProducts.TryGetValue(style.StockTreatmentProduct.ID, out var treatmentProduct))
            {
                MessageWindow.ShowMessage($"No stock treatment product found for style {style.Code}", "Treatment product not found");
                return;
            }
            else if(treatmentProduct.TreatmentType.ID == Guid.Empty)
            {
                MessageWindow.ShowMessage($"Treatment product {treatmentProduct.Code} does not have a treatment type", "No treatment type");
                return;
            }
            if(!jriProductsParameters.TryGetValue((jri.Product.ID, treatmentProduct.TreatmentType.ID), out var treatment))
            {
                MessageWindow.ShowMessage(
                    $"No treatment parameter found for product {jri.Product.Code} for treatment type {treatmentProduct.TreatmentType.Description}",
                    "Treatment product not found");
                return;
            }

            var jriHoldings = holdings.GetValueOrDefault(id);
            // We know here that the TreatmentRequired > 0, because of the check at the top of the function. Hence, there definitely should be holdings.
            // This therefore shouldn't ever happen, but if it does, we've made a logic mistake, and this error will tell us that.
            if(jriHoldings is null || jriHoldings.Count == 0)
            {
                MessageWindow.ShowError($"Internal error for requisition {jri.Requisition.Number} for job {jri.Job.JobNumber}", $"No holdings even though TreatmentRequired is greater than 0.");
                continue;
            }

            double multiplier;
            if (treatmentProduct.TreatmentType.Calculation.IsNullOrWhiteSpace())
            {
                // This is the default calculation.
                multiplier = treatment.Parameter * jri.Dimensions.Value;
            }
            else
            {
                var model = new TreatmentTypeCalculationModel();
                model.Dimensions.CopyFrom(jri.Dimensions);
                model.Parameter = treatment.Parameter;

                var expression = new CoreExpression<TreatmentTypeCalculationModel, double>(treatmentProduct.TreatmentType.Calculation);
                if(!expression.Evaluate(model).Get(out multiplier, out var e))
                {
                    MessageWindow.ShowError("Error calculating expression multiplier; using Parameter * Dimensions.Value instead.", e);
                    multiplier = treatment.Parameter * jri.Dimensions.Value;
                }
            }

            foreach(var (key, holding) in jriHoldings)
            {
                if (!holding.Units.IsEffectivelyGreaterThan(0)) continue;

                var item = new ReservationManagementTreatmentPOItem();
                item.Product.CopyFrom(holding.Product);
                item.Style.CopyFrom(holding.Style);
                item.Job.CopyFrom(holding.Job);
                item.Location.CopyFrom(holding.Location);
                item.Dimensions.CopyFrom(holding.Dimensions);

                item.TreatmentProduct.CopyFrom(treatmentProduct);
                item.Finish.CopyFrom(style);

                item.JRI.CopyFrom(jri);

                item.Multiplier = multiplier;
                // holding.Units should be TreatmentRequired
                item.RequiredQuantity = holding.Units;

                items.Add(item);
            }
        }

        var window = new ReservationManagementTreatmentOrderScreen(items);
        if(window.ShowDialog() == true)
        {
            var orders = new List<Tuple<PurchaseOrder, List<(PurchaseOrderItem, JobRequisitionItemLink)>>>();
            var movements = new List<StockMovement>();

            var results = window.Results.GroupBy(x => x.Supplier.ID).Select(x => (x.Key, x.ToArray())).ToArray();
            var suppliers = Client.Query(
                new Filter<Supplier>(x => x.ID).InList(results.ToArray(x => x.Key)),
                Columns.None<Supplier>().Add(x => x.ID).Add(x => x.DefaultLocation.ID))
                .ToObjects<Supplier>()
                .ToDictionary(x => x.ID);

            foreach(var (supplierID, perSupplier) in results)
            {
                var order = new PurchaseOrder();
                order.RaisedBy.ID = App.EmployeeID;

                order.DueDate = DateTime.Today.AddDays(7);
                order.Notes = [$"Treatment purchase order raised by {App.EmployeeName} from Reservation Management screen"];

                LookupFactory.DoLookup<PurchaseOrder, Supplier, SupplierLink>(order, x => x.SupplierLink, supplierID);

                var orderItems = new List<(PurchaseOrderItem, JobRequisitionItemLink)>();
                foreach(var item in perSupplier)
                {
                    var orderItem = new PurchaseOrderItem();
                    orderItem.Product.ID = item.Item.TreatmentProduct.ID;
                    orderItem.TaxCode.ID = item.SupplierProduct.TaxCode.ID != Guid.Empty
                        ? item.SupplierProduct.TaxCode.ID
                        : item.Item.TreatmentProduct.TaxCode.ID;
                    orderItems.Add((orderItem, item.Item.JRI));
                }

                LookupFactory.DoLookups<PurchaseOrderItem, Product, ProductLink>(
                    orderItems.Select(x => new Tuple<PurchaseOrderItem, Guid>(x.Item1, x.Item1.Product.ID)),
                    x => x.Product);
                LookupFactory.DoLookups<PurchaseOrderItem, TaxCode, TaxCodeLink>(
                    orderItems.WithIndex().Select(x => new Tuple<PurchaseOrderItem, Guid>(x.Value.Item1, perSupplier[x.Key].SupplierProduct.TaxCode.ID)),
                    x => x.TaxCode);
                LookupFactory.DoLookups<PurchaseOrderItem, Job, JobLink>(
                    orderItems.WithIndex().Select(x => new Tuple<PurchaseOrderItem, Guid>(x.Value.Item1, x.Value.Item2.Job.ID)),
                    x => x.Job);

                foreach (var (i, item) in perSupplier.WithIndex())
                {
                    var orderItem = orderItems[i].Item1;
                    orderItem.Qty = item.Quantity;
                    orderItem.Cost = item.SupplierProduct.CostPrice * item.Item.Multiplier;
                    orderItem.Description = $"Treatment for {item.Item.JRI.Product.Name} ({item.Item.Product.Code}/{item.Item.Product.Name})";
                }

                if(suppliers.TryGetValue(supplierID, out var supplier))
                {
                    foreach(var item in perSupplier)
                    {
                        var tOut = new StockMovement();
                        tOut.Job.CopyFrom(item.Item.Job);
                        tOut.Style.CopyFrom(item.Item.Style);
                        tOut.Location.CopyFrom(item.Item.Location);
                        tOut.Product.CopyFrom(item.Item.Product);
                        tOut.Dimensions.CopyFrom(item.Item.Dimensions);

                        tOut.Employee.ID = App.EmployeeID;
                        tOut.Date = DateTime.Now;
                        tOut.Issued = item.Quantity;
                        tOut.Type = StockMovementType.TransferOut;
                        tOut.JobRequisitionItem.CopyFrom(item.Item.JRI);
                        tOut.Notes = "Stock movement for treatment purchase order created from Reservation Management";

                        var tIn = tOut.CreateMovement();
                        tIn.Transaction = tOut.Transaction;

                        tIn.Style.CopyFrom(item.Item.JRI.Style);
                        tIn.Location.CopyFrom(supplier.DefaultLocation);

                        tIn.Employee.ID = App.EmployeeID;
                        tIn.Date = tOut.Date;
                        tIn.Received = item.Quantity;
                        tIn.Type = StockMovementType.TransferIn;
                        tIn.JobRequisitionItem.CopyFrom(item.Item.JRI);
                        tIn.Notes = "Stock movement for treatment purchase order created from Reservation Management";

                        movements.Add(tOut);
                        movements.Add(tIn);
                    }
                }
                else
                {
                    MessageWindow.ShowMessage(
                        $"No default location set up for supplier '{perSupplier[0].Supplier.Code}'; skipping creating stock movements",
                        "No default location");
                }

                orders.Add(new(order, orderItems));
            }

            var doIssue = false;
            if(Security.IsAllowed<CanIssueTreatmentPurchaseOrders>())
            {
                if (_globalSettings.AutoIssueTreatmentPOs)
                {
                    doIssue = true;
                }
                else if(MessageWindow.ShowYesNo($"Do you wish to mark the purchase order{(orders.Count != 1 ? "s" : "")} as issued?", "Mark as issued?"))
                {
                    doIssue = true;
                }
            }
            if (doIssue)
            {
                foreach(var (order, _) in orders)
                {
                    order.IssuedBy.ID = App.EmployeeID;
                    order.IssuedDate = DateTime.Now;
                }
            }

            Client.Save(orders.Select(x => x.Item1), "Treatment PO created from Reservation Management screen");
            foreach(var (order, orderItems) in orders)
            {
                foreach(var item in orderItems)
                {
                    item.Item1.PurchaseOrderLink.ID = order.ID;
                }
            }
            Client.Save(orders.SelectMany(x => x.Item2).Select(x => x.Item1), "Treatment PO created from Reservation Management screen");
            Client.Save(orders.SelectMany(x => x.Item2).Select(x =>
            {
                var jriPOI = new PurchaseOrderItemAllocation();
                jriPOI.Job.ID = x.Item2.Job.ID;
                jriPOI.JobRequisitionItem.ID = x.Item2.ID;
                jriPOI.Item.ID = x.Item1.ID;
                jriPOI.Quantity = x.Item1.Qty;
                return jriPOI;
            }), "Treatment PO created from Reservation Management screen");

            Client.Save(movements, "Treatment PO created from Reservation Management screen");

            MessageWindow.ShowMessage(
                $"{orders.Count} treatment purchase order{(orders.Count != 1 ? "s" : "")} {(doIssue ? "issued" : "raised")}:\n" +
                $"- {string.Join(',', orders.Select(x => x.Item1.PONumber))}",
                "Success");

            JobRequiItems.SelectedRows = [];
            JobRequiItems.Refresh(false, true);
        }
    }

    // private void SplitPanel_OnChanged(object sender, DynamicSplitPanelSettings e)
    // {
    //     JobRequiItems.Reconfigure();
    //     if(CurrentView != e.View)
    //     {
    //         CurrentView = e.View;
    //         if (e.View != DynamicSplitPanelView.Master)
    //         {
    //             Refresh();
    //         }
    //     }
    // }

    //private bool _updatingSubstitution = false;
    
    // private void JobRequiItems_OnOnSelectItem(object sender, DynamicGridSelectionEventArgs e)
    // {
        // _updatingSubstitution = true;
        // try
        // {
        //     var row = Mode == PanelMode.Reserve && e.Rows?.Length == 1
        //         ? e.Rows.FirstOrDefault()
        //         : null;
        //     var visible =
        //         row != null
        //         && row.Get<JobRequisitionItem, double>(x => x.InStock).IsEffectivelyEqual(0.0)
        //         && row.Get<JobRequisitionItem, double>(x => x.TotalOrders).IsEffectivelyEqual(0.0)
        //         && row.Get<JobRequisitionItem, double>(x => x.OnOrder).IsEffectivelyEqual(0.0)
        //         && row.Get<JobRequisitionItem, double>(x => x.TreatmentRequired).IsEffectivelyEqual(0.0)
        //         && row.Get<JobRequisitionItem, double>(x => x.TreatmentOnOrder).IsEffectivelyEqual(0.0)
        //         && row.Get<JobRequisitionItem, double>(x => x.Allocated).IsEffectivelyEqual(0.0)
        //         && row.Get<JobRequisitionItem, double>(x => x.PickRequested).IsEffectivelyEqual(0.0)
        //         && row.Get<JobRequisitionItem, double>(x => x.Issued).IsEffectivelyEqual(0.0);
        //
        //     substitutions.SizeChanged -= Substitutions_OnSizeChanged;
        //     SubstitutionSplitterRow.Height = visible ? GridLength.Auto : new GridLength(0.0);
        //     SubstitutionRow.Height = visible ? new GridLength(JobRequiItems.UserSettings.SubstitutionGridHeight) : new GridLength(0.0);
        //     SubstitutionButtonRow.Height = visible ? GridLength.Auto : new GridLength(0.0);
        //     substitutions.SizeChanged += Substitutions_OnSizeChanged;
        //     if (visible)
        //         substitutions.JRI = row?.ToObject<JobRequisitionItem>() ?? new JobRequisitionItem();
        //     SubstitutionFreeStock.IsChecked = JobRequiItems.UserSettings.SubstituteFreeStockOnly;
        //     SubstitutionUpdateStyle.IsChecked = JobRequiItems.UserSettings.SubstituteUpdateStyle;
        // }
        // finally
        // {
        //     _updatingSubstitution = false;
        // }
    //}

    // private void SubstitutionFreeStock_OnChecked(object sender, RoutedEventArgs e)
    // {
    //     if (_updatingSubstitution)
    //         return;
    //     substitutions.FreeStockOnly = SubstitutionFreeStock.IsChecked == true;
    //     JobRequiItems.UserSettings.SubstituteFreeStockOnly = substitutions.FreeStockOnly;
    //     new UserConfiguration<ReservationManagementUserSettings>().Save(JobRequiItems.UserSettings);
    // }
    //
    // private void SubstitutionUpdateStyle_OnChecked(object sender, RoutedEventArgs e)
    // {
    //     if (_updatingSubstitution)
    //         return;
    //     substitutions.UpdateStyle = SubstitutionUpdateStyle.IsChecked == true;
    //     JobRequiItems.UserSettings.SubstituteUpdateStyle = substitutions.UpdateStyle;
    //     new UserConfiguration<ReservationManagementUserSettings>().Save(JobRequiItems.UserSettings);
    // }

    // private bool _sizeChanging = false;
    //
    // private void Substitutions_OnSizeChanged(object sender, SizeChangedEventArgs e)
    // {
    //     _sizeChanging = System.Windows.Input.Mouse.LeftButton == MouseButtonState.Pressed;
    // }

    // protected override void OnPreviewMouseUp(MouseButtonEventArgs e)
    // {
    //     base.OnPreviewMouseUp(e);
    //     if (_sizeChanging)
    //     {
    //         _sizeChanging = false;
    //         JobRequiItems.UserSettings.SubstitutionGridHeight = substitutions.ActualHeight;
    //         new UserConfiguration<ReservationManagementUserSettings>().Save(JobRequiItems.UserSettings);
    //     }
    // }

    // private void ChangeProduct_OnClick(object sender, RoutedEventArgs e)
    // {
    //     var _holding = substitutions.SelectedRows?.FirstOrDefault()?.ToObject<StockHolding>();
    //     var _jrirow = JobRequiItems.SelectedRows.FirstOrDefault();
    //     if (_holding == null || _jrirow == null)
    //         return;
    //     var _jri = _jrirow.ToObject<JobRequisitionItem>();
    //     _jri.Dimensions.CopyFrom(_holding.Dimensions, true);
    //     if (substitutions.UpdateStyle)
    //         _jri.Style.CopyFrom(_holding.Style);
    //     Client.Save(_jri,"Substituted by Requisition Management Screen");
    //     var _xferout = _holding.CreateMovement();
    //     _xferout.Issued = Math.Min(_holding.Available, _jri.Qty);
    //     _xferout.Notes = "Substituted by Requisition Management Screen";
    //     _xferout.Transaction = Guid.NewGuid();
    //     _xferout.Type = StockMovementType.TransferOut;
    //     var _xferin = _holding.CreateMovement();
    //     _xferin.JobRequisitionItem.CopyFrom(_jri);
    //     _xferin.Job.CopyFrom(_jri.Job);
    //     _xferin.Received = Math.Min(_holding.Available, _jri.Qty);
    //     _xferin.Notes = "Substituted by Requisition Management Screen";
    //     _xferin.Transaction = _xferout.Transaction;
    //     _xferin.Type = StockMovementType.TransferIn;
    //     Client.Save(new[] { _xferout, _xferin}, "Substituted by Requisition Management Screen");
    //     JobRequiItems.Refresh(false,true);
    //     // Allocate Stock (transfer if required)
    // }
    //
    // private void Substitutions_OnOnSelectItem(object sender, DynamicGridSelectionEventArgs e)
    // {
    //     ChangeProduct.IsEnabled = e.Rows?.SingleOrDefault() != null;
    // }
}