using System.Runtime.CompilerServices;
using Rive.Components;
using UnityEditor;
using UnityEngine;
using UnityEngine.UI;

[assembly: InternalsVisibleTo("Rive.Tests.Editor")]
namespace Rive.EditorTools
{
    /// <summary>
    /// Custom menu items for creating Rive components.
    /// </summary>
    //Make internals visible to test assembly
    internal class MenuItems
    {
        internal enum PanelContext
        {
            Standalone = 0,
            Canvas = 1
        }

        [MenuItem("GameObject/Rive/Rive Panel", false, 10)]
        static void CreateRivePanel(MenuCommand menuCommand) =>
            CreateRivePanelInternal(menuCommand, PanelContext.Standalone);

        [MenuItem("GameObject/Rive/Rive Panel (Canvas)", false, 11)]
        static void CreateRivePanelWithCanvas(MenuCommand menuCommand) =>
            CreateRivePanelInternal(menuCommand, PanelContext.Canvas);

        [MenuItem("GameObject/Rive/Widgets/Rive Widget", false, 12)]
        static void CreateRiveWidget(MenuCommand menuCommand)
        {
            GameObject widgetObj = new GameObject("Rive Widget", typeof(RiveWidget));

            // If we have a context (selected object), try to parent to it
            GameObject parent = menuCommand.context as GameObject;
            if (parent != null)
            {
                GameObjectUtility.SetParentAndAlign(widgetObj, parent);

                ConfigureRectTransformToFill(widgetObj.GetComponent<RectTransform>());

            }

            Undo.RegisterCreatedObjectUndo(widgetObj, "Create Rive Widget");
            Selection.activeObject = widgetObj;
        }

        [MenuItem("GameObject/Rive/Widgets/Procedural Rive Widget", false, 13)]
        static void CreateProceduralRiveWidget(MenuCommand menuCommand)
        {
            GameObject widgetObj = new GameObject("Procedural Rive Widget", typeof(ProceduralRiveWidget));

            // If we have a context (selected object), try to parent to it
            GameObject parent = menuCommand.context as GameObject;
            if (parent != null)
            {
                GameObjectUtility.SetParentAndAlign(widgetObj, parent);

                ConfigureRectTransformToFill(widgetObj.GetComponent<RectTransform>());

            }

            Undo.RegisterCreatedObjectUndo(widgetObj, "Create Procedural Rive Widget");
            Selection.activeObject = widgetObj;
        }



        [MenuItem("GameObject/Rive/Render Target Strategies/Atlas Render Target Strategy", false, 21)]
        static void CreateAtlasRenderTargetStrategy(MenuCommand menuCommand) =>
            CreateRenderTargetStrategy<AtlasRenderTargetStrategy>(menuCommand);

        [MenuItem("GameObject/Rive/Render Target Strategies/Pooled Render Target Strategy", false, 22)]
        static void CreatePooledRenderTargetStrategy(MenuCommand menuCommand) =>
            CreateRenderTargetStrategy<PooledRenderTargetStrategy>(menuCommand);

        private static void CreateRenderTargetStrategy<T>(MenuCommand menuCommand) where T : RenderTargetStrategy
        {
            string typeName = typeof(T).Name;
            string objectName = ObjectNames.NicifyVariableName(typeName);

            GameObject obj = new GameObject(objectName, typeof(T));
            GameObjectUtility.SetParentAndAlign(obj, menuCommand.context as GameObject);

            Undo.RegisterCreatedObjectUndo(obj, $"Create {objectName}");
            Selection.activeObject = obj;
        }

        internal static RivePanel CreateRivePanelInternal(MenuCommand menuCommand, PanelContext context)
        {
            GameObject rootObject;
            GameObject panelObj;

            if (context == PanelContext.Canvas)
            {
                // Check if we already have a canvas parent
                Canvas parentCanvas = null;
                GameObject contextObj = menuCommand.context as GameObject;
                if (contextObj != null)
                {
                    parentCanvas = contextObj.GetComponentInParent<Canvas>();
                }

                if (parentCanvas != null)
                {
                    // Use existing canvas as root
                    rootObject = parentCanvas.gameObject;
                }
                else
                {
                    // Create new canvas
                    rootObject = new GameObject("Canvas", typeof(Canvas), typeof(CanvasScaler), typeof(GraphicRaycaster));
                    GameObjectUtility.SetParentAndAlign(rootObject, contextObj);
                    rootObject.GetComponent<Canvas>().renderMode = RenderMode.ScreenSpaceOverlay;
                }

                panelObj = new GameObject("Rive Panel", typeof(RivePanel), typeof(RiveCanvasRenderer));
                panelObj.transform.SetParent(rootObject.transform, false);

                var renderer = panelObj.GetComponent<RiveCanvasRenderer>();
                renderer.RivePanel = panelObj.GetComponent<RivePanel>();

                // Canvas panel fills parent
                ConfigureRectTransformToFill(panelObj.GetComponent<RectTransform>());
            }
            else
            {
                panelObj = new GameObject("Rive Panel", typeof(RectTransform), typeof(RivePanel));
                GameObjectUtility.SetParentAndAlign(panelObj, menuCommand.context as GameObject);
                rootObject = panelObj;

                // Standalone panel uses absolute size
                panelObj.GetComponent<RivePanel>().SetDimensions(new Vector2(1920, 1080));
            }

            // Temporarily disable so that re-enabling the gameobjects triggers a refresh when everything is set up. Otherwise, the RivePanel might not be initialized correctly for editor preview.
            panelObj.SetActive(false);

            // Create and configure widget. We also want it to fill the parent.
            GameObject widgetObj = new GameObject("Rive Widget", typeof(RectTransform), typeof(RiveWidget));
            widgetObj.transform.SetParent(panelObj.transform, false);
            ConfigureRectTransformToFill(widgetObj.GetComponent<RectTransform>());

            // Re-enable panel after everything is set up so that the editor preview has enough information to render the panel
            panelObj.SetActive(true);

            // Register undo and select the panel so that the user can start editing it right away
            Undo.RegisterCreatedObjectUndo(rootObject, $"Create Rive Panel{(context == PanelContext.Canvas ? " with Canvas" : "")}");
            Selection.activeObject = widgetObj;

            return panelObj.GetComponent<RivePanel>();
        }

        internal static void ConfigureRectTransformToFill(RectTransform rect)
        {
            rect.anchorMin = Vector2.zero;
            rect.anchorMax = Vector2.one;
            rect.sizeDelta = Vector2.zero;
        }


        [InitializeOnLoadMethod]
        static void OnLoad()
        {
#if UNITY_6000_3_OR_NEWER
            DragAndDrop.AddDropHandlerV2(OnSceneDrop);
            DragAndDrop.AddDropHandlerV2(OnHierarchyDropV2);
#else
            DragAndDrop.AddDropHandler(OnSceneDrop);
            DragAndDrop.AddDropHandler(OnHierarchyDrop);
#endif
        }

        private static bool ValidateRiveAssetDrag()
        {
            if (DragAndDrop.objectReferences.Length != 1)
                return false;

            return DragAndDrop.objectReferences[0] is Asset;
        }

        private static DragAndDropVisualMode OnSceneDrop(Object dropUpon, Vector3 worldPosition, Vector2 viewportPosition, Transform parentForDraggedObjects, bool perform)
        {
            if (!ValidateRiveAssetDrag())
            {
                return DragAndDropVisualMode.None;
            }

            if (perform)
            {
                Asset riveAsset = DragAndDrop.objectReferences[0] as Asset;

                if (riveAsset == null)
                    return DragAndDropVisualMode.Rejected;

                GameObject parentObject = dropUpon as GameObject;
                Transform parentTransform = parentObject != null ? parentObject.transform : null;
                HandleAssetDrop(riveAsset, parentTransform);
            }
            return DragAndDropVisualMode.Move;
        }

        private static UnityEngine.EventSystems.EventSystem GetExistingEventSystem()
        {

#if UNITY_6000_0_OR_NEWER
            return Object.FindFirstObjectByType<UnityEngine.EventSystems.EventSystem>();
#else
            return Object.FindObjectOfType<UnityEngine.EventSystems.EventSystem>();
#endif

        }

        private static void EnsureEventSystemExists()
        {

            if (GetExistingEventSystem() == null)
            {
                GameObject eventSystem = new GameObject("EventSystem",
                    typeof(UnityEngine.EventSystems.EventSystem),
                    typeof(UnityEngine.EventSystems.StandaloneInputModule));

                Undo.RegisterCreatedObjectUndo(eventSystem, "Create EventSystem");
            }
        }

        /// <summary>
        /// Handles dropping a Rive asset onto a game object in the heirarchy/scene.
        /// </summary>
        /// <param name="riveAsset"> The Rive asset to drop. </param>
        /// <param name="parent"> The parent transform to drop the asset under. </param>
        internal static void HandleAssetDrop(Asset riveAsset, Transform parent)
        {
            // If the RivePanel is just dropped into the scene, we want to create a standalone panel that displays within a canvas.
            // However, when the panel is dropped onto a game object with a MeshRenderer, we want to create a standalone RivePanel, then add a RiveTextureRenderer to the meshrenderer game object.

            // Create a group for all undo operations so we can collapse them into a single undo step at the end
            Undo.IncrementCurrentGroup();
            var undoGroupIndex = Undo.GetCurrentGroup();

            // Check if we're dropping onto or under an existing RivePanel
            RivePanel existingPanel = null;
            if (parent != null)
            {
                existingPanel = parent.GetComponent<RivePanel>();


                if (existingPanel == null)
                {

                    existingPanel = parent.GetComponentInParent<RivePanel>();
                }


            }

            // If we're under an existing panel, we want to create a widget under it, instead of creating a new panel.
            if (existingPanel != null)
            {

                RiveWidget parentWidget = parent.GetComponentInParent<RiveWidget>();

                // If the parent is a widget, we want to create the new widget as a sibling to the parent widget.
                // Nesting widgets works, but we don't want to encourage it as it might lead to unexpected behavior.
                Transform parentTransform = parentWidget != null ? parentWidget.transform.parent : parent;

                GameObject widgetObj = new GameObject("Rive Widget", typeof(RiveWidget));
                GameObjectUtility.SetParentAndAlign(widgetObj, parentTransform.gameObject);
                ConfigureRectTransformToFill(widgetObj.GetComponent<RectTransform>());

                var riveWidget = widgetObj.GetComponent<RiveWidget>();
                Undo.RecordObject(riveWidget, "Set Rive Asset Reference");
                riveWidget.SetEditorAssetReference(riveAsset);

                Undo.RegisterCreatedObjectUndo(widgetObj, "Create Rive Widget");
                Selection.activeObject = widgetObj;

                Undo.CollapseUndoOperations(undoGroupIndex);
                return;
            }


            PanelContext context = PanelContext.Canvas;
            GameObject parentGameObject = parent != null ? parent.gameObject : null;
            GameObject meshRendererGameObject = parentGameObject;

            if (parent != null)
            {
                if (parentGameObject.GetComponent<MeshRenderer>() != null)
                {
                    context = PanelContext.Standalone;

                    // We also clear the parent object so that the panel is created as a standalone object in the scene
                    // This might change in the future, but we do this to avoid a bunch of issues that might come from the parent potentially having non-uniform scale, which would affect the RivePanel's rendering.
                    // We also want to avoid unnecessarily re-drawing the panel when the parent object transform is updated.
                    parentGameObject = null;
                }
            }



            RivePanel panel = CreateRivePanelInternal(new MenuCommand(parentGameObject), context);
            Undo.RegisterFullObjectHierarchyUndo(panel.gameObject, "Create Rive Panel");

            var widget = panel.GetComponentInChildren<RiveWidget>();
            if (widget != null)
            {
                Undo.RecordObject(widget, "Set Rive Asset Reference");
                widget.SetEditorAssetReference(riveAsset);
            }

            if (context == PanelContext.Standalone && meshRendererGameObject != null)
            {
                if (meshRendererGameObject != null)
                {
                    // Add a RiveTextureRenderer to the meshRendererGameObject object so that the RivePanel is rendered there.
                    RiveTextureRenderer textureRenderer;
                    if (!meshRendererGameObject.TryGetComponent<RiveTextureRenderer>(out textureRenderer))
                    {
                        textureRenderer = Undo.AddComponent<RiveTextureRenderer>(meshRendererGameObject);
                    }

                    Undo.RecordObject(textureRenderer, "Set Rive Panel Reference");
                    textureRenderer.RivePanel = panel;
                }

                // Set the Panel dimensions to match the default Artboard's size so that the RivePanel is rendered with the correct aspect ratio.
                if (riveAsset.EditorOnlyMetadata.Artboards.Count > 0)
                {

                    FileMetadata.ArtboardMetadata defaultArtboard = riveAsset.EditorOnlyMetadata.Artboards[0];

                    panel.SetDimensions(new Vector2(defaultArtboard.Width, defaultArtboard.Height));
                }
            }

            // Ensure we have an EventSystem in the scene so that the RivePanel can receive input events
            EnsureEventSystemExists();

            // Collapse all operations into a single undo step
            Undo.CollapseUndoOperations(undoGroupIndex);
        }

        private static DragAndDropVisualMode HandleHierarchyDrop(GameObject parentObject, bool perform)
        {
            if (!ValidateRiveAssetDrag())
            {
                // If we don't do this, it breaks regular drag and drop in the hierarchy
                // e.g. dragging a game object into another game object stops working
                return DragAndDropVisualMode.None;
            }

            if (perform)
            {
                Asset riveAsset = DragAndDrop.objectReferences[0] as Asset;

                if (riveAsset == null)
                    return DragAndDropVisualMode.Rejected;

                Transform parentTransform = parentObject != null ? parentObject.transform : null;
                HandleAssetDrop(riveAsset, parentTransform);
            }

            return DragAndDropVisualMode.Move;
        }

#if UNITY_6000_3_OR_NEWER
        private static DragAndDropVisualMode OnHierarchyDropV2(EntityId dropTargetEntityId, HierarchyDropFlags dropMode, Transform parentForDraggedObjects, bool perform)
        {
            GameObject parentObject = EditorUtility.EntityIdToObject(dropTargetEntityId) as GameObject;
            return HandleHierarchyDrop(parentObject, perform);
        }
#else
        private static DragAndDropVisualMode OnHierarchyDrop(int dropTargetInstanceID, HierarchyDropFlags dropMode, Transform parentForDraggedObjects, bool perform)
        {
            GameObject parentObject = EditorUtility.InstanceIDToObject(dropTargetInstanceID) as GameObject;
            return HandleHierarchyDrop(parentObject, perform);
        }
#endif

    }
}