inabox/inabox.wpf/DigitalForms/DynamicFormLayoutGrid.cs

using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media.Imaging;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.Scripting;
using InABox.Wpf;
using InABox.WPF;
using Microsoft.Win32;
using Org.BouncyCastle.Asn1.Mozilla;
using Syncfusion.Windows.Shared;
using UnderlineType = InABox.Core.UnderlineType;

namespace InABox.DynamicGrid;

public class DynamicFormLayoutGrid : DynamicDataGrid<DigitalFormLayout>
{
    private readonly BitmapImage design = Wpf.Resources.design.AsBitmapImage();
    private readonly BitmapImage tick = Wpf.Resources.tick.AsBitmapImage();

    public DigitalForm? Form { get; set; }

    public DynamicVariableGrid? VariableGrid { get; set; }

    private DigitalFormLayout[]? _layouts;
    public DigitalFormLayout[] Layouts
    {
        get
        {
            _layouts ??= Data.ToArray<DigitalFormLayout>();
            return _layouts;
        }
    }

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

        //AddButton("Design", PRSDesktop.Resources.design.AsBitmapImage(), DesignClick);
        HiddenColumns.Add(x => x.Active);
        HiddenColumns.Add(x => x.Description);
        HiddenColumns.Add(x => x.Type);
        HiddenColumns.Add(x => x.Layout);
        HiddenColumns.Add(x => x.Form.Code);
        HiddenColumns.Add(x => x.Form.Description);

        if (Security.CanEdit<DigitalFormLayout>())
        {
            ActionColumns.Add(new DynamicTickColumn<DigitalFormLayout, bool>(x => x.Active, tick, tick, null,
                action: ActiveClick)
            {
                ToolTip = ActiveToolTip
            });
        }
        ActionColumns.Add(new DynamicImageColumn(DesignImage, DesignClick));

        AddEditButton("Auto Generate", null, AutoGenerate_Click);
        AddEditButton("Duplicate", null, Duplicate_Click);
    }

    private FrameworkElement? ActiveToolTip(DynamicActionColumn column, CoreRow? row)
    {
        if(row is null)
        {
            return column.TextToolTip("Active");
        }
        var active = row.Get<DigitalFormLayout, bool>(x => x.Active);
        var type = row.Get<DigitalFormLayout, DFLayoutType>(x => x.Type);
        if (active)
        {
            return column.TextToolTip($"This is the active layout for {type}.");
        }
        else
        {
            return column.TextToolTip($"This layout is inactive.");
        }
    }

    private bool ActiveClick(CoreRow? row)
    {
        if (row is null) return false;

        var item = row.ToObject<DigitalFormLayout>();
        var allItems = Data.ToArray<DigitalFormLayout>();
        var toSave = new List<DigitalFormLayout>();
        
        item.Active = !item.Active;
        toSave.Add(item);

        if (item.Active)
        {
            foreach(var otherItem in allItems)
            {
                if (otherItem.ID == item.ID) continue;

                if(otherItem.Type == item.Type)
                {
                    otherItem.Active = false;
                    toSave.Add(otherItem);
                }
            }
        }

        Client.Save(toSave, "Changed Active flag");

        return true;
    }

    protected override void DoReconfigure(DynamicGridOptions options)
    {
        base.DoReconfigure(options);

        options.RecordCount = true;
        options.ImportData = true;
    }

    private DFLayout LoadLayoutFromSpreadsheet(ISpreadsheet spreadsheet)
    {
        return DigitalFormUtils.LoadLayout(spreadsheet);
    }

    protected override void DoImport()
    {
        var dialog = new OpenFileDialog();
        dialog.Filter = "Excel Spreadsheet (.xlsx)|*.xlsx";
        if (dialog.ShowDialog() == true)
        {
            try
            {
                DFLayout layout;
                Dictionary<String, String> variablegroups = new Dictionary<string, string>();
                using (var fs = new FileStream(dialog.FileName, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    layout = LoadLayoutFromSpreadsheet(new Spreadsheet(fs));
                }

                var dfLayout = CreateItem();
                dfLayout.Description = $"Imported From {Path.GetFileName(dialog.FileName)}";
                dfLayout.Layout = layout.SaveLayout();
                if(EditItems(new DigitalFormLayout[] { dfLayout }))
                {
                    var newVariables = new List<DigitalFormVariable>();
                    String group = "";
                    foreach (var element in layout.Elements)
                    {
                        if (element is DFLayoutHeader header)
                        {
                            group = header.Header;
                        }
                        else if (element is DFLayoutField field)
                        {
                            var variable = new DigitalFormVariable();
                            variable.SetFieldType(field.GetType());
                            variable.SaveProperties(field.GetProperties());
                            variable.Group = group;
                            variable.Code = field.Name;
                            variable.Description = field.Name;
                            newVariables.Add(variable);
                        }
                    }
                    if(newVariables.Count > 0)
                    {
                        if (VariableGrid is not null)
                        {
                            var save = new List<DigitalFormVariable>();
                            foreach(var newVariable in newVariables)
                            {
                                var variable = VariableGrid.GetVariable(newVariable.Code);
                                if(variable is not null)
                                {
                                    if(variable.FieldType() != newVariable.FieldType())
                                    {
                                        MessageBox.Show($"Variable [{newVariable.Code}] already exists with a different type!");
                                    }
                                }
                                else
                                {
                                    save.Add(newVariable);
                                }
                            }

                            VariableGrid.SaveItems(save.ToArray());
                            VariableGrid.Refresh(false, true);
                        }
                    }

                    Refresh(false, true);
                }
            }
            catch(Exception e)
            {
                MessageWindow.ShowError("Something went wrong", e);
            }
        }
    }

    private bool Duplicate_Click(Button btn, CoreRow[] rows)
    {
        if (rows.Length == 0) return false;

        SaveItems(rows.ToArray(x =>
        {
            var layout = x.ToObject<DigitalFormLayout>();

            var newLayout = CreateItem();
            newLayout.Description = layout.Description;
            newLayout.Type = layout.Type;
            newLayout.Layout = layout.Layout;

            return newLayout;
        }));
        return true;
    }

    private bool AutoGenerate_Click(Button btn, CoreRow[] rows)
    {
        var menu = new ContextMenu();

        menu.AddItem("Desktop Layout", null, AddDesktop_Click);
        menu.AddItem("Mobile Layout", null, AddMobile_Click);

        menu.IsOpen = true;

        return false;
    }

    private BitmapImage? DesignImage(CoreRow? row)
    {
        return row != null ? design : null;
    }

    private void AddMobile_Click()
    {
        var item = CreateItem();

        item.Layout = DFLayout.GenerateAutoMobileLayout(GetVariables()).SaveLayout();
        item.Type = DFLayoutType.Mobile;

        if (EditItems(new[] { item }))
        {
            SaveItem(item);
            Refresh(false, true);
            DoChanged();
        }
    }

    private void AddDesktop_Click()
    {
        var item = CreateItem();

        item.Layout = DFLayout.GenerateAutoDesktopLayout(GetVariables()).SaveLayout();
        item.Type = DFLayoutType.Desktop;

        if (EditItems(new[] { item }))
        {
            SaveItem(item);
            Refresh(false, true);
            DoChanged();
        }
    }

    private IList<DigitalFormVariable> GetVariables()
        => VariableGrid?.Variables ?? [];

    private void Design(DigitalFormLayout layout)
    {
        if (Form is null) return;

        var variables = GetVariables().ToList();

        var newVariables = new List<DigitalFormVariable>();

        var form = new DynamicFormDesignWindow
        {
            Type = layout.Type,
            ReadOnly = !Security.CanEdit<DigitalFormLayout>()
        };
        form.OnCreateVariable += (fieldType) =>
        {
            if (DynamicVariableUtils.CreateAndEdit(Form, variables, fieldType, out var variable))
            {
                newVariables.Add(variable);
                variables.Add(variable);
                return variable;
            }
            return null;
        };
        /*form.OnEditVariable += (variable) =>
        {
            var properties = variable.CreateProperties();
            if (DynamicVariableUtils.EditProperties(Item, GetVariables(), properties.GetType(), properties))
            {
                variable.SaveProperties(properties);
                return true;
            }
            return false;
        };*/
        form.LoadLayout(layout, variables);
        form.Initialize();

        if (form.ShowDialog() == true)
        {
            layout.Layout = form.SaveLayout();
            SaveItem(layout);

            if (VariableGrid is not null)
            {
                VariableGrid.SaveItems(newVariables);
                VariableGrid.Refresh(false, true);
            }
            Refresh(false, true);
        }
    }

    private bool DesignClick(CoreRow? row)
    {
        if (row == null)
            return false;

        Design(row.ToObject<DigitalFormLayout>());

        return false;
    }

    protected override bool CanCreateItems()
    {
        return base.CanCreateItems() && Form is not null;
    }

    public override DigitalFormLayout CreateItem()
    {
        var item = base.CreateItem();
        item.Form.ID = Form?.ID ?? Guid.Empty;
        return item;
    }

    protected override void DoDoubleClick(object sender, DynamicGridCellClickEventArgs args)
    {
        DesignClick(SelectedRows.FirstOrDefault());
    }

    protected override void OnAfterRefresh()
    {
        base.OnAfterRefresh();
        _layouts = null;
    }

    protected override void Reload(Filters<DigitalFormLayout> criteria, Columns<DigitalFormLayout> columns, ref SortOrder<DigitalFormLayout>? sort, CancellationToken token, Action<CoreTable?, Exception?> action)
    {
        if(Form is null)
        {
            criteria.Add(Filter.None<DigitalFormLayout>());
        }
        else
        {
            criteria.Add(Filter<DigitalFormLayout>.Where(x => x.Form.ID).IsEqualTo(Form.ID));
        }
        base.Reload(criteria, columns, ref sort, token, action);
    }
}