using Sirenix.OdinInspector;
using Sirenix.OdinInspector.Editor;
using Sirenix.Utilities;
using Sirenix.Utilities.Editor;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using UnityEditor;
using UnityEngine;

// Usage:
public class SomeScriptableObject : SerializedScriptableObject
{
    public BetterEventCollection Test;

    public void Update()
    {
        if (Input.GetKey(KeyCode.Space))
        {
            this.Test.Invoke();
        }
    }
}

// Data:
public struct BetterEventCollection
{
    [HideReferenceObjectPicker, ListDrawerSettings(CustomAddFunction = "GetDefaultBetterEvent", OnTitleBarGUI = "DrawInvokeButton")]
    public List<IBetterEvent> Events;

    public void Invoke()
    {
        if (this.Events == null) return;
        foreach (var e in this.Events)
        {
            if (e == null) continue;
            e.Invoke();
        }
    }

#if UNITY_EDITOR

    private IBetterEvent GetDefaultBetterEvent()
    {
        return new CustomEvent(null);
    }

    private void DrawInvokeButton()
    {
        if (SirenixEditorGUI.ToolbarButton("Invoke"))
        {
            this.Invoke();
        }
    }

#endif
}

public interface IBetterEvent
{
    Delegate Delegate { get; }
    void Invoke();
}

public class CustomEvent : IBetterEvent
{
    [SerializeField, HideInInspector]
    private Action action;

    public Delegate Delegate { get { return this.action; } }

    public CustomEvent(Action action)
    {
        this.action = action;
    }

    public void Invoke()
    {
        if (this.action != null)
        {
            this.action();
        }
    }
}

public class CustomEvent<T> : IBetterEvent
{
    [SerializeField, LabelText("$GetArg1LabelText")]
    private T arg1;

    [SerializeField, HideLabel, HideInInspector]
    private Action<T> action;

    public CustomEvent(Action<T> action)
    {
        this.action = action;
    }

    public Delegate Delegate { get { return this.action; } }

    public void Invoke()
    {
        if (this.action != null)
        {
            this.action(this.arg1);
        }
    }

    private string GetArg1LabelText()
    {
        if (this.action != null && this.action.Method != null)
        {
            return this.action.Method.GetParameters()[0].Name.SplitPascalCase();
        }

        return "Arg 1";
    }
}

public class CustomEvent<T1, T2> : IBetterEvent
{
    [SerializeField, LabelText("$GetArg1LabelText")]
    private T1 arg1;

    [SerializeField, LabelText("$GetArg2LabelText")]
    private T2 arg2;

    public CustomEvent(Action<T1, T2> action)
    {
        this.action = action;
    }

    public Delegate Delegate { get { return this.action; } }

    [SerializeField, HideLabel, HideInInspector]
    private Action<T1, T2> action;

    public void Invoke()
    {
        if (this.action != null)
        {
            this.action(this.arg1, this.arg2);
        }
    }

    private string GetArg1LabelText()
    {
        if (this.action != null && this.action.Method != null)
        {
            return this.action.Method.GetParameters()[0].Name.SplitPascalCase();
        }

        return "Arg 1";
    }

    private string GetArg2LabelText()
    {
        if (this.action != null && this.action.Method != null)
        {
            return this.action.Method.GetParameters()[1].Name.SplitPascalCase();
        }

        return "Arg 2";
    }
}

// Drawers:

// This drawer is completly optional but cleans up the inspector a lot. Try outcommenting it and see the difference.
// Instead of drawing the BetterEvent struct with its label and then a list named Events, this drawer will skip drawing the foldout, and draw the Events list with its own label.
public class BetterEventDrawer : OdinValueDrawer<BetterEventCollection>
{
    protected override void DrawPropertyLayout(GUIContent label)
    {
        this.Property.Children["Events"].Draw(label);
    }
}

public class IBetterEventAttributeDrawer<T> : OdinValueDrawer<T>
    where T : IBetterEvent
{
    // For while the user is modifying the delegate.
    private UnityEngine.Object tmpTarget;

    protected override void DrawPropertyLayout(GUIContent label)
    {
        SirenixEditorGUI.BeginBox();
        {
            SirenixEditorGUI.BeginToolbarBoxHeader();
            {
                var rect = GUILayoutUtility.GetRect(0, 19);
                var unityObjectFieldRect = rect.Padding(2).AlignLeft(rect.width / 2);
                var methodSelectorRect = rect.Padding(2).AlignRight(rect.width / 2 - 5);
                var dInfo = this.GetDelegateInfo();

                EditorGUI.BeginChangeCheck();
                var newTarget = SirenixEditorFields.UnityObjectField(unityObjectFieldRect, dInfo.Target, typeof(UnityEngine.Object), true);
                if (EditorGUI.EndChangeCheck())
                {
                    this.tmpTarget = newTarget;
                }

                if (dInfo.Target)
                {
                    EditorGUI.BeginChangeCheck();
                    var selectorText = dInfo.Method == null ? "Select a method" : dInfo.Method.GetNiceName();
                    var newMethod = MethodSelector.DrawSelectorDropdown(methodSelectorRect, selectorText, this.CreateSelector);
                    if (EditorGUI.EndChangeCheck())
                    {
                        this.CreateAndAssignNewDelegate(newMethod.FirstOrDefault());
                        this.tmpTarget = null;
                    }
                }
            }
            SirenixEditorGUI.EndToolbarBoxHeader();

            // Draws the rest of the ICustomEvent, and since we've drawn the label, we simply pass along null.
            this.CallNextDrawer(null);
        }
        SirenixEditorGUI.EndBox();
    }

    private void CreateAndAssignNewDelegate(DelegateInfo delInfo)
    {
        var method = delInfo.Method;
        var target = delInfo.Target;

        IBetterEvent result = null;
        var pTypes = method.GetParameters().Select(x => x.ParameterType).ToArray();
        var args = new object[1];

        if (pTypes.Length == 0)
        {
            var action = (Action)Delegate.CreateDelegate(typeof(Action), target, method);
            result = new CustomEvent(action);
        }
        else if (pTypes.Length == 1)
        {
            var delType = typeof(Action<>).MakeGenericType(pTypes);
            args[0] = Delegate.CreateDelegate(delType, target, method);
            result = (IBetterEvent)Activator.CreateInstance(typeof(CustomEvent<>).MakeGenericType(pTypes), args);
        }
        else if (pTypes.Length == 2)
        {
            var delType = typeof(Action<,>).MakeGenericType(pTypes);
            args[0] = Delegate.CreateDelegate(delType, target, method);
            result = (IBetterEvent)Activator.CreateInstance(typeof(CustomEvent<,>).MakeGenericType(pTypes), args);
        }
        else
        {
            Debug.LogError("TODO: Add more generic CustomEvent variants.");
        }

        this.Property.Tree.DelayActionUntilRepaint(() =>
        {
            this.ValueEntry.WeakSmartValue = result;
        });
    }

    private DelegateInfo GetDelegateInfo()
    {
        var value = this.ValueEntry.SmartValue;
        var del = value.Delegate;
        var methodInfo = del == null ? null : del.Method;

        UnityEngine.Object target = null;
        if (this.tmpTarget)
        {
            target = this.tmpTarget;
        }
        else if (del != null)
        {
            target = del.Target as UnityEngine.Object;
        }

        return new DelegateInfo() { Target = target, Method = methodInfo };
    }

    private OdinSelector<DelegateInfo> CreateSelector(Rect arg)
    {
        arg.xMin -= arg.width;
        var info = this.GetDelegateInfo();
        var sel = new MethodSelector(info.Target);
        sel.SetSelection(info);
        sel.ShowInPopup(arg);
        return sel;
    }

}

public struct DelegateInfo
{
    public UnityEngine.Object Target;
    public MethodInfo Method;
}

public class MethodSelector : OdinSelector<DelegateInfo>
{
    private BindingFlags bindingFlags = Flags.StaticPublic | Flags.InstancePublic | BindingFlags.FlattenHierarchy;
    private UnityEngine.Object currentObj = null;
    private HashSet<DelegateInfo> seenMethods = new HashSet<DelegateInfo>();

    public MethodSelector(UnityEngine.Object obj)
    {
        this.currentObj = obj;
    }

    protected override void BuildSelectionTree(OdinMenuTree tree)
    {
        tree.Config.DrawSearchToolbar = true;
        tree.Selection.SupportsMultiSelect = false;
        tree.Add("None", new DelegateInfo());
        tree.Config.UseCachedExpandedStates = false;

        var gameObject = this.currentObj as GameObject;
        var component = this.currentObj as Component;

        if (component)
        {
            gameObject = component.gameObject;
        }

        if (gameObject)
        {
            this.AddMethods(tree, gameObject);

            var components = gameObject.GetComponents(typeof(Component));
            foreach (var c in components)
            {
                this.AddMethods(tree, c);
            }
        }
        else if (this.currentObj)
        {
            this.AddMethods(tree, this.currentObj);
        }
    }

    public override bool IsValidSelection(IEnumerable<DelegateInfo> collection)
    {
        var info = collection.FirstOrDefault();
        return info.Method != null;
    }

    private void AddMethods(OdinMenuTree tree, UnityEngine.Object obj)
    {
        var methods = obj.GetType().GetMethods(this.bindingFlags);
        foreach (var mi in methods)
        {
            if (mi.ReturnType != typeof(void)) continue;
            if (mi.IsGenericMethod) continue;
            var target = mi.IsStatic ? null : obj;
            var info = new DelegateInfo() { Target = target, Method = mi };
            if (this.seenMethods.Add(info))
            {
                tree.Add(obj.GetType().GetNiceName() + "/" + mi.GetNiceName(), info);
            }
        }
    }
}