using com.sun.corba.se.spi.orbutil.threadpool;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using InABox.Wpf;
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Linq.Expressions;
using System.Windows;
using System.Windows.Media;

namespace PRSDesktop;

internal class JobSummaryGrid : DynamicDataGrid<JobMaterial>, IMasterDetailControl<Job,JobMaterial>, IDataModelSource
{
    Guid empID = Guid.Empty;
    string empName = "";
    
    public Job? Master { get; set; }

    public Filter<JobMaterial> MasterDetailFilter => (Master?.ID ?? Guid.Empty) != Guid.Empty
        ? new Filter<JobMaterial>(x => x.Job.ID).IsEqualTo(Master.ID)
            .And(x => x.Product.ID).IsNotEqualTo(Guid.Empty)
        : new Filter<JobMaterial>().None();

    public bool IncludeReserves { get; set; }

    public bool ShowIssues { get; set; }
    
    public JobSummaryGrid() : base()
    {
        ColumnsTag = nameof(JobSummaryGrid);

        OnCellDoubleClick += JobSummaryGrid_OnCellDoubleClick;

        SetupDetailsColumns();
    }

    private class UIComponent : DynamicGridGridUIComponent<JobMaterial>
    {
        private Column<JobMaterial> _jobshortage = new Column<JobMaterial>(x => x.JobShortage);
        private Column<JobMaterial> _stockshortage = new Column<JobMaterial>(x => x.FreeStockShortage);

        protected override Brush? GetCellBackground(CoreRow row, string columnname)
        {
            if (_jobshortage.IsEqualTo(columnname))
                return row.Get<JobMaterial, double>(x => x.JobShortage) > 0.0F ? new SolidColorBrush(Colors.LightSalmon) { Opacity = 0.5 } : null;
            if (_stockshortage.IsEqualTo(columnname))
                return row.Get<JobMaterial, double>(x => x.FreeStockShortage) > 0.0F ? new SolidColorBrush(Colors.LightSalmon) { Opacity = 0.5 } : null;
            return null;
        }
    }

    protected override IDynamicGridUIComponent<JobMaterial> CreateUIComponent()
    {
        return new UIComponent()
        {
            Parent = this
        };
    }

    protected override void Init()
    {
        base.Init();

        HiddenColumns.Add(x => x.Product.ID);
        HiddenColumns.Add(x => x.Style.ID);
        HiddenColumns.Add(x => x.Dimensions.UnitSize);

        HiddenColumns.Add(x => x.BillOfMaterials);
        HiddenColumns.Add(x => x.Requisitions);
        HiddenColumns.Add(x => x.PickingLists);
        HiddenColumns.Add(x => x.Issued);

        HiddenColumns.Add(x => x.ReservedStock);
        HiddenColumns.Add(x => x.OnOrder);

        HiddenColumns.Add(x => x.JobShortage);

        HiddenColumns.Add(x => x.FreeOnHand);
        HiddenColumns.Add(x => x.FreeOnOrder);
        HiddenColumns.Add(x => x.FreeStockTotal);
        HiddenColumns.Add(x => x.FreeStockShortage);

        HiddenColumns.Add(x => x.Product.Image.ID);
        HiddenColumns.Add(x => x.Product.Image.FileName);
        ActionColumns.Add(new DynamicImageManagerColumn<JobMaterial>(this, x => x.Product.Image, false)
        { Position = DynamicActionColumnPosition.Start });

        ActionColumns.Add(new DynamicMenuColumn(BuildMenu));

        AddButton("Create PO", null, CreatePO);
    }

    protected override void DoReconfigure(FluentList<DynamicGridOption> options)
    {
        base.DoReconfigure(options);

        options.AddRange(
            DynamicGridOption.RecordCount,
            DynamicGridOption.SelectColumns,
            DynamicGridOption.FilterRows,
            DynamicGridOption.ExportData,
            DynamicGridOption.MultiSelect
        );
    }

    private bool StyleColumnVisible()
    {
        var styleColumn = CoreUtils.GetFullPropertyName<JobMaterial, ProductStyleLink>(x => x.Style, ".");

        return VisibleColumns.Any(x => x.ColumnName.StartsWith(styleColumn));
    }

    public override DynamicGridColumns GenerateColumns()
    {
        var columns = new DynamicGridColumns();
        columns.Add<JobMaterial, string>(x => x.Product.Group.Code, 120, "Group Code", "", Alignment.MiddleCenter);
        columns.Add<JobMaterial, string>(x => x.Product.Code, 200, "Product Code", "", Alignment.MiddleCenter);
        columns.Add<JobMaterial, string>(x => x.Product.Name, 0, "Product Name", "", Alignment.MiddleCenter);
        columns.Add<JobMaterial, string>(x => x.Dimensions.UnitSize, 120, "UOM", "", Alignment.MiddleCenter);
        columns.Add<JobMaterial, double>(x => x.BillOfMaterials, 80, "BOM", "", Alignment.MiddleCenter);
        columns.Add<JobMaterial, double>(x => x.Requisitions, 80, "Req.", "", Alignment.MiddleCenter);
        columns.Add<JobMaterial, double>(x => x.PickingLists, 80, "P/L", "", Alignment.MiddleCenter);
        columns.Add<JobMaterial, double>(x => x.Issued, 80, "Issued", "", Alignment.MiddleCenter);
        columns.Add<JobMaterial, double>(x => x.ReservedStock, 80, "Reserved", "", Alignment.MiddleCenter);
        columns.Add<JobMaterial, double>(x => x.OnOrder, 80, "Ordered", "", Alignment.MiddleCenter);
        columns.Add<JobMaterial, double>(x => x.JobShortage, 80, "Job Short", "", Alignment.MiddleCenter);
        columns.Add<JobMaterial, double>(x => x.FreeStockTotal, 80, "Free Stock", "", Alignment.MiddleCenter);
        columns.Add<JobMaterial, double>(x => x.FreeStockShortage, 80, "Stk Short", "", Alignment.MiddleCenter);
        return columns;
    }

    private void BuildMenu(DynamicMenuColumn column, CoreRow? row)
    {
        if (row is null) return;
        var menu = column.GetMenu();
        menu.AddItem("View Stock Movements", PRSDesktop.Resources.forklift, row, ViewStockMovements_Click);

        foreach(var col in DetailsColumns)
        {
            menu.AddItem(col.MenuText, null, row, col.Action);
        }
    }

    private void ViewStockMovements_Click(CoreRow row)
    {
        var productID = row.Get<StockSummary, Guid>(c => c.Product.ID);
        Guid? styleID = StyleColumnVisible() ? row.Get<StockSummary, Guid>(c => c.Style.ID) : null;
        var unitSize = row.Get<StockSummary, String>(c => c.Dimensions.UnitSize);

        /*ShowDetailGrid<StockMovement>(
            args.Column.ColumnName,
            x => x.Product.ID,
            productid,
            x => x.Style.ID,
            styleid,
            x => x.Dimensions.UnitSize,
            unitsize,
            x => x.Job.ID,
            new Filter<StockMovement>(x => x.IsTransfer).IsEqualTo(false).And(x => x.Issued).IsNotEqualTo(0.0F),
            null
        );
        var movements = Client.Query<StockMovement>(
            );*/

        var grid = (Activator.CreateInstance(typeof(DynamicDataGrid<>).MakeGenericType(typeof(StockMovement))) as DynamicDataGrid<StockMovement>);
        if (grid == null)
        {
            MessageBox.Show($"Cannot create Grid for [{typeof(StockMovement).Name}]");
            return;
        }
        grid.ColumnsTag = $"{ColumnsTag}.Transactions";
        grid.Reconfigure(options =>
        {
            options.BeginUpdate().Clear().AddRange(DynamicGridOption.FilterRows, DynamicGridOption.SelectColumns).EndUpdate();
        });
        grid.OnReload += (object sender, Filters<StockMovement> criteria, Columns<StockMovement> columns, ref SortOrder<StockMovement>? sortby) =>
        {
            var filter = criteria.Combine();
            criteria.Clear();
            criteria.Add(new Filter<StockMovement>(x => x.Transaction).InQuery(filter, x => x.Transaction));
        };

        grid.OnDefineFilter += t =>
        {
            var filter = new Filter<StockMovement>(x => x.Product.ID).IsEqualTo(productID)
                .And(x => x.Dimensions.UnitSize).IsEqualTo(unitSize);
            if (styleID.HasValue)
                filter = filter.And(x => x.Style.ID).IsEqualTo(styleID);
            filter = filter.And(x => x.Job.ID).IsEqualTo(Master?.ID ?? Guid.Empty);
            return filter;
        };

        var window = DynamicGridUtils.CreateGridWindow($"Stock Movements", grid);
        window.ShowDialog();
    }

    private void ShowDetailGrid<TEntity>(
        String columnname,
        Expression<Func<TEntity, object?>> productcol,
        Guid productid,
        Expression<Func<TEntity, object?>> stylecol,
        Guid? styleid,
        Expression<Func<TEntity, object?>> unitcol,
        String unitsize,
        Expression<Func<TEntity, object?>>? jobcol,
        Filter<TEntity>? extrafilter,
        Func<CoreRow, bool>? rowfilter
    )
    {
        var grid = (Activator.CreateInstance(typeof(DynamicDataGrid<>).MakeGenericType(typeof(TEntity))) as IDynamicDataGrid);
        if (grid == null)
        {
            MessageBox.Show($"Cannot create Grid for [{typeof(TEntity).Name}]");
            return;
        }
        grid.ColumnsTag = $"{ColumnsTag}.{columnname}";
        grid.Reconfigure(options =>
        {
            options.BeginUpdate().Clear().AddRange(DynamicGridOption.FilterRows, DynamicGridOption.SelectColumns).EndUpdate();
        });
        grid.OnDefineFilter += t =>
        {
            var filter = new Filter<TEntity>(productcol).IsEqualTo(productid)
                .And(unitcol).IsEqualTo(unitsize);
            if (styleid.HasValue)
                filter = filter.And(stylecol).IsEqualTo(styleid);

            if (jobcol != null)
                filter = filter.And(jobcol).IsEqualTo(Master?.ID ?? Guid.Empty);

            if (extrafilter != null)
                filter = filter.And(extrafilter);
            return filter;
        };
        grid.OnFilterRecord += row => rowfilter?.Invoke(row) ?? true;
        var window = DynamicGridUtils.CreateGridWindow($"Viewing {CoreUtils.Neatify(columnname)} Calculation", grid);
        window.ShowDialog();
    }

    private static readonly Column<JobMaterial> BOMColumn = new Column<JobMaterial>(x => x.BillOfMaterials);
    private static readonly Column<JobMaterial> RequisitionsColumn = new Column<JobMaterial>(x => x.Requisitions);
    private static readonly Column<JobMaterial> PickingListsColumn = new Column<JobMaterial>(x => x.PickingLists);
    private static readonly Column<JobMaterial> IssuedColumn = new Column<JobMaterial>(x => x.Issued);
    private static readonly Column<JobMaterial> ReservedStockColumn = new Column<JobMaterial>(x => x.ReservedStock);
    private static readonly Column<JobMaterial> OnOrderColumn = new Column<JobMaterial>(x => x.OnOrder);
    private static readonly Column<JobMaterial> FreeOnHandColumn = new Column<JobMaterial>(x => x.FreeOnHand);
    private static readonly Column<JobMaterial> FreeOnOrderColumn = new Column<JobMaterial>(x => x.FreeOnOrder);

    private void ViewBillOfMaterials(CoreRow row)
    {
        ShowDetailGrid<JobBillOfMaterialsItem>(
            BOMColumn.Property,
            x => x.Product.ID,
            row.Get<StockSummary, Guid>(c => c.Product.ID),
            x => x.Style.ID,
            StyleColumnVisible() ? row.Get<StockSummary, Guid>(c => c.Style.ID) : null,
            x => x.Dimensions.UnitSize,
            row.Get<StockSummary, String>(c => c.Dimensions.UnitSize),
            x => x.Job.ID,
            new Filter<JobBillOfMaterialsItem>(x => x.BillOfMaterials.Approved).IsNotEqualTo(DateTime.MinValue),
            null
        );
    }
    private void ViewRequisitions(CoreRow row)
    {
        ShowDetailGrid<JobRequisitionItem>(
            RequisitionsColumn.Property,
            x => x.Product.ID,
            row.Get<StockSummary, Guid>(c => c.Product.ID),
            x => x.Style.ID,
            StyleColumnVisible() ? row.Get<StockSummary, Guid>(c => c.Style.ID) : null,
            x => x.Dimensions.UnitSize,
            row.Get<StockSummary, String>(c => c.Dimensions.UnitSize),
            x => x.Job.ID,
            new Filter<JobRequisitionItem>(x => x.Requisition.Approved).IsNotEqualTo(DateTime.MinValue),
            null
        );
    }
    private void ViewPickingLists(CoreRow row)
    {
        ShowDetailGrid<RequisitionItem>(
            PickingListsColumn.Property,
            x => x.Product.ID,
            row.Get<StockSummary, Guid>(c => c.Product.ID),
            x => x.Style.ID,
            StyleColumnVisible() ? row.Get<StockSummary, Guid>(c => c.Style.ID) : null,
            x => x.Dimensions.UnitSize,
            row.Get<StockSummary, String>(c => c.Dimensions.UnitSize),
            x => x.JobLink.ID,
            new Filter<RequisitionItem>(x => x.RequisitionLink.Filled).IsEqualTo(DateTime.MinValue),
            null
        );
    }
    private void ViewIssued(CoreRow row)
    {
        ShowDetailGrid<StockMovement>(
            IssuedColumn.Property,
            x => x.Product.ID,
            row.Get<StockSummary, Guid>(c => c.Product.ID),
            x => x.Style.ID,
            StyleColumnVisible() ? row.Get<StockSummary, Guid>(c => c.Style.ID) : null,
            x => x.Dimensions.UnitSize,
            row.Get<StockSummary, String>(c => c.Dimensions.UnitSize),
            x => x.Job.ID,
            new Filter<StockMovement>(x => x.Type).IsEqualTo(StockMovementType.Issue),
            null
        );
    }
    private void ViewReservedStock(CoreRow row)
    {
        ShowDetailGrid<StockHolding>(
            ReservedStockColumn.Property,
            x => x.Product.ID,
            row.Get<StockSummary, Guid>(c => c.Product.ID),
            x => x.Style.ID,
            StyleColumnVisible() ? row.Get<StockSummary, Guid>(c => c.Style.ID) : null,
            x => x.Dimensions.UnitSize,
            row.Get<StockSummary, String>(c => c.Dimensions.UnitSize),
            x => x.Job.ID,
            new Filter<StockHolding>(x => x.Units).IsGreaterThan(0.1),
            null
        );
    }
    private void ViewOnOrder(CoreRow row)
    {
        ShowDetailGrid<PurchaseOrderItem>(
            OnOrderColumn.Property,
            x => x.Product.ID,
            row.Get<StockSummary, Guid>(c => c.Product.ID),
            x => x.Style.ID,
            StyleColumnVisible() ? row.Get<StockSummary, Guid>(c => c.Style.ID) : null,
            x => x.Dimensions.UnitSize,
            row.Get<StockSummary, String>(c => c.Dimensions.UnitSize),
            x => x.Job.ID,
            null,
            null
        );
    }
    private void ViewFreeOnHand(CoreRow row)
    {
        ShowDetailGrid<StockHolding>(
            FreeOnHandColumn.Property,
            x => x.Product.ID,
            row.Get<StockSummary, Guid>(c => c.Product.ID),
            x => x.Style.ID,
            StyleColumnVisible() ? row.Get<StockSummary, Guid>(c => c.Style.ID) : null,
            x => x.Dimensions.UnitSize,
            row.Get<StockSummary, String>(c => c.Dimensions.UnitSize),
            null,
            new Filter<StockHolding>(x => x.Units).IsNotEqualTo(0.0F)
                .And(
                    IncludeReserves
                        ? new Filter<StockHolding>(x => x.Job.ID).IsNotEqualTo(Master?.ID ?? Guid.Empty)
                        : new Filter<StockHolding>(x => x.Job.JobStatus.Active).IsEqualTo(false)
                    ),
            null
        );
    }
    private void ViewFreeOnOrder(CoreRow row)
    {
        ShowDetailGrid<PurchaseOrderItem>(
            FreeOnOrderColumn.Property,
            x => x.Product.ID,
            row.Get<StockSummary, Guid>(c => c.Product.ID),
            x => x.Style.ID,
            StyleColumnVisible() ? row.Get<StockSummary, Guid>(c => c.Style.ID) : null,
            x => x.Dimensions.UnitSize,
            row.Get<StockSummary, String>(c => c.Dimensions.UnitSize),
            null,

            IncludeReserves
                ? new Filter<PurchaseOrderItem>(x => x.Job.ID).IsNotEqualTo(Master?.ID ?? Guid.Empty)
                : new Filter<PurchaseOrderItem>(x => x.Job.JobStatus.Active).IsEqualTo(false),
            null
        );
    }

    private List<DetailsColumn> DetailsColumns;

    [MemberNotNull(nameof(DetailsColumns))]
    private void SetupDetailsColumns()
    {
        DetailsColumns = new List<DetailsColumn>
        {
            new(BOMColumn, ViewBillOfMaterials, "View bill of materials"),
            new(RequisitionsColumn, ViewRequisitions, "View requisitions"),
            new(PickingListsColumn, ViewPickingLists, "View picking lists"),
            new(IssuedColumn, ViewIssued, "View issued"),
            new(ReservedStockColumn, ViewReservedStock, "View reserved stock"),
            new(OnOrderColumn, ViewOnOrder, "View on order"),
            new(FreeOnHandColumn, ViewFreeOnHand, "View free on hand"),
            new(FreeOnOrderColumn, ViewFreeOnOrder, "View free on order"),
        };
    }

    private class DetailsColumn
    {
        public Column<JobMaterial> Column { get; set; }

        public Action<CoreRow> Action { get; set; }

        public string MenuText { get; set; }

        public DetailsColumn(Column<JobMaterial> column, Action<CoreRow> action, string menuText)
        {
            Column = column;
            Action = action;
            MenuText = menuText;
        }
    }

    private void JobSummaryGrid_OnCellDoubleClick(object sender, DynamicGridCellClickEventArgs args)
    {
        foreach(var column in DetailsColumns)
        {
            if (column.Column.IsEqualTo(args.Column.ColumnName))
            {
                column.Action(args.Row);
                break;
            }
        }
    }

    public event DataModelUpdateEvent? OnUpdateDataModel;

    public string SectionName => "Job Summary";

    public DataModel DataModel(Selection selection)
    {
        return new AutoDataModel<JobMaterial>(MasterDetailFilter);
    }
    
    public override JobMaterial CreateItem()
    {
        var result = base.CreateItem();
        result.Job.ID = Master?.ID ?? Guid.Empty;
        result.Job.Synchronise(Master ?? new Job());
        return result;
    }

    private Tuple<Guid, Guid, Guid?, String>[] GetKeys(IEnumerable<CoreRow> rows, Columns<JobMaterial> columns, bool hasstyle)
    {
        int jobcol = columns.IndexOf(x => x.Job.ID);
        int productcol = columns.IndexOf(x => x.Product.ID);
        int stylecol = hasstyle ? columns.IndexOf(x => x.Style.ID) : -1;
        int unitcol = columns.IndexOf(x => x.Dimensions.UnitSize);

        var result = rows.Select(r => new Tuple<Guid, Guid, Guid?, String>(
            (Guid)(r.Values[jobcol] ?? Guid.Empty),
            (Guid)(r.Values[productcol] ?? Guid.Empty),
            (stylecol != -1) ? (Guid)(r.Values[stylecol] ?? Guid.Empty) : null,
            (String)(r.Values[unitcol] ?? ""))
        ).Distinct().ToArray();

        return result;
    }

    private CoreRow[] GetRows<TSource>(IEnumerable<CoreRow> rows, Columns<TSource> columns, Guid? jobid, Guid productid, Guid? styleid, String unitsize, Func<CoreRow, bool>? extrafilter = null) where TSource : IJobMaterial
    {
        int jobcol = columns.IndexOf(x => x.Job.ID);
        int productcol = columns.IndexOf(x => x.Product.ID);
        int stylecol = styleid.HasValue ? columns.IndexOf(x => x.Style.ID) : -1;
        int unitcol = columns.IndexOf(x => x.Dimensions.UnitSize);

        var subset = rows
            .Where(r =>
                (!jobid.HasValue || Guid.Equals(r.Values[jobcol], jobid))
                && Guid.Equals(r.Values[productcol], productid)
                && (!styleid.HasValue || Guid.Equals(r.Values[stylecol], styleid))
                && String.Equals(r.Values[unitcol], unitsize)
                && ((extrafilter == null) || extrafilter(r))
            );

        return subset.ToArray();
    }

    private double Aggregate<TSource>(IEnumerable<CoreRow> rows, Columns<TSource> columns, bool hasstyle, bool hasjob, Expression<Func<TSource, object>> source, CoreRow target, Expression<Func<JobMaterial, object>> aggregate)
    {
        int srcol = columns.IndexOf(source);

        if (srcol == -1)
            return 0.00;

        var total = rows.Aggregate(0d, (value, row) => value + (double)(row.Values[srcol] ?? 0.0d));

        target.Set(aggregate, total);
        return total;
    }

    protected override void Reload(Filters<JobMaterial> criteria, Columns<JobMaterial> columns, ref SortOrder<JobMaterial>? sort,
        Action<CoreTable?, Exception?> action)
    {

        var filter = MasterDetailFilter;

        var orderby = sort;

        Progress.ShowModal("Loading Data",
            (progress) =>
            {
                var table = new CoreTable();
                table.LoadColumns(columns);

                var data = new Client<JobMaterial>().Query(filter, columns, orderby);
                var pids = data.ExtractValues<JobMaterial, Guid>(x => x.Product.ID).ToArray();

                if (pids.Any())
                {
                    var results = Client.QueryMultiple(
                        new KeyedQueryDef<StockHolding>(
                            new Filter<StockHolding>(x => x.Product.ID).InList(pids)
                                .And(x => x.Units).IsNotEqualTo(0.0F)
                                .And(new Filter<StockHolding>(x => x.Job.ID).IsEqualTo(Guid.Empty).Or(x => x.Job.ID).IsNotEqualTo(Master?.ID ?? Guid.Empty)),
                            new Columns<StockHolding>(x => x.Product.ID)
                                .Add(x => x.Style.ID)
                                .Add(x => x.Dimensions.UnitSize)
                                .Add(x => x.Units)
                                .Add(x => x.Job.ID)
                                .Add(x => x.Job.JobStatus.Active)),
                        new KeyedQueryDef<PurchaseOrderItem>(
                            new Filter<PurchaseOrderItem>(x => x.ReceivedDate).IsEqualTo(DateTime.MinValue)
                                .And(x => x.Product.ID).InList(pids)
                                .And(new Filter<PurchaseOrderItem>(x => x.Job.ID).IsEqualTo(Guid.Empty).Or(x => x.Job.ID).IsNotEqualTo(Master?.ID ?? Guid.Empty)),
                            new Columns<PurchaseOrderItem>(x => x.Product.ID)
                                .Add(x => x.Style.ID)
                                .Add(x => x.Dimensions.UnitSize)
                                .Add(x => x.Qty)
                                .Add(x => x.Job.ID)
                                .Add(x => x.Job.JobStatus.Active)));

                    var freestock = results.Get<StockHolding>();
                    var freestockcolumns = new Columns<StockHolding>(freestock.Columns.Select(x => x.ColumnName));

                    var freeorders = results.Get<PurchaseOrderItem>();
                    var freeordercolumns = new Columns<PurchaseOrderItem>(freeorders.Columns.Select(x => x.ColumnName));

                    var hasStyle = StyleColumnVisible();
                    var keys = GetKeys(data.Rows, columns, hasStyle);

                    foreach (var key in keys)
                    {

                        var rows = GetRows(data.Rows, columns, key.Item1, key.Item2, key.Item3, key.Item4);
                        if (rows.Any())
                        {

                            CoreRow newrow = table.NewRow();
                            newrow.LoadValues(rows.First().Values);

                            var bom = Aggregate(rows, columns, hasStyle, true, x => x.BillOfMaterials, newrow,
                                x => x.BillOfMaterials);
                            var requi = Aggregate(rows, columns, hasStyle, true, x => x.Requisitions, newrow, x => x.Requisitions);
                            var picklist = Aggregate(rows, columns, hasStyle, true, x => x.PickingLists, newrow,
                                x => x.PickingLists);
                            var issued = Aggregate(rows, columns, hasStyle, true, x => x.Issued, newrow, x => x.Issued);

                            var reserved = Aggregate(rows, columns, hasStyle, true, x => x.ReservedStock, newrow,
                                x => x.ReservedStock);
                            var ordered = Aggregate(rows, columns, hasStyle, true, x => x.OnOrder, newrow, x => x.OnOrder);

                            var shortage = Math.Max(0, Math.Max(0, (requi - issued)) - (reserved + ordered));
                            newrow.Set<JobMaterial, double>(x => x.JobShortage, shortage);

                            var freestockrows = GetRows(freestock.Rows, freestockcolumns, null, key.Item2, key.Item3, key.Item4,
                                IncludeReserves ? null : (r) => !r.Get<StockHolding, bool>(x => x.Job.JobStatus.Active));
                            var freeonhand = Aggregate(freestockrows, freestockcolumns, hasStyle, false, x => x.Units, newrow,
                                x => x.FreeOnHand);
                            newrow.Set<JobMaterial, double>(x => x.FreeOnHand, freeonhand);

                            var freeorderrows = GetRows(freeorders.Rows, freeordercolumns, null, key.Item2, key.Item3, key.Item4,
                                IncludeReserves ? null : (r) => !r.Get<PurchaseOrderItem, bool>(x => x.Job.JobStatus.Active));
                            var freeonorder = Aggregate(freeorderrows, freeordercolumns, hasStyle, false, x => x.Qty, newrow,
                                x => x.FreeOnOrder);
                            newrow.Set<JobMaterial, double>(x => x.FreeOnOrder, freeonorder);

                            newrow.Set<JobMaterial, double>(x => x.FreeStockTotal, freeonhand + freeonorder);
                            newrow.Set<JobMaterial, double>(x => x.FreeStockShortage, Math.Max(0, shortage - (freeonhand + freeonorder)));
                            table.Rows.Add(newrow);
                        }


                    }
                }

                action?.Invoke(table, null);

            }
        );
    }

    protected override bool FilterRecord(CoreRow row)
    {
        var result = base.FilterRecord(row)
            && (
                row.Get<JobMaterial, double>(x => x.BillOfMaterials) != 0.0F ||
                row.Get<JobMaterial, double>(x => x.Requisitions) != 0.0F ||
                row.Get<JobMaterial, double>(x => x.PickingLists) != 0.0F ||
                row.Get<JobMaterial, double>(x => x.Issued) != 0.0F ||
                row.Get<JobMaterial, double>(x => x.ReservedStock) != 0.0F ||
                row.Get<JobMaterial, double>(x => x.OnOrder) != 0.0F
            );
        if (ShowIssues)
        {
            result = result && (
                row.Get<JobMaterial, double>(x => x.JobShortage) > 0.0F ||
                row.Get<JobMaterial, double>(x => x.FreeStockShortage) > 0.0F);
        }
        return result;
    }

    #region Create PO
    private void GetEmpID()
    {
        CoreTable table = new Client<Employee>().Query(new Filter<Employee>(x => x.UserLink.UserID).IsEqualTo(ClientFactory.UserID), new Columns<Employee>(x => x.ID, x => x.Name));
        if (table.Rows.Any())
        {
            empID = Guid.Parse(table.Rows.FirstOrDefault().Values[0].ToString());
            empName = table.Rows.FirstOrDefault().Values[1].ToString();
        }
    }

    private bool CreatePO(System.Windows.Controls.Button btn, CoreRow[] rows)
    {
        if (!rows.Any())
        {
            MessageBox.Show("Please select at least one row to add to PO");
            return false;
        }
        PurchaseOrder purchaseOrder = new PurchaseOrder();
        purchaseOrder.Description = "Created from Job Summary Screen" + System.Environment.NewLine;
        purchaseOrder.RaisedBy.ID = empID;
        var page = new SupplierPurchaseOrders();
        page.OnAfterSave += (form, items) =>
        {
            MessageBox.Show("Success - New Purchase Order Created (" + purchaseOrder.PONumber + ")");
        };
        return page.EditItems(new[] { purchaseOrder }, LoadPurchaseOrderItems, true);
    }

    private CoreTable LoadPurchaseOrderItems(Type arg)
    {
        Progress.Show("Working");
        var result = new CoreTable();
        result.LoadColumns(typeof(PurchaseOrderItem));
        List<PurchaseOrderItem> items = new List<PurchaseOrderItem>();
        foreach (CoreRow row in SelectedRows)
        {
            JobMaterial material = row.ToObject<JobMaterial>();
            PurchaseOrderItem POItem = new PurchaseOrderItem();
            POItem.Product.ID = material.Product.ID;
            POItem.Product.Code = material.Product.Code;
            POItem.Product.Name = material.Product.Name;
            POItem.Description = material.Product.Name;
            POItem.Qty = 0;
            POItem.Dimensions.CopyFrom(material.Dimensions);
            POItem.Style.ID = material.Style.ID;
            POItem.Style.Code = material.Style.Code;
            POItem.Style.Description = material.Style.Description;
            POItem.Job.ID = material.Job.ID;
            POItem.Dimensions.UnitSize = material.Dimensions.UnitSize;
            items.Add(POItem);
        }
        result.LoadRows(items);
        Progress.Close();
        return result;
    }

    #endregion
}