prs/prs.shared/Grids/EventEditor/EventEditor.xaml.cs

using AutoProperties;
using Comal.Classes;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using PRS.Shared.Events;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;

namespace PRS.Shared;
/// <summary>
/// Interaction logic for EventEditorWIndow.xaml
/// </summary>
public partial class EventEditor : UserControl, INotifyPropertyChanged
{
    private EventType? _eventType;
    public EventType? EventType
    {
        get => _eventType;
        set
        {
            _eventType = value;
            OnPropertyChanged();

            HasType = value.HasValue && EventTypeHasEntityType(value.Value);
            HasTriggers = value != Comal.Classes.EventType.Scheduled;
            DoChanged();

            UpdateEventData();
        }
    }

    private Type? _entityType;
    public Type? EntityType
    {
        get => _entityType;
        set
        {
            _entityType = value;
            OnPropertyChanged();

            UpdateEventData();
        }
    }

    private bool _hasTriggers = true;
    public bool HasTriggers
    {
        get => _hasTriggers;
        set
        {
            _hasTriggers = value;
            OnPropertyChanged();
        }
    }

    private bool _hasProperties;
    public bool HasProperties
    {
        get => _hasProperties;
        set
        {
            _hasProperties = value;
            OnPropertyChanged();
        }
    }

    private bool _hasType;
    public bool HasType
    {
        get => _hasType;
        set
        {
            _hasType = value;
            OnPropertyChanged();
        }
    }

    private Type? EventDataType;
    private Type? DataModelType;

    private IEventEditorControl? _eventEditorControl;

    private bool _changed;
    public bool Changed
    {
        get => _changed;
        set
        {
            _changed = value;
            OnPropertyChanged();
        }
    }

    public IEventData? Data
    {
        get => _eventEditorControl?.Data;
        set
        {
            OnPropertyChanged();

            if(value is not null && EventType.HasValue)
            {
                if(EventDataType is null || DataModelType is null)
                {
                    var inter = value.GetType().GetSuperclassDefinition(typeof(EventData<,>))!;
                    EventDataType = inter.GenericTypeArguments[0];
                    DataModelType = inter.GenericTypeArguments[1];

                    if (EventTypeGetEntityType(EventType.Value, EventDataType) is Type entityType)
                    {
                        EntityType = entityType;
                    }
                }
                var control = Activator.CreateInstance(typeof(EventEditorControl<,>).MakeGenericType(EventDataType, DataModelType), value);
                _eventEditorControl = (control as IEventEditorControl)!;
                _eventEditorControl.OnChanged += DoChanged;
                Content.Content = control;
                Content.Visibility = Visibility.Visible;
                Placeholder.Visibility = Visibility.Collapsed;
            }
            else
            {
                _eventEditorControl = null;
                Content.Content = null;
                Content.Visibility = Visibility.Collapsed;
                Placeholder.Visibility = Visibility.Visible;
            }
            DoChanged();
        }
    }

    public EventEditor()
    {
        InitializeComponent();

        EventTypeBox.ItemsSource = Enum.GetValues<EventType>();

        var entities = CoreUtils.Entities.Where(x => !x.IsGenericType && x.IsSubclassOf(typeof(Entity))).ToArray();
        entities.SortBy(x => x.Name);

        EntityTypeBox.ItemsSource = entities;
    }

    private void DoChanged()
    {
        Changed = true;
    }

    private bool EventTypeHasEntityType(EventType eventType)
    {
        return EventUtils.GetEventType(eventType).HasInterface(typeof(IEntityEvent<>));
    }
    private Type? EventTypeGetEntityType(EventType eventType, Type eventDataType)
    {
        var evType = EventUtils.GetEventType(eventType);
        var entType = evType?.GetInterfaceDefinition(typeof(IEntityEvent<>))?.GenericTypeArguments[0];
        if (evType is null || entType is null) return null;

        var idx = Array.IndexOf(evType.GetGenericArguments(), entType);
        return eventDataType.GenericTypeArguments[idx];
    }

    private void UpdateEventData()
    {
        if (EventType is null || (EventTypeHasEntityType(EventType.Value) && EntityType is null))
        {
            Data = null;
            HasProperties = false;
            return;
        }

        Type dataModelType;

        var eventType = EventUtils.GetEventType(EventType.Value);
        if (eventType.IsGenericTypeDefinition)
        {
            if(!eventType.BuildGenericType()
                .AddInterface(typeof(IEntityEvent<>), EntityType!)
                .TryBuild(out eventType))
            {
                Data = null;
                HasProperties = false;
                return;
            }
        }
        dataModelType = eventType.GetInterfaceDefinition(typeof(IEvent<>))!.GenericTypeArguments[0];

        HasProperties = eventType.HasInterface(typeof(IPropertiesEvent<>));

        var ev = Activator.CreateInstance(eventType);
        EventDataType = eventType;
        DataModelType = dataModelType;
        Data = (Activator.CreateInstance(typeof(EventData<,>).MakeGenericType(eventType, dataModelType), ev) as IEventData)!;
    }

    private void EditButton_Click(object sender, RoutedEventArgs e)
    {
        if (EventDataType is null || EventDataType.GetInterfaceDefinition(typeof(IPropertiesEvent<>)) is not Type propertiesInterface) return;

        var method = GetType().GetMethod(nameof(EditProperties), BindingFlags.Instance | BindingFlags.NonPublic)!
            .MakeGenericMethod(propertiesInterface.GenericTypeArguments[0]);
        method.Invoke(this, []);
    }

    private void EditProperties<TProperties>() where TProperties : BaseObject, new()
    {
        if (Data?.Event is not IPropertiesEvent<TProperties> propertiesEvent) return;

        var props = propertiesEvent.GetProperties();
        if (DynamicGridUtils.EditEntity(props))
        {
            propertiesEvent.SetProperties(props);
            DoChanged();
        }
    }

    public static bool Run(ref EventType evType, ref IEventData? eventData)
    {
        var editor = new EventEditor();

        editor.EventType = evType;
        if(eventData is not null)
        {
            editor.Data = eventData;
        }

        editor.Changed = false;

        var dialog = new DynamicContentDialog(editor)
        {
            SizeToContent = SizeToContent.Height,
            Title = "Edit Event"
        };
        dialog.Bind(DynamicContentDialog.CanSaveProperty, editor, x => x.Changed);

        if(dialog.ShowDialog() == true)
        {
            eventData = editor.Data;
            evType = editor.EventType ?? default;
            return true;
        }
        else
        {
            return false;
        }
    }
}