using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using PRS.Shared.Events;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;

namespace PRS.Shared.Grids.EventEditor;

public interface IEventTriggerEditor
{
    bool Edit(IEventTrigger trigger);
}

public interface IEventTriggerEditor<TTrigger> : IEventTriggerEditor
    where TTrigger : IEventTrigger
{
    bool Edit(TTrigger trigger);

    bool IEventTriggerEditor.Edit(IEventTrigger trigger) => Edit((TTrigger)trigger);
}

public static class EventTriggerEditors
{
    private static Dictionary<Type, Type>? _triggerEditors;
    private static Dictionary<Type, Type> GetTriggerEditors()
    {
        if(_triggerEditors is null)
        {
            _triggerEditors = new Dictionary<Type, Type>();
            foreach(var type in CoreUtils.TypeList(x => true))
            {
                if (type.GetInterfaceDefinition(typeof(IEventTriggerEditor<>)) is Type editorInterface)
                {
                    var triggerType = editorInterface.GenericTypeArguments[0];
                    triggerType = triggerType.IsGenericType ? triggerType.GetGenericTypeDefinition() : triggerType;
                    _triggerEditors[triggerType] = type;
                }
            }
        }
        return _triggerEditors;
    }

    public static Type? GetTriggerEditorType(Type triggerType)
    {
        var genericTriggerType = triggerType.IsGenericType ? triggerType.GetGenericTypeDefinition() : triggerType;
        if(GetTriggerEditors().GetValueOrDefault(genericTriggerType) is Type editorType)
        {
            return editorType.IsGenericType ? editorType.MakeGenericType(triggerType.GenericTypeArguments) : editorType;
        }
        else
        {
            return null;
        }
    }

    public static bool EditTrigger<TEvent, TDataModel>(IEventTrigger<TEvent, TDataModel> trigger)
        where TEvent : IEvent<TDataModel>
        where TDataModel : IEventDataModel
    {
        var editorType = GetTriggerEditorType(trigger.GetType());
        if (editorType is null) return true;

        var editor = (Activator.CreateInstance(editorType) as IEventTriggerEditor)!;
        return editor.Edit(trigger);
    }
}

public class PropertyChangedSaveEventTriggerEditor<T> : IEventTriggerEditor<PropertyChangedSaveEventTrigger<T>>
    where T : Entity, new()
{
    public bool Edit(PropertyChangedSaveEventTrigger<T> trigger)
    {
        var properties = DatabaseSchema.Properties(typeof(T))
            .Where(x => x.IsSerializable)
            .Select(x => x.Name)
            .ToList();
        properties.Sort();
        if(DynamicGridColumnNameSelectorGrid.SelectColumnName(typeof(T), properties, out var value))
        {
            trigger.TriggerProperty = DatabaseSchema.Property(typeof(T), value);
            return true;
        }
        else
        {
            return false;
        }
    }
}

public class ScriptSaveEventTriggerEditor<T> : IEventTriggerEditor<ScriptSaveEventTrigger<T>>
    where T : Entity, new()
{
    public bool Edit(ScriptSaveEventTrigger<T> trigger)
    {
        var window = new ScriptEditorWindow(trigger.Script ?? trigger.DefaultScript(), scriptTitle: "Edit Custom Script trigger");
        if(window.ShowDialog() == true)
        {
            trigger.Script = window.Script;
            return true;
        }
        else
        {
            return false;
        }
    }
}

public class FilterSaveEventTriggerEditor<T> : IEventTriggerEditor<FilterSaveEventTrigger<T>>
    where T : Entity, new()
{
    public bool Edit(FilterSaveEventTrigger<T> trigger)
    {
        var filter = trigger.Filter;
        if(FilterEditorWindow.Execute(ref filter))
        {
            trigger.Filter = filter;
            return true;
        }
        else
        {
            return false;
        }
    }
}