// Copyright (c) 2015 - 2023 Doozy Entertainment. All Rights Reserved.
// This code can only be used under the standard Unity Asset Store End User License Agreement
// A Copy of the EULA APPENDIX 1 is available at http://unity3d.com/company/legal/as_terms

using System;
using System.Collections.Generic;
using Doozy.Editor.EditorUI;
using Doozy.Editor.EditorUI.Utils;
using Doozy.Editor.Reactor.Internal;
using Doozy.Runtime.Nody;
using Doozy.Runtime.Reactor.Extensions;
using Doozy.Runtime.Reactor.Internal;
using Doozy.Runtime.Reactor.Reactions;
using Doozy.Runtime.UIElements.Extensions;
using UnityEditor;
using UnityEditor.Experimental.GraphView;
using UnityEngine;
using UnityEngine.UIElements;
using EditorStyles = Doozy.Editor.EditorUI.EditorStyles;
// ReSharper disable MemberCanBePrivate.Global
// ReSharper disable UnusedAutoPropertyAccessor.Global

namespace Doozy.Editor.Nody
{
    public class FlowPortView : Port, IDisposable
    {
        public void Dispose()
        {
            capacityIconReaction?.Recycle();
            RemoveFromHierarchy();
        }

        public bool canDeletePort => flowNode.CanDeletePort(flowPort.portId);

        private static Type defaultPortType => typeof(bool);

        public FlowGraphView graphView { get; }
        public FlowNodeView nodeView { get; }

        public FlowGraph flowGraph => graphView.flowGraph;
        public FlowNode flowNode => flowPort.node;
        public FlowPort flowPort { get; }

        public VisualElement connectorBox { get; }
        public VisualElement connectorBoxCap { get; }

        public Image capacityIcon { get; }
        public Texture2DReaction capacityIconReaction { get; }

        public VisualElement portInfoContainer { get; }

        public FlowPortView(FlowGraphView graphView, FlowNodeView nodeView, FlowPort flowPort) : this(graphView, nodeView, flowPort, Orientation.Horizontal, defaultPortType) {}
        public FlowPortView(FlowGraphView graphView, FlowNodeView nodeView, FlowPort flowPort, Orientation portOrientation) : this(graphView, nodeView, flowPort, portOrientation, defaultPortType) {}
        public FlowPortView(FlowGraphView graphView, FlowNodeView nodeView, FlowPort flowPort, Orientation portOrientation, Type type) : base(portOrientation, GetDirection(flowPort.direction), GetCapacity(flowPort.capacity), type)
        {
            this.graphView = graphView;
            this.nodeView = nodeView;
            this.flowPort = flowPort;
            flowPort.node ??= graphView.flowGraph.GetNodeById(flowPort.nodeId);

            this
                .AddStyle(EditorStyles.Nody.FlowPort)
                .SetStyleHeight(StyleKeyword.Auto)
                .SetStylePadding(0, 4, 0, 4)
                .SetStyleAlignSelf(Align.Center)
                .SetStyleFlexDirection(FlexDirection.Row);

            connectorBox = this.Q<VisualElement>("connector");      //get connector
            connectorBoxCap = connectorBox.Q<VisualElement>("cap"); //get cap
            this.Q<Label>().RemoveFromHierarchy();                  //remove label

            //create a container
            portInfoContainer =
                new VisualElement()
                    .SetName(nameof(portInfoContainer))
                    .SetStyleAlignItems(Align.Center)
                    .SetStyleFlexDirection(FlexDirection.Row);

            switch (direction)
            {
                case Direction.Input: //add container to the right
                    this
                        .SetStyleAlignSelf(Align.FlexStart)
                        .SetStyleMarginLeft(DesignUtils.k_Spacing);

                    Add(portInfoContainer);
                    Add(DesignUtils.flexibleSpace);
                    break;
                case Direction.Output: //add container to the left
                    this
                        .SetStyleAlignSelf(Align.FlexEnd)
                        .SetStyleMarginRight(DesignUtils.k_Spacing);

                    Insert(0, portInfoContainer);
                    Insert(0, DesignUtils.flexibleSpace);
                    break;
                default:
                    throw new ArgumentOutOfRangeException();
            }

            portColor = portDirectionColor;

            capacityIcon =
                new Image()
                    .ResetLayout()
                    .SetStyleFlexShrink(0)
                    .SetStyleSize(capacityIconSize)
                    .SetStyleBackgroundImageTintColor(this.flowPort.isConnected ? connectorBox.GetStyleBackgroundColor() : portColor)
                    .SetTooltip
                    (
                        this.flowPort.capacity == PortCapacity.Single ? "Single connection port" : this.flowPort.capacity == PortCapacity.Multi ? "Multi connections port" : throw new ArgumentOutOfRangeException()
                    );

            capacityIconReaction = capacityIcon
                .GetTexture2DReaction(capacityIconTextures)
                .SetEditorHeartbeat()
                .SetDuration(0.6f);


            RegisterCallback<PointerEnterEvent>(_ =>
            {
                capacityIconReaction?.Play();
                capacityIcon.SetStyleBackgroundImageTintColor(connectorBox.GetStyleBackgroundColor());
            });

            RegisterCallback<PointerLeaveEvent>(_ =>
            {
                // capacityIconReaction?.Play();
                UpdateCapacityIcon();
            });

            connectorBox.Add(capacityIcon);

            var connectorListener = new DefaultEdgeConnectorListener();
            m_EdgeConnector = new EdgeConnector<FlowEdgeView>(connectorListener);
            this.AddManipulator(m_EdgeConnector);
            this.AddManipulator(new ContextualMenuManipulator(BuildContextualMenu));
            this.RegisterCallback<CustomStyleResolvedEvent>(_ => UpdateCapacityIcon());
        }

        /// <summary>
        ///   <para>Add menu items to the port contextual menu.</para>
        /// </summary>
        /// <param name="evt">The event holding the menu to populate.</param>
        public void BuildContextualMenu(ContextualMenuPopulateEvent evt)
        {
            if (!(evt.target is FlowPortView))
                return;
        }

        public FlowEdgeView ConnectTo(FlowPortView otherPortView) =>
            ConnectTo<FlowEdgeView>(otherPortView)
                .SetInputPortView(direction == Direction.Input ? this : otherPortView)
                .SetOutputPortView(direction == Direction.Input ? otherPortView : this);

        public override void Connect(Edge edge)
        {
            base.Connect(edge);
            UpdateCapacityIcon();
            ((FlowPortView)edge.input).nodeView.RefreshData();
            ((FlowPortView)edge.output).nodeView.RefreshData();
        }

        public override void Disconnect(Edge edge)
        {
            base.Disconnect(edge);
            UpdateCapacityIcon();
            ((FlowPortView)edge.input).nodeView.RefreshData();
            ((FlowPortView)edge.output).nodeView.RefreshData();
        }

        public override void DisconnectAll()
        {
            base.DisconnectAll();
            UpdateCapacityIcon();
        }

        public override void OnStopEdgeDragging()
        {
            base.OnStopEdgeDragging();
            UpdateCapacityIcon();
        }

        private void UpdateCapacityIcon()
        {
            schedule.Execute(() =>
            {
                capacityIcon
                    .SetStyleBackgroundImageTintColor
                    (
                        connected
                            ? connectorBox.GetStyleBackgroundColor()
                            : portColor
                    );
            });
        }

        private class DefaultEdgeConnectorListener : IEdgeConnectorListener
        {
            private GraphViewChange m_GraphViewChange;
            private List<Edge> m_EdgesToCreate;
            private List<GraphElement> m_EdgesToDelete;

            public DefaultEdgeConnectorListener()
            {
                m_EdgesToCreate = new List<Edge>();
                m_EdgesToDelete = new List<GraphElement>();
                m_GraphViewChange.edgesToCreate = m_EdgesToCreate;
            }

            public void OnDropOutsidePort(Edge edge, Vector2 position)
            {
            }

            public void OnDrop(GraphView graphView, Edge edge)
            {
                m_EdgesToCreate.Clear();
                m_EdgesToCreate.Add(edge);
                m_EdgesToDelete.Clear();
                if (edge.input.capacity == Capacity.Single)
                {
                    foreach (Edge connection in edge.input.connections)
                    {
                        if (connection != edge)
                            m_EdgesToDelete.Add(connection);
                    }
                }
                if (edge.output.capacity == Capacity.Single)
                {
                    foreach (Edge connection in edge.output.connections)
                    {
                        if (connection != edge)
                            m_EdgesToDelete.Add(connection);
                    }
                }
                if (m_EdgesToDelete.Count > 0)
                    graphView.DeleteElements(m_EdgesToDelete);
                List<Edge> edgesToCreate = m_EdgesToCreate;
                if (graphView.graphViewChanged != null)
                    edgesToCreate = graphView.graphViewChanged(m_GraphViewChange).edgesToCreate;
                foreach (Edge newEdge in edgesToCreate)
                {
                    graphView.AddElement(newEdge);
                    edge.input.Connect(newEdge);
                    edge.output.Connect(newEdge);
                }
            }
        }

        private IEnumerable<Texture2D> capacityIconTextures
        {
            get
            {
                switch (flowPort.capacity)
                {
                    case PortCapacity.Single:
                        return EditorSpriteSheets.Nody.Icons.One;
                    case PortCapacity.Multi:
                        return EditorSpriteSheets.Nody.Icons.Infinity;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }
        }

        private int capacityIconSize
        {
            get
            {
                switch (flowPort.capacity)
                {
                    case PortCapacity.Single:
                        return 8;
                    case PortCapacity.Multi:
                        return 10;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }
        }

        private Color portDirectionColor
        {
            get
            {
                if (EditorApplication.isPlayingOrWillChangePlaymode)
                    return EditorColors.Nody.StateIdle;

                switch (flowPort.direction)
                {
                    case PortDirection.Input:
                        return EditorColors.Nody.Input;
                    case PortDirection.Output:
                        return EditorColors.Nody.Output;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }
        }


        /// <summary> Convert PortDirection (Nody) to Direction (Unity) </summary>
        public static Direction GetDirection(PortDirection portDirection)
        {
            switch (portDirection)
            {
                case PortDirection.Input:
                    return Direction.Input;
                case PortDirection.Output:
                    return Direction.Output;
                default:
                    throw new ArgumentOutOfRangeException(nameof(portDirection), portDirection, null);
            }
        }

        /// <summary> Convert Direction (Unity) to PortDirection (Nody) </summary>
        public static PortDirection GetPortDirection(Direction direction)
        {
            switch (direction)
            {
                case Direction.Input:
                    return PortDirection.Input;
                case Direction.Output:
                    return PortDirection.Output;
                default:
                    throw new ArgumentOutOfRangeException(nameof(direction), direction, null);
            }
        }

        /// <summary> Convert PortCapacity (Nody) to Capacity (Unity) </summary>
        public static Capacity GetCapacity(PortCapacity portCapacity)
        {
            switch (portCapacity)
            {
                case PortCapacity.Single:
                    return Capacity.Single;
                case PortCapacity.Multi:
                    return Capacity.Multi;
                default:
                    throw new ArgumentOutOfRangeException(nameof(portCapacity), portCapacity, null);
            }
        }

        /// <summary> Convert Capacity (Unity) to PortCapacity (Nody) </summary>
        public static PortCapacity GetCapacity(Capacity portCapacity)
        {
            switch (portCapacity)
            {
                case Capacity.Single:
                    return PortCapacity.Single;
                case Capacity.Multi:
                    return PortCapacity.Multi;
                default:
                    throw new ArgumentOutOfRangeException(nameof(portCapacity), portCapacity, null);
            }
        }

    }
}