VariableEditorVM.cs

using System.Collections.Generic;
using System.Linq;
using TaleWorlds.GauntletUI;
using TaleWorlds.GauntletUI.PrefabSystem;
using TaleWorlds.Library;

namespace InGameUIDesigner
{
    public class VariableEditorVM : ViewModel
    {
        [DataSourceProperty]
        public MBBindingList<VariableEditorItemVM> VariablesList
        {
            get => _variablesList;
            set
            {
                if (_variablesList != value)
                {
                    _variablesList = value;
                    OnPropertyChangedWithValue(value, "VariablesList");
                }
            }
        }

        [DataSourceProperty]
        public string VariableSearchText
        {
            get => _variableSearchText;
            set
            {
                if (_variableSearchText != value)
                {
                    _variableSearchText = value;
                    OnPropertyChangedWithValue(value, "VariableSearchText");
                    FilterVariablesList();
                }
            }
        }

        [DataSourceProperty]
        public bool ShowVariableEditor
        {
            get => _showVariableEditor;
            set
            {
                if (_showVariableEditor != value)
                {
                    _showVariableEditor = value;
                    OnPropertyChangedWithValue(value, "ShowVariableEditor");
                }
            }
        }

        private MBBindingList<VariableEditorItemVM> _variablesList;
        private MBBindingList<VariableEditorItemVM> _unfilteredVariablesList;
        private string _variableSearchText;
        private bool _showVariableEditor;

        public List<ConstantDefinition> Constants { get; private set; }
        public List<VisualDefinition> VisualDefinitions { get; private set; }
        public List<PrefabParameter> Parameters { get; private set; }

        public VariableEditorVM()
        {
            _variablesList = new MBBindingList<VariableEditorItemVM>();
            _unfilteredVariablesList = new MBBindingList<VariableEditorItemVM>();
            _variableSearchText = "";
            _showVariableEditor = false;

            Constants = new List<ConstantDefinition>();
            VisualDefinitions = new List<VisualDefinition>();
            Parameters = new List<PrefabParameter>();
        }

        public void ShowVariableEditorMethod()
        {
            ShowVariableEditor = true;
        }

        public void CloseVariableEditor()
        {
            ShowVariableEditor = false;
        }

        public void AddConstant()
        {
            var newItem = new VariableEditorItemVM(this, VariableType.Constant);
            _unfilteredVariablesList.Add(newItem);
            Constants.Add((ConstantDefinition)newItem.DataObject);
            FilterVariablesList();
        }

        public void AddParameter()
        {
            var newItem = new VariableEditorItemVM(this, VariableType.Parameter);
            _unfilteredVariablesList.Add(newItem);
            Parameters.Add((PrefabParameter)newItem.DataObject);
            FilterVariablesList();
        }

        public void AddVisualDefinition()
        {
            var newItem = new VariableEditorItemVM(this, VariableType.VisualDefinition);
            _unfilteredVariablesList.Add(newItem);
            VisualDefinitions.Add((VisualDefinition)newItem.DataObject);
            FilterVariablesList();
        }

        public void RemoveVariable(VariableEditorItemVM item)
        {
            _unfilteredVariablesList.Remove(item);

            if (item.Type == VariableType.Constant)
            {
                Constants.Remove((ConstantDefinition)item.DataObject);
            }
            else if (item.Type == VariableType.VisualDefinition)
            {
                VisualDefinitions.Remove((VisualDefinition)item.DataObject);
            }
            else if (item.Type == VariableType.Parameter)
            {
                Parameters.Remove((PrefabParameter)item.DataObject);
            }

            FilterVariablesList();
        }

        private void FilterVariablesList()
        {
            if (string.IsNullOrEmpty(VariableSearchText) || VariableSearchText.Length < 3)
            {
                VariablesList.Clear();
                foreach (var item in _unfilteredVariablesList)
                {
                    VariablesList.Add(item);
                }
            }
            else
            {
                VariablesList.Clear();
                foreach (var variable in _unfilteredVariablesList)
                {
                    // Search by Name property if it exists
                    var nameProperty = variable.Properties.FirstOrDefault(p => p.PropertyName == "Name:");
                    if (nameProperty != null && nameProperty.PropertyValue.ToLower().Contains(VariableSearchText.ToLower()))
                    {
                        VariablesList.Add(variable);
                    }
                }
            }
        }

        public void UpdateVisualDefinition(VariableEditorItemVM item)
        {
            if (item.DataObject is VisualDefinition visualDef)
            {
                var index = VisualDefinitions.FindIndex(v => v == visualDef);
                if (index >= 0)
                {
                    VisualDefinitions[index] = visualDef;
                }
            }
        }

        public void LoadExistingVariables(List<ConstantDefinition> constants,
            List<VisualDefinition> visualDefinitions,
            List<PrefabParameter> parameters)
        {
            _unfilteredVariablesList.Clear();
            Constants.Clear();
            VisualDefinitions.Clear();
            Parameters.Clear();

            foreach (var constant in constants)
            {
                var item = new VariableEditorItemVM(this, constant);
                _unfilteredVariablesList.Add(item);
                Constants.Add(constant);
            }

            foreach (var visualDef in visualDefinitions)
            {
                var item = new VariableEditorItemVM(this, visualDef);
                _unfilteredVariablesList.Add(item);
                VisualDefinitions.Add(visualDef);
            }

            foreach (var parameter in parameters)
            {
                var item = new VariableEditorItemVM(this, parameter);
                _unfilteredVariablesList.Add(item);
                Parameters.Add(parameter);
            }

            FilterVariablesList();
        }
    }
}