using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Reflection;
using UnityEngine;
using UnityEngine.VFX;
using Object = UnityEngine.Object;

namespace UnityEditor.VFX
{
    interface IVFXSlotContainer
    {
        VFXSlot activationSlot { get; } // Return the activation slot if any, null otherwise
        ReadOnlyCollection<VFXSlot> inputSlots { get; }
        ReadOnlyCollection<VFXSlot> outputSlots { get; }

        int GetNbInputSlots();
        int GetNbOutputSlots();

        VFXSlot GetInputSlot(int index);
        VFXSlot GetOutputSlot(int index);

        void AddSlot(VFXSlot slot, int index = -1);
        void RemoveSlot(VFXSlot slot);
        void ReplaceSlot(VFXSlot prevSlot, VFXSlot newSlot);

        int GetSlotIndex(VFXSlot slot);

        void UpdateOutputExpressionsIfNeeded();

        void ClearSlots();
        bool ResyncSlots(bool notify);
        void Invalidate(VFXModel.InvalidationCause cause);
        void Invalidate(VFXModel model, VFXModel.InvalidationCause cause);

        void SetSettingValue(string name, object value);

        object GetSettingValue(string name);

        VFXSetting GetSetting(string name);

        void OnCopyLinksOtherSlot(VFXSlot mySlot, VFXSlot prevOtherSlot, VFXSlot newOtherSlot);
        void OnCopyLinksMySlot(VFXSlot myPrevSlot, VFXSlot myNewSlot, VFXSlot otherSlot);

        bool collapsed { get; set; }

        VFXSpace GetOutputSpaceFromSlot(VFXSlot slot);
    }

    abstract class VFXSlotContainerModel<ParentType, ChildrenType> : VFXModel<ParentType, ChildrenType>, IVFXSlotContainer
        where ParentType : VFXModel
        where ChildrenType : VFXModel
    {
        public virtual VFXSlot activationSlot => null;
        public virtual ReadOnlyCollection<VFXSlot> inputSlots { get { return m_InputSlots.AsReadOnly(); } }
        public virtual ReadOnlyCollection<VFXSlot> outputSlots { get { return m_OutputSlots.AsReadOnly(); } }

        public virtual int GetNbInputSlots() { return m_InputSlots.Count; }
        public virtual int GetNbOutputSlots() { return m_OutputSlots.Count; }

        public virtual VFXSlot GetInputSlot(int index) { return m_InputSlots[index]; }
        public virtual VFXSlot GetOutputSlot(int index) { return m_OutputSlots[index]; }

        protected virtual IEnumerable<VFXPropertyWithValue> inputProperties { get { return PropertiesFromType(GetInputPropertiesTypeName()); } }
        protected virtual IEnumerable<VFXPropertyWithValue> outputProperties { get { return PropertiesFromType(GetOutputPropertiesTypeName()); } }

        // Get properties with value from nested class fields
        protected IEnumerable<VFXPropertyWithValue> PropertiesFromType(string typeName)
        {
            //using are own GetRecursiveNestedType is needed for .net 4.0 compability
            return PropertiesFromType(GetType().GetRecursiveNestedType(typeName));
        }

        // Get properties with value from type fields
        public static IEnumerable<VFXPropertyWithValue> PropertiesFromType(Type type)
        {
            if (type == null)
                return Enumerable.Empty<VFXPropertyWithValue>();

            var instance = System.Activator.CreateInstance(type);
            return type.GetFields()
                .Where(f => !f.IsStatic)
                .Select(f =>
                {
                    var p = new VFXPropertyWithValue();
                    p.property = new VFXProperty(f);
                    p.value = f.GetValue(instance);
                    return p;
                });
        }

        // Get properties with values from slots
        protected static IEnumerable<VFXPropertyWithValue> PropertiesFromSlots(IEnumerable<VFXSlot> slots)
        {
            return slots.Select(s =>
            {
                var p = new VFXPropertyWithValue();
                p.property = s.property;
                p.value = s.value;
                return p;
            });
        }

        // Get properties with values from slots if any or initialize from default inner class name
        protected IEnumerable<VFXPropertyWithValue> PropertiesFromSlotsOrDefaultFromClass(VFXSlot.Direction direction)
        {
            bool isInput = direction == VFXSlot.Direction.kInput;
            var slots = isInput ? inputSlots : outputSlots;
            if (slots.Count() == 0)
                return PropertiesFromType(isInput ? GetInputPropertiesTypeName() : GetOutputPropertiesTypeName());
            else
                return PropertiesFromSlots(slots);
        }

        protected static string GetInputPropertiesTypeName()
        {
            return "InputProperties";
        }

        protected static string GetOutputPropertiesTypeName()
        {
            return "OutputProperties";
        }

        public virtual void AddSlot(VFXSlot slot, int index = -1) { InnerAddSlot(slot, index, true); }
        private void InnerAddSlot(VFXSlot slot, int index, bool notify)
        {
            var slotList = slot.direction == VFXSlot.Direction.kInput ? m_InputSlots : m_OutputSlots;

            if (!slot.IsMasterSlot())
                throw new ArgumentException("InnerAddSlot expect only a masterSlot");

            if (slot.owner != this as IVFXSlotContainer)
            {
                if (slot.owner != null)
                    slot.owner.RemoveSlot(slot);

                int realIndex = index == -1 ? slotList.Count : index;
                slotList.Insert(realIndex, slot);
                slot.SetOwner(this);
                if (notify)
                    Invalidate(InvalidationCause.kStructureChanged);
            }
        }

        void IVFXSlotContainer.Invalidate(VFXModel model, InvalidationCause cause)
        {
            Invalidate(model, cause);
        }

        public virtual void OnCopyLinksOtherSlot(VFXSlot mySlot, VFXSlot prevOtherSlot, VFXSlot newOtherSlot)
        {
        }

        public virtual void OnCopyLinksMySlot(VFXSlot myPrevSlot, VFXSlot myNewSlot, VFXSlot otherSlot)
        {
        }

        public virtual void RemoveSlot(VFXSlot slot) { InnerRemoveSlot(slot, true); }
        private void InnerRemoveSlot(VFXSlot slot, bool notify)
        {
            var slotList = slot.direction == VFXSlot.Direction.kInput ? m_InputSlots : m_OutputSlots;

            if (!slot.IsMasterSlot())
                throw new ArgumentException();

            if (slot.owner == this as IVFXSlotContainer)
            {
                slotList.Remove(slot);
                slot.SetOwner(null);
                if (notify)
                    Invalidate(InvalidationCause.kStructureChanged);
            }
        }

        public virtual void ReplaceSlot(VFXSlot prevSlot, VFXSlot newSlot) { InnerReplaceSlot(prevSlot, newSlot, true); }
        private void InnerReplaceSlot(VFXSlot prevSlot, VFXSlot newSlot, bool notify)
        {
            int index = GetSlotIndex(prevSlot);
            InnerRemoveSlot(prevSlot, false);
            InnerAddSlot(newSlot, index, false);
            if (notify)
                Invalidate(InvalidationCause.kStructureChanged);
        }

        public int GetSlotIndex(VFXSlot slot)
        {
            var slotList = slot.direction == VFXSlot.Direction.kInput ? m_InputSlots : m_OutputSlots;
            return slotList.IndexOf(slot);
        }

        protected VFXSlotContainerModel()
        { }

        public override void OnEnable()
        {
            base.OnEnable();

            if (m_InputSlots == null)
            {
                m_InputSlots = new List<VFXSlot>();
                SyncSlots(VFXSlot.Direction.kInput, false); // Initial slot creation
            }
            else
            {
                int nbRemoved = m_InputSlots.RemoveAll(c => c == null);// Remove bad references if any
                if (nbRemoved > 0)
                    Debug.LogWarning(String.Format("Remove {0} input slot(s) that couldnt be deserialized from {1} of type {2}", nbRemoved, name, GetType()));
            }

            if (m_OutputSlots == null)
            {
                m_OutputSlots = new List<VFXSlot>();
                SyncSlots(VFXSlot.Direction.kOutput, false); // Initial slot creation
            }
            else
            {
                int nbRemoved = m_OutputSlots.RemoveAll(c => c == null);// Remove bad references if any
                if (nbRemoved > 0)
                    Debug.LogWarning(String.Format("Remove {0} output slot(s) that couldnt be deserialized from {1} of type {2}", nbRemoved, name, GetType()));
            }
        }

        public override void Sanitize(int version)
        {
            base.Sanitize(version);
            if (ResyncSlots(true))
                Debug.Log(string.Format("Slots have been resynced in {0} of type {1}", name, GetType()));
        }

        public override void OnUnknownChange()
        {
            base.OnUnknownChange();
            m_OutputExpressionsUpToDate = false;
            ResyncSlots(false);
        }

        public override void CollectDependencies(HashSet<ScriptableObject> objs, bool ownedOnly = true)
        {
            base.CollectDependencies(objs, ownedOnly);
            foreach (var slot in m_InputSlots.Concat(m_OutputSlots))
            {
                objs.Add(slot);
                slot.CollectDependencies(objs, ownedOnly);
            }
        }

        public virtual bool ResyncSlots(bool notify)
        {
            bool changed = false;
            changed |= SyncSlots(VFXSlot.Direction.kInput, notify);
            changed |= SyncSlots(VFXSlot.Direction.kOutput, notify);
            return changed;
        }

        //Specific helper for VFXLibrary, doesn't notify, used before applying variants.
        public void ClearSlots()
        {
            while (m_InputSlots.Count > 0)
                InnerRemoveSlot(m_InputSlots.First(), false);
            while (m_OutputSlots.Count > 0)
                InnerRemoveSlot(m_OutputSlots.First(), false);
        }

        public void MoveSlots(VFXSlot.Direction direction, int movedIndex, int targetIndex)
        {
            VFXSlot movedSlot = m_InputSlots[movedIndex];
            if (movedIndex < targetIndex)
            {
                m_InputSlots.Insert(targetIndex, movedSlot);
                m_InputSlots.RemoveAt(movedIndex);
            }
            else
            {
                m_InputSlots.RemoveAt(movedIndex);
                m_InputSlots.Insert(targetIndex, movedSlot);
            }
        }

        protected override void OnInvalidate(VFXModel model, InvalidationCause cause)
        {
            if (model == this && cause == InvalidationCause.kSettingChanged)
                ResyncSlots(true);

            base.OnInvalidate(model, cause);
        }

        static public IEnumerable<VFXNamedExpression> GetExpressionsFromSlots(IVFXSlotContainer slotContainer)
        {
            foreach (var master in slotContainer.inputSlots)
            {
                foreach (var slot in master.GetExpressionSlots())
                {
                    var expression = slot.GetExpression();
                    yield return new VFXNamedExpression(expression, slot.fullName);
                }
            }
        }

        protected void InitSlotsFromProperties(IEnumerable<VFXPropertyWithValue> properties, VFXSlot.Direction direction)
        {
            foreach (var p in properties)
            {
                var slot = VFXSlot.Create(p, direction);
                InnerAddSlot(slot, -1, false);
            }
        }

        public VFXSlot GetSlotByPath(bool input, string path)
        {
            string[] elements = path.Split('_');

            IEnumerable<VFXSlot> slots = input ? m_InputSlots : m_OutputSlots;

            VFXSlot slot = null;
            for (int i = 0; i < elements.Length; ++i)
            {
                slot = slots.FirstOrDefault(t => t.name == elements[i]);
                if (slot == null) break;
                slots = slot.children;
            }

            return slot;
        }

        protected bool SyncSlots(VFXSlot.Direction direction, bool notify)
        {
            bool isInput = direction == VFXSlot.Direction.kInput;

            var expectedProperties = (isInput ? inputProperties : outputProperties).ToArray();
            int nbSlots = isInput ? GetNbInputSlots() : GetNbOutputSlots();
            var currentSlots = isInput ? inputSlots : outputSlots;

            // check all slots owner (TODO Still useful?)
            for (int i = 0; i < nbSlots; ++i)
            {
                VFXSlot slot = currentSlots[i];
                var slotOwner = slot.owner as VFXSlotContainerModel<ParentType, ChildrenType>;
                if (slotOwner != this)
                {
                    Debug.LogError("Slot :" + slot.name + " of Container" + name + "Has a wrong owner.");
                    slot.SetOwner(this); // make sure everything works even if the owner was lost for some reason.
                }
            }

            bool recreate = false;
            if (nbSlots != expectedProperties.Length)
                recreate = true;
            else
            {
                for (int i = 0; i < nbSlots; ++i)
                    if (!currentSlots[i].property.Equals(expectedProperties[i].property))
                    {
                        recreate = true;
                        break;
                    }
            }

            if (recreate)
            {
                var existingSlots = new List<VFXSlot>(currentSlots);

                // Remove all slots
                for (int i = nbSlots - 1; i >= 0; --i)
                    InnerRemoveSlot(currentSlots[i], false);

                var newSlotCount = expectedProperties.Length;
                var newSlots = new VFXSlot[newSlotCount];
                var createdSlots = new List<VFXSlot>(newSlotCount);

                // Reuse slots that already exists or create a new one if not
                for (int i = 0; i < newSlotCount; ++i)
                {
                    var p = expectedProperties[i];
                    var slot = existingSlots.Find(s => p.property.Equals(s.property));
                    if (slot != null)
                    {
                        slot.UpdateAttributes(p.property.attributes, notify);
                        existingSlots.Remove(slot);
                    }
                    else
                    {
                        slot = VFXSlot.Create(p, direction);
                        createdSlots.Add(slot);
                    }

                    newSlots[i] = slot;
                }

                for (int i = 0; i < createdSlots.Count; ++i)
                {
                    var dstSlot = createdSlots[i];

                    // Try to keep links and value for slots of same name and compatible types
                    var srcSlot = existingSlots.FirstOrDefault(s => s.property.name == dstSlot.property.name);

                    // Find the first slot with same type (should perform a more clever selection based on name distance)
                    if (srcSlot == null)
                        srcSlot = existingSlots.FirstOrDefault(s => s.property.type == dstSlot.property.type);

                    // Try to find a slot that can be implicitely converted
                    if (srcSlot == null)
                        srcSlot = existingSlots.FirstOrDefault(s => VFXConverter.CanConvertTo(s.property.type, dstSlot.property.type));

                    if (srcSlot != null)
                    {
                        VFXSlot.CopyLinksAndValue(dstSlot, srcSlot, notify);
                        srcSlot.UnlinkAll(true, notify);
                        existingSlots.Remove(srcSlot);
                    }
                }

                // Remove all remaining links
                foreach (var slot in existingSlots)
                    slot.UnlinkAll(true, notify);

                // Add all slots
                foreach (var s in newSlots)
                    InnerAddSlot(s, -1, false);

                if (notify)
                    Invalidate(InvalidationCause.kStructureChanged);
            }
            else
            {
                // Update properties
                for (int i = 0; i < nbSlots; ++i)
                    currentSlots[i].UpdateAttributes(expectedProperties[i].property.attributes, notify);
            }

            return recreate;
        }

        public void ExpandPath(string fieldPath)
        {
            m_expandedPaths.Add(fieldPath);
            Invalidate(InvalidationCause.kParamChanged);
        }

        public void RetractPath(string fieldPath)
        {
            m_expandedPaths.Remove(fieldPath);
            Invalidate(InvalidationCause.kParamChanged);
        }

        public bool IsPathExpanded(string fieldPath)
        {
            return m_expandedPaths.Contains(fieldPath);
        }

        protected virtual void UpdateOutputExpressions() { }

        [NonSerialized]
        private bool m_OutputExpressionsUpToDate = false;
        public void UpdateOutputExpressionsIfNeeded()
        {
            if (!m_OutputExpressionsUpToDate)
            {
                UpdateOutputExpressions();
                m_OutputExpressionsUpToDate = true;
            }
        }

        public void MarkOutputExpressionsAsOutOfDate()
        {
            m_OutputExpressionsUpToDate = false;
        }

        public virtual VFXSpace GetOutputSpaceFromSlot(VFXSlot slot)
        {
            return VFXSpace.None;
        }

        public override void CheckGraphBeforeImport()
        {
            // The cache is here to avoid multiple output recomputation when updating the expression graph
            // So It's marked as out of date before compilation just to minimize risk of cache missed invalidation between different compilation
            MarkOutputExpressionsAsOutOfDate(); 
            base.CheckGraphBeforeImport();     
        }

        //[SerializeField]
        HashSet<string> m_expandedPaths = new HashSet<string>();

        [SerializeField]
        List<VFXSlot> m_InputSlots;

        [SerializeField]
        List<VFXSlot> m_OutputSlots;
    }
}