using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine.Graphing;

namespace UnityEngine.MaterialGraph
{
    public interface INodeGroupRemapper
    {
        void DepthFirstCollectNodesFromNodeSlotList(List<INode> nodeList, NodeUtils.IncludeSelf includeSelf);
        bool IsValidSlotConnection(int id);
    }

    /*   [Serializable]
       public class MasterRemapGraph : AbstractMaterialGraph
       {
           [NonSerialized]
           private MasterRemapInputNode m_InputNode;

           public MasterRemapInputNode inputNode
           {
               get
               {
                   // find existing node
                   if (m_InputNode == null)
                       m_InputNode = GetNodes<MasterRemapInputNode>().FirstOrDefault();

                   return m_InputNode;
               }
           }

           public override void OnAfterDeserialize()
           {
               base.OnAfterDeserialize();
               m_InputNode = null;
           }

           public override void AddNode(INode node)
           {
               if (inputNode != null && node is MasterRemapInputNode)
               {
                   Debug.LogWarning("Attempting to add second SubGraphInputNode to SubGraph. This is not allowed.");
                   return;
               }

               var materialNode = node as AbstractMaterialNode;
               if (materialNode != null)
               {
                   var amn = materialNode;
                   if (!amn.allowedInRemapGraph)
                   {
                       Debug.LogWarningFormat("Attempting to add {0} to Remap Graph. This is not allowed.", amn.GetType());
                       return;
                   }
               }
               base.AddNode(node);
           }

           struct DisposeMeh : IDisposable
           {
               private readonly MasterRemapInputNode m_Graph;

               public DisposeMeh(MasterRemapInputNode graph, RemapMasterNode master)
               {
                   m_Graph = graph;
                   graph.m_RemapTarget = master;
               }

               public void Dispose()
               {
                   m_Graph.m_RemapTarget = null;
               }
           }

           public List<string> GetSubShadersFor(RemapMasterNode rmn, GenerationMode mode, PropertyGenerator shaderPropertiesVisitor)
           {
               var subShaders = new List<string>();
               try
               {
                   using (new DisposeMeh(inputNode, rmn))
                   {
                       foreach (var node in GetNodes<IMasterNode>())
                           subShaders.Add(node.GetSubShader(mode, shaderPropertiesVisitor));
                   }
               }
               catch (Exception e)
               {
                   Debug.LogException(e);
               }
               return subShaders;
           }

           public void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
           {
               foreach (var node in GetNodes<AbstractMaterialNode>())
                   node.CollectPreviewMaterialProperties(properties);
           }

       }*/
}