prs/prs.desktop/Panels/Staging/StagingPanel.xaml.cs

using Comal.Classes;
using InABox.Core;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using InABox.Clients;
using InABox.Configuration;
using InABox.DynamicGrid;
using System.Diagnostics;
using System.IO;
using InABox.WPF;
using InABox.Wpf;
using System.ComponentModel;
using InABox.Scripting;
using System.Reflection;
using System.Collections.Immutable;
using StagingManufacturingPacketComponent = Comal.Classes.StagingManufacturingPacketComponent;
using System.Threading.Tasks;
using NPOI.SS.Formula.Functions;
using Columns = InABox.Core.Columns;

namespace PRSDesktop;

[Caption("Staging Panel Settings")]
public class StagingPanellSettings : BaseObject, IGlobalConfigurationSettings
{
    [Caption("PDF Markup Program Pathway", IncludePath = false)]
    [FileNameEditor]
    public string MarkupPathway { get; set; }

    [FolderEditor(Environment.SpecialFolder.CommonDocuments)]
    public string SetoutsFolder { get; set; }

    [ScriptEditor]
    public string? Script { get; set; }

    [Comment("Maximum Document Size (MB)")]
    [IntegerEditor(Caption = "Maximum Document Size (MB)", ToolTip = "The user will be warned when uploading documents which are larger than this size in megabytes. Set to zero for no maximum.")]
    public int MaximumDocumentSize { get; set; }

    public StagingPanellSettings()
    {
        MarkupPathway = "";
        SetoutsFolder = "";
        Script = null;
        MaximumDocumentSize = 0;
    }

    public string DefaultScript()
    {
        return @"
using PRSDesktop;
using InABox.Core;
using System.Collections.Generic;

public class Module
{
    /*public void CustomiseSetouts(CustomiseSetoutsArgs args)
    {
        // Perform customisation on the setouts when they are added to the 'Staged Documents' grid.
    }*/
}";
    }
}

public class CustomiseSetoutsArgs
{
    public IReadOnlyList<Tuple<StagingSetout, Document>> Setouts;

    public CustomiseSetoutsArgs(IReadOnlyList<Tuple<StagingSetout, Document>> setouts)
    {
        Setouts = setouts;
    }
}

/// <summary>
/// Interaction logic for StagingPanel.xaml
/// </summary>
public partial class StagingPanel : UserControl, IPanel<StagingSetout>
{
    private StagingPanellSettings _settings = new StagingPanellSettings();
    
    /// <summary>
    /// The currently selected setout.
    /// </summary>
    private StagingSetout? selectedSetout;

    /// <summary>
    /// All currently selected setouts; <see cref="selectedSetout"/> will be a member of this list.
    /// </summary>
    private List<StagingSetout> selectedSetouts = new();

    private CoreTable _templateGroups = null!;

    #region Script Stuff

    private MethodInfo? _customiseSetoutsMethod;
    private MethodInfo? CustomiseSetoutsMethod
    {
        get
        {
            EnsureScript();
            return _customiseSetoutsMethod;
        }
    }
    private object? _scriptObject;
    private object? ScriptObject
    {
        get
        {
            EnsureScript();
            return _scriptObject;
        }
    }
    private ScriptDocument? _script;
    private ScriptDocument? Script
    {
        get
        {
            EnsureScript();
            return _script;
        }
    }
    private void EnsureScript()
    {
        if (_script is null && !_settings.Script.IsNullOrWhiteSpace())
        {
            _script = new ScriptDocument(_settings.Script);
            if (!_script.Compile())
            {
                throw new Exception("Script in Staging Panel Settings failed to compile!");
            }
            _scriptObject = _script?.GetObject();
            _customiseSetoutsMethod = _script?.GetMethod(methodName: "CustomiseSetouts");
        }
    }

    #endregion

    public StagingPanel()
    {
        InitializeComponent();
        SectionName = nameof(StagingPanel);
    }

    public void Setup()
    {
        _settings = new GlobalConfiguration<StagingPanellSettings>().Load();
        
        _templateGroups = new Client<ManufacturingTemplateGroup>().Query();
        
        MarkUpButton.Visibility = Security.IsAllowed<CanMarkUpSetouts>() ? Visibility.Visible : Visibility.Hidden;
        RejectButton.Visibility = Security.IsAllowed<CanApproveSetouts>() ? Visibility.Visible : Visibility.Hidden;
        ApproveButton.Visibility = Security.IsAllowed<CanApproveSetouts>() ? Visibility.Visible : Visibility.Hidden;
        ProcessButton.Visibility = Security.IsAllowed<CanApproveSetouts>() ? Visibility.Visible : Visibility.Hidden;

        //stagingSetoutGrid.ScanFiles(_settings.SetoutsFolder);
        stagingSetoutGrid.PanelSettings = _settings;
        stagingSetoutGrid.Refresh(true, false);
        SetoutComponentGrid.Refresh(true, false);
        
    }

    private bool CanViewPackets() => MainPanel.View != DynamicSplitPanelView.Master && NestedPanel.View != DynamicSplitPanelView.Master;

    private void NestedPanel_OnChanged(object sender, DynamicSplitPanelSettings e)
    {
        if(CanViewPackets())
        {
            ManufacturingPacketList.Setout = selectedSetout;
            SetoutComponentGrid.StagingSetout = selectedSetout;
        }
    }

    #region Document Viewer

    public enum DocumentMode
    {
        Markup,
        Complete,
        Locked
    }
    private DocumentMode _mode;
    private DocumentMode Mode
    {
        get => _mode;
        set  => SetMode(value);
    }

    private void SetMode(DocumentMode mode)
    {
        _mode = mode;
        if (_mode == DocumentMode.Markup)
        {
            MarkUpButton.Content = "Mark Up";
            MarkUpButton.IsEnabled = Document != null && !Document.Approved;
            UpdateOriginalButton.Visibility =
                Document != null && !String.Equals(Document.DocumentLink.CRC, selectedSetout?.OriginalCRC)
                    ? Visibility.Visible
                    : Visibility.Collapsed;
            ProcessButton.IsEnabled = Document != null && Document.Approved;
            RejectButton.IsEnabled = Document != null && !Document.Approved;
            ApproveButton.IsEnabled = Document != null;
        }
        else if (_mode == DocumentMode.Complete)
        {
            MarkUpButton.Content = "Complete";
            MarkUpButton.IsEnabled = Document != null;
            UpdateOriginalButton.Visibility = Visibility.Collapsed;
            ProcessButton.IsEnabled = false;
            RejectButton.IsEnabled = false;
            ApproveButton.IsEnabled = false;
        }
        else if (_mode == DocumentMode.Locked)
        {
            MarkUpButton.Content = "Locked";
            MarkUpButton.IsEnabled = false;
            UpdateOriginalButton.Visibility = Visibility.Collapsed;
            ProcessButton.IsEnabled = false;
            RejectButton.IsEnabled = false;
            ApproveButton.IsEnabled = false;
        }
    }

    private StagingSetoutDocument? _document;

    private StagingSetoutDocument? Document
    {
        get => _document;
        set
        {
            _document = value;
            if(_document is not null)
            {
                ApproveButton.Content = _document.Approved ? "Unapprove" : "Approve";
            }
        }
    }

    private byte[]? _documentdata = null;

    private void ClearDocuments()
    {
        Document = null;
        RenderDocuments(null);
    }

    private List<byte[]>? GetDocuments(StagingSetoutDocument? document)
    {
        if(document is null)
        {
            return null;
        }
        var table = new Client<Document>().Query(
            new Filter<Document>(x => x.ID).IsEqualTo(document.DocumentLink.ID),
            Columns.None<Document>().Add(x => x.Data));
        var first = table.Rows.FirstOrDefault();
        if (first is null)
            return null;
        _documentdata = first.Get<Document, byte[]>(x => x.Data);
        return ImageUtils.RenderPDFToImageBytes(_documentdata);
    }
    
    private void RenderDocuments(List<byte[]>? documents)
    {
        DocumentViewer.Children.Clear();
        if(documents is not null)
        {
            foreach (var image in documents)
            {
                DocumentViewer.Children.Add(new Image
                {
                    Source = ImageUtils.LoadImage(image),
                    Margin = new Thickness(0, 0, 0, 20)
                });
            }
        }
    }

    private void ProcessButton_Click(object sender, RoutedEventArgs e)
    {
        bool bulkApprove = false;
        if (selectedSetouts.Count > 1)
        {
            if (MessageBox.Show("Bulk approve? (Skip individual setout approval)", "Continue?", MessageBoxButton.OKCancel) == MessageBoxResult.OK)
            {
                bulkApprove = true;
                Progress.Show("Approving Setouts..");
            }
        }

        if (selectedSetouts.Any(x => x.UnapprovedDocuments > 0))
        {
            MessageBox.Show("Cannot process setouts with unapproved documents.");
            Progress.Close();
            return;
        }

        if (selectedSetouts.Any(x => x.JobLink.ID == Guid.Empty))
        {
            MessageBox.Show("Cannot process setout without a linked job.");
            Progress.Close();
            return;
        }

        if (ManufacturingPacketList.Packets.Any(x => x.Template.ID == Guid.Empty))
        {
            MessageBox.Show("Cannot process manufacturing packets without templates.");
            Progress.Close();
            return;
        }

        if (selectedSetouts.Any(x => x.Packets == 0))
        {
            if (MessageBox.Show("Warning: some setouts do not have any manufacturing packets: are you sure you wish to proceed?", "Warning", MessageBoxButton.YesNoCancel) != MessageBoxResult.Yes)
            {
                Progress.Close();
                return;
            }
        }



        string message = "";

        foreach (var item in selectedSetouts)
        {
            if (bulkApprove)
                Progress.Show("Working on " + item.Number);
            var returnstring = ApproveSetout(item, bulkApprove);
            if (!string.IsNullOrWhiteSpace(returnstring))
                message = message + returnstring + Environment.NewLine;
        }

        if (bulkApprove)
            Progress.Close();

        new Client<StagingSetout>().Save(selectedSetouts, "Updated from staging screen");
        selectedSetout = null;
        Refresh();

        if (!message.IsNullOrWhiteSpace())
        {
            MessageBox.Show($"Result:\n{message}");
        }
        MainPanel.View = DynamicSplitPanelView.Combined;
        NestedPanel.View = DynamicSplitPanelView.Master;
    }

    private string ApproveSetout(StagingSetout item, bool bulkapprove)
    {
        if (item.Group.ID == Guid.Empty)
        {
            var message = "Setout has no group assigned";
            if (Security.IsAllowed<CanApproveSetoutsWithoutGroup>())
            {
                if (MessageBox.Show(message + ", continue?", "Continue?", MessageBoxButton.OKCancel) != MessageBoxResult.OK)
                    return "";
            }
            else
            {
                MessageBox.Show(message + ", please assign a group!");
                return "";
            }
        }

        var setoutDocument = new Client<StagingSetoutDocument>()
            .Query(
                new Filter<StagingSetoutDocument>(x => x.EntityLink.ID).IsEqualTo(item.ID),
                Columns.None<StagingSetoutDocument>().Add(x => x.ID, x => x.DocumentLink.ID, x => x.DocumentLink.FileName))
            .ToObjects<StagingSetoutDocument>().FirstOrDefault();

        if (setoutDocument is null)
            return "";

        var setout = new Client<Setout>()
            .Query(
                new Filter<Setout>(x => x.Number).IsEqualTo(item.Number),
                Columns.Required<Setout>().Add(x => x.ID))
            .ToObjects<Setout>().FirstOrDefault();

        string result;
        //setout already exists - create new setoutdoc and supercede old ones
        if (setout is not null)
        {
            if (!bulkapprove)
                if (MessageBox.Show("Supercede existing documents?", "Proceed?", MessageBoxButton.YesNo) != MessageBoxResult.Yes)
                    return "";

            setout.Group.ID = item.Group.ID;

            item.Setout.ID = setout.ID;

            var setoutdoc = new SetoutDocument();
            setoutdoc.EntityLink.ID = setout.ID;
            setoutdoc.DocumentLink.ID = setoutDocument.DocumentLink.ID;

            var setoutdocs = new List<SetoutDocument>
            {
                setoutdoc
            };

            CoreTable oldDocsTable = new Client<SetoutDocument>().Query(
                new Filter<SetoutDocument>(x => x.EntityLink.ID).IsEqualTo((Guid)setout.ID)
                .And(x => x.DocumentLink.ID).IsNotEqualTo(item.Group.OptimizationDocument.ID)
                );
            foreach (var row in oldDocsTable.Rows)
            {
                var oldDoc = row.ToObject<SetoutDocument>();
                if (oldDoc.Superceded == DateTime.MinValue)
                {
                    oldDoc.Superceded = DateTime.Now;
                    setoutdocs.Add(oldDoc);
                }
            }
            new Client<SetoutDocument>().Save(setoutdocs, "Updated from Staging Screen");
            new Client<Setout>().Save((Setout)setout, "Updated from Staging Screen");

            result = item.Number + " Superceded";
        }
        //no setout for this pdf - create new
        else
        {
            setout = new Setout
            {
                Number = item.Number
            };
            setout.JobLink.ID = item.JobLink.ID;
            setout.Group.ID = item.Group.ID;

            var editor = new DynamicDataGrid<Setout>();
            editor.OnAfterSave += (editor, items) =>
            {
                CreateSetoutDocument(setout, item, setoutDocument);
            };

            if (!bulkapprove)
            {
                if (!editor.EditItems(new[] { setout }))
                {
                    MessageBox.Show("Setout Creation Cancelled");
                    return "";
                }
                else
                    result = item.Number + " Created";
            }
            else
            {
                new Client<Setout>().Save(setout, "Added from staging screen");
                CreateSetoutDocument(setout, item, setoutDocument);
                result = item.Number + " Created";
            }
        }

        var tuples = new List<Tuple<ManufacturingPacket, StagingManufacturingPacket>>();
        var stagingPackets = new Client<StagingManufacturingPacket>()
            .Query(
                new Filter<StagingManufacturingPacket>(x => x.StagingSetout.ID).IsEqualTo(item.ID),
                Columns.Required<StagingManufacturingPacket>().Add(x => x.ID)
                    .Add(x => x.Serial)
                    .Add(x => x.Title)
                    .Add(x => x.Quantity)
                    .Add(x => x.BarcodeQuantity)
                    .Add(x => x.Watermark)
                    .Add(x => x.Group.Watermark)
                    .Add(x => x.Location)
                    .Add(x => x.ITP.ID)
                    .Add(x => x.Job.ID)
                    .Add(x => x.Template.ID));
        foreach(var stagingPacket in stagingPackets.ToObjects<StagingManufacturingPacket>())
        {
            if(stagingPacket.ManufacturingPacket.ID != Guid.Empty)
            {
                MessageBox.Show($"A manufacturing packet already exists for {stagingPacket.Serial}; skipping packet.");
                continue;
            }

            var packet = new ManufacturingPacket
            {
                Serial = stagingPacket.Serial,
                Title = stagingPacket.Title,
                Quantity = stagingPacket.Quantity,
                BarcodeQty = string.IsNullOrWhiteSpace(stagingPacket.BarcodeQuantity) 
                    ? stagingPacket.Quantity 
                    : int.Parse(stagingPacket.BarcodeQuantity),
                WaterMark = string.IsNullOrWhiteSpace(stagingPacket.Watermark) 
                    ? stagingPacket.Group.Watermark
                    : stagingPacket.Watermark,
                Location = stagingPacket.Location
            };
            packet.SetoutLink.ID = setout.ID;
            packet.ITP.ID = stagingPacket.ITP.ID;
            packet.JobLink.ID = stagingPacket.Job.ID;
            packet.ManufacturingTemplateLink.ID = stagingPacket.Template.ID;

            tuples.Add(new(packet, stagingPacket));
        }
        new Client<ManufacturingPacket>().Save(tuples.Select(x => x.Item1), "Created from Design Management Panel");

        var newStages = new List<ManufacturingPacketStage>();
        var newComponents = new List<ManufacturingPacketComponent>();
        var newTreatments = new List<ManufacturingTreatment>(); 
        foreach(var (packet, stagingPacket) in tuples)
        {
            stagingPacket.ManufacturingPacket.ID = packet.ID;
            
            var stages = new Client<StagingManufacturingPacketStage>()
                .Query(
                    new Filter<StagingManufacturingPacketStage>(x => x.Packet.ID).IsEqualTo(stagingPacket.ID),
                    IManufacturingPacketGeneratorExtensions.GetPacketGeneratorRequiredColumns<StagingManufacturingPacketStage>());
            newStages.AddRange(stages.ToObjects<StagingManufacturingPacketStage>()
                .Select(x =>
                {
                    var stage = x.CreateManufacturingPacketStage();
                    stage.Parent.ID = packet.ID;
                    return stage;
                }));
            
            var components = new Client<StagingManufacturingPacketComponent>()
                .Query(
                    new Filter<StagingManufacturingPacketComponent>(x => x.Packet.ID).IsEqualTo(stagingPacket.ID),
                    Columns.None<StagingManufacturingPacketComponent>().Add(x=>x.Packet.ID)
                        .Add(x => x.Product.ID)
                        .Add(x => x.Quantity)
                        .Add(x => x.Dimensions.Unit.ID)
                        .Add(x => x.Dimensions.Quantity)
                        .Add(x => x.Dimensions.Length)
                        .Add(x => x.Dimensions.Width)
                        .Add(x => x.Dimensions.Height)
                        .Add(x => x.Dimensions.Weight)
                        .Add(x => x.Dimensions.Value)
                        .Add(x => x.Dimensions.UnitSize)
                );
            
            newComponents.AddRange(components.ToObjects<StagingManufacturingPacketComponent>()
                .Select(x => x.CreateComponent(packet.ID)));
            
            var treatments = new Client<StagingManufacturingPacketTreatment>()
                .Query(
                    new Filter<StagingManufacturingPacketTreatment>(x => x.Packet.ID).IsEqualTo(stagingPacket.ID),
                    Columns.None<StagingManufacturingPacketTreatment>().Add(x=>x.Packet.ID)
                        .Add(x=>x.Product.ID)
                        .Add(x=>x.Parameter)
                );
            
            newTreatments.AddRange(treatments.ToObjects<StagingManufacturingPacketTreatment>()
                .Select(x => x.CreateTreatment(packet.ID)));
            
        }
        new Client<ManufacturingPacketStage>().Save(newStages, "Created from Design Management");
        new Client<ManufacturingPacketComponent>().Save(newComponents, "Created from Design Management");
        new Client<ManufacturingTreatment>().Save(newTreatments, "Created from Design Management");
        new Client<StagingManufacturingPacket>().Save(tuples.Select(x => x.Item2), "Created from Design Management");

        //currently not creating packets due to temporary change in requirements - to uncomment and check for validity when required
        //CreatePackets(setout);
        return result;
    }

    private static void CreateSetoutDocument(Setout setout, StagingSetout item, StagingSetoutDocument stagingsetoutdocument)
    {
        item.Setout.ID = setout.ID;

        var setoutdoc = new SetoutDocument();
        setoutdoc.EntityLink.ID = setout.ID;
        setoutdoc.DocumentLink.ID = stagingsetoutdocument.DocumentLink.ID;

        new Client<SetoutDocument>().Save(setoutdoc, "Added from staging screen");
    }

    private void RejectButton_Click(object sender, RoutedEventArgs e)
    {
        if (selectedSetout is null || Document is null)
        {
            MessageBox.Show("Please select a setout");
            return;
        }
        //dont create setout - setout.id remains blank
        //create kanban and populate task.id - this prevents it from appearing on the stagingsetout grid, and allows a new staging setout to be created when the file is saved to the folder again
        //attach the document to the task for reference

        var task = new Kanban
        {
            Title = "Setout Review Task (setout rejected)",
            Description = "Please review the attached document for setout " + selectedSetout.Number
        };
        task.ManagerLink.ID = App.EmployeeID;

        if (DynamicGridUtils.EditEntity(task))
        {
            var doc = new KanbanDocument();
            doc.EntityLink.ID = task.ID;
            doc.DocumentLink.ID = Document.DocumentLink.ID;
            new Client<KanbanDocument>().Save(doc, "Created from staging screen");

            selectedSetout.Task.ID = task.ID;
            new Client<StagingSetout>().Save(selectedSetout, "Updated from staging screen");

            MessageBox.Show("Success - Task Created for Document " + selectedSetout.Number + " (Task no. " + task.Number + " assigned to " + task.EmployeeLink.Name + ")");
            selectedSetout = null;

            ClearDocuments();
            refreshing = true;
            stagingSetoutGrid.Refresh(false, true);
        }
        else
        {
            MessageWindow.ShowMessage("Task creation cancelled - setout not rejected", "Action cancelled");
        }
    }

    private void MarkUpButton_Click(object sender, RoutedEventArgs e)
    {
        if (Mode == DocumentMode.Markup)
        {
            Mode = DocumentMode.Complete;
            MessageBox.Show("IMPORTANT - press save in your document editor, then press the Complete Button in PRS");
            OnMarkupSelected();
        }
        else
        {
            OnMarkupComplete();
            Mode = DocumentMode.Markup;
        }
    }

    private void UpdateOriginalButton_Click(object sender, RoutedEventArgs e)
    {
        if ((_documentdata?.Any() == true) && !String.IsNullOrWhiteSpace(selectedSetout?.OriginalPath))
        {
            try
            {
                File.WriteAllBytes(selectedSetout.OriginalPath, _documentdata);
                selectedSetout.OriginalCRC = CoreUtils.CalculateCRC(_documentdata);
                new Client<StagingSetout>().Save(selectedSetout,"Updated Source File with markups");
                UpdateOriginalButton.Visibility = Visibility.Collapsed;
            }
            catch (Exception _exception)
            {
                MessageBox.Show($"Unable to update {selectedSetout?.OriginalPath}!\n\n{_exception.Message}");
            }
            return;
        }
        MessageBox.Show("Please select a design first!");
    }

    private void ApproveButton_Click(object sender, RoutedEventArgs e)
    {
        if (Document is null || selectedSetout is null)
        {
            MessageBox.Show("Please select a setout first.");
            return;
        }
        if (selectedSetouts.Count > 1)
        {
            var msg = Document.Approved
                ? "Bulk unapprove?"
                : "Bulk approve? (Skip individual setout approval)";
            if (MessageBox.Show(msg, "Continue?", MessageBoxButton.OKCancel) == MessageBoxResult.OK)
            {
                Progress.Show("Approving Setouts..");
                var documents = Client.Query(
                    new Filter<StagingSetoutDocument>(x => x.EntityLink.ID).InList(selectedSetouts.Select(x => x.ID).ToArray()),
                    Columns.Required<StagingSetoutDocument>().Add(x => x.ID, x => x.Approved)
                ).ToObjects<StagingSetoutDocument>().ToList();
                foreach(var document in documents)
                {
                    document.Approved = !Document.Approved;
                }
                Client.Save(documents, "Approved by user.");

                Progress.Close();

                refreshing = true;
                stagingSetoutGrid.Refresh(false, true);
            }
        }
        else
        {
            Document.Approved = !Document.Approved;
            new Client<StagingSetoutDocument>().Save(Document, "");
            refreshing = true;
            stagingSetoutGrid.Refresh(false, true);
        }
    }

    private void OnMarkupSelected()
    {
        if (Document is null || selectedSetout is null)
        {
            MessageBox.Show("Please select a setout first.");
            return;
        }

        var doc = new Client<Document>()
            .Query(
                new Filter<Document>(x => x.ID).IsEqualTo(Document.DocumentLink.ID))
            .ToObjects<Document>().FirstOrDefault();
        if (doc is null)
        {
            Logger.Send(LogType.Error, "", $"Document with ID {Document.DocumentLink.ID} could not be found.");
            MessageBox.Show("Error: the selected document could not be found in the database.");
            return;
        }

        var tempdocpath = Path.Combine(Path.GetTempPath(), doc.FileName);
        selectedSetout.SavePath = tempdocpath;
        selectedSetout.LockedBy.ID = App.EmployeeID;
        selectedSetout.LockedBy.Name = App.EmployeeName;
        new Client<StagingSetout>().Save(selectedSetout, "Locked from Staging Screen");
        File.WriteAllBytes(tempdocpath, doc.Data);
        using (var p = new Process())
        {
            p.StartInfo = new ProcessStartInfo()
            {
                UseShellExecute = true,
                FileName = tempdocpath
            };

            p.Start();
        }
        refreshing = true;
        stagingSetoutGrid.Refresh(false, true);
    }
    private void OnMarkupComplete()
    {
        if (selectedSetout is null)
        {
            MessageBox.Show("Please select a setout first.");
            return;
        }
        StagingSetoutGrid.ReloadFile(selectedSetout);
        refreshing = true;
        stagingSetoutGrid.Refresh(false, true);
    }

    #endregion

    private bool refreshing = false;

    private void stagingSetoutGrid_AfterRefresh(object sender, AfterRefreshEventArgs args)
    {
        refreshing = false;
    }

    private void StagingSetoutGrid_OnSelectItem(object sender, InABox.DynamicGrid.DynamicGridSelectionEventArgs e)
    {
        var newSetouts = new List<StagingSetout>();
        foreach (var row in e.Rows ?? Enumerable.Empty<CoreRow>())
            newSetouts.Add(row.ToObject<StagingSetout>());

        if(!refreshing && (selectedSetouts.Count == newSetouts.Count
            && !selectedSetouts.Any(x => !newSetouts.Any(y => x.ID == y.ID))))
        {
            selectedSetouts = newSetouts;
            selectedSetout = selectedSetouts.FirstOrDefault();
            return;
        }

        selectedSetouts = newSetouts;

        selectedSetout = selectedSetouts.FirstOrDefault();
        AddPacketButton.IsEnabled = selectedSetout is not null;
        if(selectedSetout is null)
        {
            ClearDocuments();
            ManufacturingPacketList.Setout = null;
            CollapsePacketsButton.IsEnabled = false;
            SetoutComponentGrid.StagingSetout = null;
            SetMode(DocumentMode.Markup);
            return;
        }

        var doc = new Client<StagingSetoutDocument>()
            .Query(
                new Filter<StagingSetoutDocument>(x => x.EntityLink.ID).IsEqualTo(selectedSetout.ID),
                Columns.None<StagingSetoutDocument>().Add(x => x.ID)
                    .Add(x => x.DocumentLink.ID)
                    .Add(x => x.DocumentLink.FileName)
                    .Add(x => x.Approved)
                    .Add(x=>x.DocumentLink.CRC)
            ).ToObjects<StagingSetoutDocument>().FirstOrDefault();
        if(doc is null)
        {
            MessageBox.Show("No document found for this setout.");
            ClearDocuments();
            ManufacturingPacketList.Setout = null;
            CollapsePacketsButton.IsEnabled = false;
            SetoutComponentGrid.StagingSetout = null;
            return;
        }

        Document = doc;
        var docTask = Task.Run(() => GetDocuments(doc));
        if(CanViewPackets())
        {
            ManufacturingPacketList.Setout = selectedSetout;
            SetoutComponentGrid.StagingSetout = selectedSetout;
        }
        CollapsePacketsButton.IsEnabled = true;
        var mode =
            selectedSetout.LockedBy.ID == Guid.Empty ?
                DocumentMode.Markup :
                selectedSetout.LockedBy.ID == App.EmployeeID ?
                    DocumentMode.Complete :
                    DocumentMode.Locked;

        docTask.Wait();
        RenderDocuments(docTask.Result);

        SetMode(mode);
    }

    public bool IsReady { get; set; }

    public string SectionName { get; }


    public event DataModelUpdateEvent? OnUpdateDataModel;

    #region Settings

    public void CreateToolbarButtons(IPanelHost host)
    {
        ProjectSetupActions.JobStatuses(host);
        ProjectSetupActions.DrawingTemplates(host);
        host.CreateSetupSeparator();
        ProjectSetupActions.JobSpreadsheetTemplates(host);
        host.CreateSetupSeparator();
        ProjectSetupActions.SetoutGroups(host);
        host.CreateSetupSeparator();

        host.CreateSetupAction(
            new PanelAction()
            {
                Caption = "Setouts Configuration", 
                Image = PRSDesktop.Resources.specifications,
                OnExecute = ConfigSettingsClick
            }
        );
        host.CreateSetupAction(
            new PanelAction()
            {
                Caption = "Component Import Profiles",
                Image = PRSDesktop.Resources.doc_xls,
                OnExecute = ConfigComponentProfiles
            });

        host.CreateSetupAction(
            new PanelAction() 
            { 
                Caption = "Template Products", 
                Image = PRSDesktop.Resources.specifications,
                OnExecute =
                    action =>
                    {
                        var list = new MasterList(typeof(ManufacturingTemplateGroupProducts));
                        list.ShowDialog();
                    }  
            }
        );
        
        SystemSetupActions.ERPStatuses(host);
        
    }

    private void ConfigComponentProfiles(PanelAction obj)
    {
        var list = new DynamicImportList(
            typeof(StagingSetoutComponent),
            Guid.Empty,
            canImport: false
        );
        list.ShowDialog();
    }

    private void ConfigSettingsClick(PanelAction obj)
    {
        var grid = new DynamicItemsListGrid<StagingPanellSettings>();
        grid.OnCustomiseEditor += Grid_OnCustomiseEditor;
        if(grid.EditItems(new[] { _settings }))
        {
            new GlobalConfiguration<StagingPanellSettings>().Save(_settings);
            _script = null;
        }
    }

    private void Grid_OnCustomiseEditor(IDynamicEditorForm sender, StagingPanellSettings[]? items, DynamicGridColumn column, BaseEditor editor)
    {
        if (items?.FirstOrDefault() is not StagingPanellSettings settings) return;

        if (column.ColumnName == nameof(StagingPanellSettings.Script) && editor is ScriptEditor scriptEditor)
        {
            scriptEditor.Type = ScriptEditorType.TemplateEditor;
            scriptEditor.OnEditorClicked += () =>
            {
                var script = settings.Script.NotWhiteSpaceOr()
                    ?? settings.DefaultScript();

                var editor = new ScriptEditorWindow(script, SyntaxLanguage.CSharp);
                if (editor.ShowDialog() == true)
                {
                    sender.SetEditorValue(column.ColumnName, editor.Script);
                    settings.Script = editor.Script;
                }
            };
        }
    }

    #endregion

    public void Heartbeat(TimeSpan time)
    {

    }

    public void Refresh()
    {
        //stagingSetoutGrid.ScanFiles(_settings.SetoutsFolder);
        refreshing = true;
        stagingSetoutGrid.Refresh(false, true);
        /*Document = null;

        selectedSetout = null;
        ManufacturingPacketList.Setout = null;
        SetoutComponentGrid.StagingSetout = null;*/
        CalculateTime();
    }

    private void stagingSetoutGrid_OnRefreshPackets()
    {
        if (CanViewPackets())
        {
            ManufacturingPacketList.Refresh();
        }
    }

    public Dictionary<string, object[]> Selected()
    {
        return new();
    }


    public void Shutdown(CancelEventArgs? cancel)
    {

    }

    public DataModel DataModel(Selection selection)
    {
        return new AutoDataModel<StagingSetout>(new Filter<StagingSetout>().All());
    }

    private void AddPacketButton_Click(object sender, RoutedEventArgs e)
    {
        if (_templateGroups.Rows.Any() == true)
        {
            ContextMenu menu = new ContextMenu();
            foreach (var row in _templateGroups.Rows)
            {
                menu.AddItem(
                    $"{row.Get<ManufacturingTemplateGroup, String>(x => x.Code)}: {row.Get<ManufacturingTemplateGroup, String>(x => x.Description)}",
                    null,
                    () =>
                    {
                        ManufacturingPacketList.Add(
                            selectedSetout?.JobLink.ID ?? Guid.Empty,
                            row.ToObject<ManufacturingTemplateGroup>()
                        );
                        UpdateStagingSetoutGrid();
                    });
            }

            menu.AddSeparator();
            menu.AddItem("Miscellaneous Item", null, () =>
            {
                ManufacturingPacketList.Add(
                    selectedSetout?.JobLink.ID ?? Guid.Empty,
                    null
                );
                UpdateStagingSetoutGrid();
            });
            menu.IsOpen = true;
        }
        else
        {
            ManufacturingPacketList.Add(
                selectedSetout?.JobLink.ID ?? Guid.Empty, 
                null
            );
            UpdateStagingSetoutGrid();
        }

    }

    private void UpdateStagingSetoutGrid()
    {
        var selected = stagingSetoutGrid.SelectedRows.FirstOrDefault();
        if (selected != null)
        {
            var packets = ManufacturingPacketList.Packets;
            selected.Set<StagingSetout, int>(x => x.Packets, packets.Length);
            selected.Set<StagingSetout, int>(x => x.UnprocessedPackets, packets.Count(x => x.ManufacturingPacket.ID == Guid.Empty));
            stagingSetoutGrid.InvalidateRow(selected);
        }
    }

    private void CollapsePacketsButton_Click(object sender, RoutedEventArgs e)
    {
        if (ManufacturingPacketList.Collapsed())
        {
            ManufacturingPacketList.Uncollapse();
        }
        else
        {
            ManufacturingPacketList.Collapse();
        }
    }

    private void ManufacturingPacketList_OnCollapsed(bool collapsed)
    {
        if (collapsed)
        {
            CollapsePacketsButton.Content = "Expand";
        }
        else
        {
            CollapsePacketsButton.Content = "Collapse";
        }
    }

    private void stagingSetoutGrid_OnCustomiseSetouts(IReadOnlyList<StagingSetoutGrid.SetoutDocument> setouts)
    {
        if(CustomiseSetoutsMethod != null && ScriptObject != null)
        {
            CustomiseSetoutsMethod?.Invoke(ScriptObject, new object?[]
            {
                new CustomiseSetoutsArgs(setouts.Select(x => new Tuple<StagingSetout, Document>(x.Setout, x.Document)).ToImmutableList())
            });
        }
    }

    private void StagingSetoutGrid_OnOnDoubleClick(object sender, HandledEventArgs args)
    {
        ManufacturingPacketList.Setout = selectedSetout;
        SetoutComponentGrid.StagingSetout = selectedSetout;
        MainPanel.View = DynamicSplitPanelView.Detail;
        NestedPanel.View = DynamicSplitPanelView.Combined;
        args.Handled = true;
    }

    private void CalculateTime()
    {
        if (selectedSetout != null)
        {
            var time = ManufacturingPacketList.TimeRequired();
            TimeRequired.Content = $"{time.TotalHours:F2} hours";
        }
        else
            TimeRequired.Content = "N/A";
    }

    private void ManufacturingPacketList_OnChanged(object? sender, EventArgs e)
    {
       CalculateTime();
       UpdateStagingSetoutGrid();
    }


    private void DoImport(Importer importer, string? componentFileName, Guid setoutID)
    {
        var success = DynamicImportGrid.CreateImporter(importer, ref componentFileName, out var iimporter);
        if (!success)
        {
            return;
        }

        var errors = new List<string>();

        var stagingSetoutComponents = new List<StagingSetoutComponent>();
        iimporter.OnLoad += Iimporter_OnLoad;
        iimporter.OnSave += (_, entity) => stagingSetoutComponents.Add((entity as StagingSetoutComponent)!);
        iimporter.OnError += (_, error) => errors.Add(error);

        using var stream = new FileStream(componentFileName!, FileMode.Open, FileAccess.Read);
        if (iimporter.Open(stream))
        {
            if (iimporter.ReadHeader())
            {
                var mismatches = iimporter.Mappings.Where(x =>
                    !string.IsNullOrWhiteSpace(x.Field) &&
                    !iimporter.Fields.Contains(x.Field)
                ).Select(x => x.Field).ToArray();
                if (!mismatches.Any())
                {
                    var imported = iimporter.Import();
                    if (errors.Any())
                    {
                        MessageBox.Show($"Import for component file {componentFileName} failed:\nSome errors occurred: {string.Join('\n', errors)}", "Import failed");
                    }
                    else
                    {
                        var valid = true;
                        var conflicts = false;
                        if (setoutID != Guid.Empty)
                        {
                            var newComponents = new List<StagingSetoutComponent>();
                            foreach (var component in stagingSetoutComponents)
                            {
                                if (component.StagingSetout.ID == Guid.Empty)
                                {
                                    component.StagingSetout.ID = setoutID;
                                    newComponents.Add(component);
                                }
                                else if (component.StagingSetout.ID != setoutID)
                                {
                                    conflicts = true;
                                    // Ignoring this item.
                                }
                                else
                                {
                                    newComponents.Add(component);
                                }
                            }
                            stagingSetoutComponents = newComponents;

                            if (conflicts)
                            {
                                MessageBox.Show($"Warning: the lines in this file have conflicting setout numbers.", "Warning");
                            }
                        }
                        if (valid)
                        {
                            foreach (var component in stagingSetoutComponents)
                            {
                                if (component.StagingSetout.ID == Guid.Empty)
                                {
                                    MessageBox.Show($"Component with no related setout cannot be imported.");
                                    valid = false;
                                    break;
                                }
                                else if (component.Description.IsNullOrWhiteSpace())
                                {
                                    MessageBox.Show($"Component with no description cannot be imported.");
                                    valid = false;
                                    break;
                                }
                                else if (component.Dimensions.Unit.ID == Guid.Empty)
                                {
                                    MessageBox.Show($"Component with no dimensions unit cannot be imported.");
                                    valid = false;
                                    break;
                                }
                            }
                        }
                        if (valid)
                        {
                            new Client<StagingSetoutComponent>().Save(stagingSetoutComponents, $"Imported from {componentFileName}");

                            SetoutComponentGrid.Refresh(false, true);
                        }
                        else
                        {
                            MessageBox.Show($"Import for component file {componentFileName} failed.", "Import failed");
                        }
                    }
                }
                else
                {
                    MessageBox.Show("Import Mappings do not match file headers!\n\n- " + string.Join("\n- ", mismatches),
                        "Import Failed");
                }
            }
            else
            {
                MessageBox.Show("Unable to Read Headers from {0}", Path.GetFileName(componentFileName));
            }
        }
        else
        {
            MessageBox.Show("Unable to Open {0}", Path.GetFileName(componentFileName));
        }

        iimporter.Close();
    }

    private CoreTable Iimporter_OnLoad(object sender, Type type, string[] fields, string ID)
    {
        var result = new CoreTable();
        result.LoadColumns(Columns.None<StagingSetoutComponent>().Add(fields));
        return result;
    }

    private void stagingSetoutGrid_OnParseComponentFile(string componentFileName, Guid setoutID)
    {
        try
        {
            var entityName = typeof(StagingSetoutComponent).EntityName();
            var importers = new Client<Importer>()
                .Query(
                    new Filter<Importer>(x => x.EntityName).IsEqualTo(entityName),
                    Columns.None<Importer>().Add(x => x.ID));
            if (importers.Rows.Count == 0)
            {
                var importer = new Importer
                {
                    EntityName = entityName,
                    FileName = componentFileName
                };

                var form = new DynamicImportForm(importer);
                if (form.ShowDialog() == true)
                {
                    new Client<Importer>().Save(importer, "");

                    DoImport(importer, componentFileName, setoutID);

                    return;
                }
            }
            else if (importers.Rows.Count == 1)
            {
                var importer = new Client<Importer>().Load(new Filter<Importer>(x => x.ID).IsEqualTo(importers.Rows[0].Get<Importer, Guid>(x => x.ID))).First();
                DoImport(importer, componentFileName, setoutID);
            }
            else
            {
                var list = new PopupList(
                    typeof(Importer),
                    Guid.Empty,
                    Array.Empty<string>());
                list.OnDefineFilter += t => new Filter<Importer>(x => x.EntityName).IsEqualTo(entityName);
                if (list.ShowDialog() == true)
                {
                    var importer = new Client<Importer>().Load(new Filter<Importer>(x => x.ID).IsEqualTo(list.ID)).First();
                    DoImport(importer, componentFileName, setoutID);
                }
            }
        }
        catch(Exception e)
        {
            Logger.Send(LogType.Error, "", $"Error in file {componentFileName}: {CoreUtils.FormatException(e)}");
            MessageBox.Show($"Error opening {componentFileName}: {e.Message}");
        }
    }
}