inabox/inabox.wpf/DigitalForms/DynamicVariableGrid.cs

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using InABox.Clients;
using InABox.Core;
using InABox.Wpf;
using InABox.WPF;

namespace InABox.DynamicGrid;

public class DynamicVariableGrid : DynamicDataGrid<DigitalFormVariable>
{
    private bool ShowHidden = false;
    private Button ShowHiddenButton;
    private Button HideButton;

    public DigitalForm? Form { get; set; }

    private DigitalFormVariable[]? _variables;
    public DigitalFormVariable[] Variables
    {
        get
        {
            _variables ??= Data.ToArray<DigitalFormVariable>();
            return _variables;
        }
    }

    public DynamicFormLayoutGrid? LayoutGrid { get; set; }

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

        ShowHiddenButton = AddButton("Show Hidden", null, ToggleHidden_Click);
        HideButton = AddEditButton("Hide Variable", null, Hide_Click);
        HideButton.IsEnabled = false;

        HiddenColumns.Add(x => x.Hidden);
        HiddenColumns.Add(x => x.Code);
        HiddenColumns.Add(x => x.VariableType);
        HiddenColumns.Add(x => x.Parameters);
        HiddenColumns.Add(x => x.Required);
        HiddenColumns.Add(x => x.Secure);
        HiddenColumns.Add(x => x.Retain);

        ActionColumns.Add(new DynamicMenuColumn(BuildMenu) { Position = DynamicActionColumnPosition.End });
    }

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

        options.MultiSelect = true;
    }

    private void BuildMenu(DynamicMenuColumn column, CoreRow? row)
    {
        if (row is null) return;

        if (Security.CanEdit<DigitalFormVariable>())
        {
            var variable = row.ToObject<DigitalFormVariable>();

            var changeType = column.AddItem("Change Type", null, null);
            foreach(var (toType, converter) in DFUtils.GetFieldConverters(variable.FieldType()))
            {
                var caption = toType.GetCaption();
                if (string.IsNullOrWhiteSpace(caption))
                {
                    caption = CoreUtils.Neatify(toType.Name);
                }
                changeType.AddItem(caption, null, (variable, converter, toType), ChangeType_Click);
            }
            if(changeType.Items.Count == 0)
            {
                changeType.IsEnabled = false;
            }
        }
    }

    private void ChangeType_Click((DigitalFormVariable variable, Type converterType, Type fieldType) tuple)
    {
        if (Form is null) return;

        var (variable, converterType, fieldType) = tuple;

        var oldFieldType = variable.FieldType();

        var converter = (Activator.CreateInstance(converterType) as IDFLayoutFieldConverter)!;

        var oldProperties = variable.CreateProperties();

        variable.SetFieldType(fieldType);

        var newPropertiesType = DigitalFormVariable.GetPropertiesType(fieldType);
        if (newPropertiesType is null) return;

        var newProperties = (Activator.CreateInstance(newPropertiesType) as DFLayoutFieldProperties)!;

        foreach(var property in DatabaseSchema.LocalProperties(oldProperties.GetType()))
        {
            if(DatabaseSchema.Property(newProperties.GetType(), property.Name) is IProperty prop)
            {
                prop.Setter()(newProperties, property.Getter()(oldProperties));
            }
        }
        converter.ConvertProperties(oldProperties, newProperties);
        newProperties.SetDefaultValue(converter.Convert(oldProperties, oldProperties.GetDefaultValue(), newProperties));

        if (DynamicVariableUtils.EditProperties(Form, Variables, newProperties.GetType(), newProperties, false))
        {
            if(!MessageWindow.ShowYesNo(
                $"This will convert field '{variable.Code}' from {oldFieldType.GetCaption()} to {fieldType.GetCaption()}. Note that this will " +
                $"update all instances of this form '{Form.Code}' that have been filled in, converting the field data. Do you wish to proceed?",
                "Proceed?"))
            {
                return;
            }

            variable.SaveProperties(fieldType, newProperties);

            if (DFUtils.GetFormInstanceType(Form.AppliesTo) is not Type instanceType)
            {
                throw new Exception($"Could not find form instance that applies to {Form.AppliesTo}");
            }

            var forms = Client.Create(instanceType)
                .Query(
                    Filter.Create(instanceType).All(),
                    Columns.Create(instanceType, ColumnTypeFlags.Required)
                        .Add<IDigitalFormInstance>(x => x.FormData)
                        .Add<IDigitalFormInstance>(x => x.BlobData))
                .ToObjects(instanceType)
                .Cast<Entity>()
                .ToArray();
            foreach(var form in forms)
            {
                var formInstance = (form as IDigitalFormInstance)!;
                var newData = DigitalForm.DeserializeFormSaveData(formInstance) ?? new();
                var oldData = newData.ToLoadStorage();

                var entry = oldData.GetEntry(variable.Code);
                var oldValue = oldProperties.Deserialize(oldData.GetEntry(variable.Code));

                var newValue = converter.Convert(oldProperties, oldValue, newProperties);
                newProperties.Serialize(newData.GetEntry(variable.Code), newValue);

                DigitalForm.SerializeFormData(formInstance, newData);
            }

            Client.Create(instanceType).Save(forms, $"Changed {variable.Code} from {oldFieldType.GetCaption()} to {fieldType.GetCaption()}");

            if(LayoutGrid is not null)
            {
                foreach(var layout in LayoutGrid.Layouts)
                {
                    var dfLayout = DFLayout.FromLayoutString(layout.Layout);

                    void UpdateList(List<DFLayoutControl> elements)
                    {
                        var updates = new List<(int, DFLayoutField)>();
                        foreach(var (i, element) in elements.WithIndex())
                        {
                            if (element is not DFLayoutField field
                                || field.Name != variable.Code) continue;
                            updates.Add((i, field));
                        }
                        foreach(var (i, field) in updates)
                        {
                            var newField = (Activator.CreateInstance(fieldType) as DFLayoutField)!;
                            newField.LoadFromString(field.SaveToString());
                            elements[i] = newField;
                        }
                    }

                    UpdateList(dfLayout.Elements);
                    UpdateList(dfLayout.HiddenElements);

                    layout.Layout = dfLayout.SaveLayout();
                }
                LayoutGrid.SaveItems(LayoutGrid.Layouts);
                LayoutGrid.Refresh(false, true);
            }

            SaveItem(variable);
            Refresh(false, true);
        }
    }

    public DigitalFormVariable? GetVariable(string code)
    {
        return Data.Rows
            .Where(x => x.Get<DigitalFormVariable, string>(x => x.Code) == code)
            .FirstOrDefault()
            ?.ToObject<DigitalFormVariable>();
    }

    private static bool ShouldHide(CoreRow[] rows)
    {
        return rows.Any(x => !x.Get<DigitalFormVariable, bool>(x => x.Hidden));
    }

    private bool Hide_Click(Button btn, CoreRow[] rows)
    {
        if(rows.Length == 0)
        {
            MessageBox.Show("No rows selected");
            return false;
        }

        var hide = ShouldHide(rows);
        var items = rows.ToArray<DigitalFormVariable>();
        foreach (var item in items)
        {
            item.Hidden = hide;
        }
        if(items.Length > 0)
        {
            SaveItems(items);
            return true;
        }
        return false;
    }

    protected override void SelectItems(CoreRow[]? rows)
    {
        base.SelectItems(rows);

        if(rows is null)
        {
            HideButton.IsEnabled = false;
        }
        else
        {
            HideButton.IsEnabled = true;
            HideButton.Content = (ShouldHide(rows) ? "Hide Variable" : "Un-hide Variable") + (rows.Length > 1 ? "s" : "");
        }
    }

    private bool ToggleHidden_Click(Button btn, CoreRow[] rows)
    {
        ShowHidden = !ShowHidden;
        ShowHiddenButton.Content = ShowHidden ? "Hide Hidden" : "Show Hidden";
        return true;
    }

    private void CreateMenu(ContextMenu parent, string header, Type type)
    {
        if (Form is null) return;

        parent.AddItem(header, null, type, (itemtype) =>
        {
            if(DynamicVariableUtils.CreateAndEdit(Form, Data.ToArray<DigitalFormVariable>(), itemtype, out var variable))
            {
                SaveItem(variable);
                Refresh(false, true);
            }
        });
    }

    protected override void DoAdd(bool openEditorOnDirectEdit = false)
    {
        var menu = new ContextMenu();

        foreach(var fieldType in DFUtils.GetFieldTypes())
        {
            var caption = fieldType.GetCaption();
            if (string.IsNullOrWhiteSpace(caption))
            {
                caption = CoreUtils.Neatify(fieldType.Name);
            }
            CreateMenu(menu, caption, fieldType);
        }

        menu.IsOpen = true;
    }

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

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

    protected override void DoEdit()
    {
        if (!SelectedRows.Any() || Form is null)
            return;
        var variable = SelectedRows.First().ToObject<DigitalFormVariable>();
        var properties = variable.CreateProperties();
        if (DynamicVariableUtils.EditProperties(Form, Variables, properties.GetType(), properties, !Security.CanEdit<DigitalFormVariable>()))
        {
            variable.SaveProperties(properties);
            SaveItem(variable);
            Refresh(false, true);
        }
    }

    protected override void DoDelete()
    {
        var rows = SelectedRows.ToArray();

        if (rows.Length != 0)
            if (CanDeleteItems(rows))
                if (MessageWindow.ShowYesNo(
                    "Are you sure you want to delete this variable? This will all cause data associated with this variable to be lost.\n(If you want to just hide the variable, set it to 'Hidden' instead.)",
                    "Confirm Deletion"))
                {
                    DeleteItems(rows);
                    SelectedRows = Array.Empty<CoreRow>();
                    DoChanged();
                    Refresh(false, true);
                    SelectItems(null);
                }
    }

    protected override bool FilterRecord(CoreRow row)
    {
        return ShowHidden || !row.Get<DigitalFormVariable, bool>(x => x.Hidden);
    }

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

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

public class DFLookupFilterNode : ComboBox, ICustomValueNode
{
    public DFLookupFilterNode(Type entityType, CustomFilterValue? selectedValue)
    {
        var properties = CoreUtils.PropertyList(entityType, x => x.GetCustomAttribute<DoNotSerialize>() == null, true).Keys.ToList();
        properties.Sort();
        Items.Add("");
        foreach (var property in properties)
        {
            Items.Add(property);
        }

        Value = selectedValue;

        SelectionChanged += DFLookupFilterNode_SelectionChanged;

        VerticalAlignment = System.Windows.VerticalAlignment.Stretch;
        VerticalContentAlignment = System.Windows.VerticalAlignment.Center;
        MinWidth = 50;
    }

    private void DFLookupFilterNode_SelectionChanged(object sender, SelectionChangedEventArgs e)
    {
        var text = SelectedItem as string;
        if (text.IsNullOrWhiteSpace())
        {
            _value = null;
        }
        else
        {
            _value = new CustomFilterValue(System.Text.Encoding.UTF8.GetBytes(text));
        }
        ValueChanged?.Invoke(this, Value);
    }

    private CustomFilterValue? _value;
    public CustomFilterValue? Value
    {
        get => _value;
        set
        {
            if(value is not null)
            {
                var text = System.Text.Encoding.UTF8.GetString(value.Data);
                SelectedItem = text;
                _value = value;
            }
            else
            {
                SelectedItem = null;
                _value = null;
            }
        }
    }

    public FrameworkElement FrameworkElement => this;

    public event ICustomValueNode.ValueChangedHandler? ValueChanged;
}

public static class DynamicVariableUtils
{
    public static bool CreateAndEdit(
        DigitalForm form, IList<DigitalFormVariable> variables,
        Type fieldType,
        [NotNullWhen(true)] out DigitalFormVariable? variable)
    {
        var fieldBaseType = fieldType.GetSuperclassDefinition(typeof(DFLayoutField<>));
        if (fieldBaseType != null)
        {
            var propertiesType = fieldBaseType.GetGenericArguments()[0];
            var properties = (Activator.CreateInstance(propertiesType) as DFLayoutFieldProperties)!;
            if (DynamicVariableUtils.EditProperties(form, variables, propertiesType, properties, readOnly: false))
            {
                variable = new DigitalFormVariable();
                variable.Form.CopyFrom(form);
                variable.SaveProperties(fieldType, properties);
                return true;
            }
        }
        variable = null;
        return false;
    }

    public static bool EditProperties(DigitalForm form, IList<DigitalFormVariable> variables, Type type, DFLayoutFieldProperties item, bool readOnly)
    {
        var editor = new DynamicEditorForm(type);
        editor.ReadOnly = readOnly;
        if (item is DFLayoutLookupFieldProperties)
        {
            var appliesToType = DFUtils.FormEntityType(form);
            editor.OnReconfigureEditors = grid =>
            {
                var filter = grid.FindEditor("Filter");
                if(filter is FilterEditorControl filterEditor)
                {
                    var config = new FilterEditorConfiguration();

                    config.OnCreateCustomValueNode += (type, prop, op, value) =>
                    {
                        if (appliesToType is not null)
                        {
                            return new DFLookupFilterNode(appliesToType, value);
                        }
                        else
                        {
                            return null;
                        }
                    };

                    filterEditor.Configuration = config;
                }
            };
            editor.OnFormCustomiseEditor += (sender, items, column, editor) => LookupEditor_OnFormCustomiseEditor(sender, variables, items, column, editor);
            editor.OnEditorValueChanged += (sender, name, value) =>
            {
                var result = DynamicGridUtils.UpdateEditorValue(new[] { item }, name, value);
                if (name == "LookupType")
                {
                    var grid = (sender as EmbeddedDynamicEditorForm)?.Editor!;
                    var edit = grid.FindEditor("Filter");
                    if (edit is FilterEditorControl filter)
                    {
                        filter.FilterType = value is string str ?
                            CoreUtils.GetEntityOrNull(str) :
                            null;
                    }

                    var propertiesEditor = grid.FindEditor(nameof(DFLayoutLookupFieldProperties.AdditionalProperties));
                    if (propertiesEditor is MultiLookupEditorControl multi && multi.EditorDefinition is MultiLookupEditor combo)
                    {
                        combo.Clear();
                        multi.Configure();
                    }
                }
                OnEditorValueChanged(sender, name, value);
                return new();
            };
        }
        else
        {
            editor.OnFormCustomiseEditor += (sender, items, column, editor) => Editor_OnFormCustomiseEditor(sender, variables, column, editor);
            editor.OnEditorValueChanged += (sender, name, value) =>
            {
                var result = DynamicGridUtils.UpdateEditorValue(new[] { item }, name, value);
                OnEditorValueChanged(sender, name, value);
                return result;
            };
        }
        editor.OnCreateEditorControl += Editor_OnCreateEditorControl;

        editor.OnDefineLookups += o =>
        {
            var def = (o.EditorDefinition as ILookupEditor)!;
            var colname = o.ColumnName;
            // Nope, there is nothing dodgy about this at all
            // I am not breaking any rules by passing in the QA Form instance, rather than the Field instance 
            // so that I can get access to the "AppliesTo" property, and thus the list of properties that can be updated
            // Nothing to see here, I promise!
            CoreTable? values;
            if (o.ColumnName == "Property")
            {
                values = def.Values(colname, new[] { form });
            }
            else
            {
                values = def.Values(colname, new[] { item });
            }

            o.LoadLookups(values);
        };

        var thisVariable = variables.Where(x => x.Code == item.Code).ToList();

        editor.OnValidateData += (sender, items) =>
        {
            var errors = new List<string>();
            foreach(var item in items.Cast<DFLayoutFieldProperties>())
            {
                // Check Codes
                if (string.IsNullOrWhiteSpace(item.Code))
                {
                    errors.Add("[Code] may not be blank!");
                }
                else
                {
                    var codeVars = variables.Where(x => x.Code == item.Code).ToList();
                    if(codeVars.Count > 1)
                    {
                        errors.Add($"Duplicate code [{item.Code}]");
                    }
                    else if(codeVars.Count == 1)
                    {
                        if (!thisVariable.Contains(codeVars.First()))
                        {
                            errors.Add($"There is already a variable with code [{item.Code}]");
                        }
                    }
                }

                // Check Read-Only property
                if(item.ReadOnlyProperty && item.Property.IsNullOrWhiteSpace() && item.Expression.IsNullOrWhiteSpace())
                {
                    errors.Add("A field cannot be read-only if [Property] or [Expression] have not been set.");
                }
            }
            return errors;
        };
        editor.Items = new BaseObject[] { item };
        return editor.ShowDialog() == true;
    }

    private static void Editor_OnCreateEditorControl(string column, BaseEditor editor, IDynamicEditorControl control)
    {
        var properties = (control.Host.GetItems()[0] as DFLayoutFieldProperties)!;
        if(column == nameof(DFLayoutFieldProperties.ReadOnlyProperty))
        {
            if (properties.Property.IsNullOrWhiteSpace())
            {
                control.IsEnabled = false;
            }
        }
    }

    private static void Editor_OnFormCustomiseEditor(IDynamicEditorForm sender, IList<DigitalFormVariable> vars, DynamicGridColumn column, BaseEditor editor)
    {
        var properties = (sender.Items[0] as DFLayoutFieldProperties)!;
        if ((column.ColumnName == "Expression" || column.ColumnName == "ColourExpression") && editor is ExpressionEditor exp)
        {
            var variables = new List<string>();
            foreach (var variable in vars)
            {
                //variables.Add(variable.Code);
                foreach (var col in variable.GetVariableColumns())
                {
                    variables.Add(col.ColumnName);
                }
            }
            if(column.ColumnName == "Expression")
            {
                variables.Remove(properties.Code);
            }
            variables.Sort();
            exp.VariableNames = variables;
        }
    }

    private static void LookupEditor_OnFormCustomiseEditor(IDynamicEditorForm sender, IList<DigitalFormVariable> vars, object[] items, DynamicGridColumn column, BaseEditor editor)
    {
        if (column.ColumnName == "Filter" && editor is FilterEditor fe)
        {
            var properties = (items[0] as DFLayoutLookupFieldProperties)!;
            var lookupType = properties.LookupType;
            var entityType = CoreUtils.GetEntityOrNull(lookupType);
            fe.Type = entityType;
        }
        Editor_OnFormCustomiseEditor(sender, vars, column, editor);
    }

    private static void OnEditorValueChanged(IDynamicEditorForm sender, string name, object value)
    {
        if(name == nameof(DFLayoutFieldProperties.Property))
        {
            var properties = (sender.Items[0] as DFLayoutFieldProperties)!;
            var grid = (sender as EmbeddedDynamicEditorForm)?.Editor!;
            var edit = grid.FindEditor(nameof(DFLayoutFieldProperties.ReadOnlyProperty));
            if (edit is not null)
            {
                edit.IsEnabled = !properties.Property.IsNullOrWhiteSpace() && !grid.ReadOnly && edit.EditorDefinition.Editable.IsEditable();
            }
        }
    }

}