#nullable enable
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Security.Cryptography;
using T3.Core.Compilation;
using T3.Core.DataTypes;
using T3.Core.Logging;
using T3.Core.Model;
using T3.Core.Operator.Slots;
using T3.Core.Utils;
using Texture2D = T3.Core.DataTypes.Texture2D;

namespace T3.Core.Operator;

public partial class Symbol
{
    /// <summary>
    /// Represents an instance of a <see cref="Symbol"/> within a Symbol.
    /// </summary>
    public sealed class Child
    {
        /// <summary>A reference to the <see cref="Symbol"/> this is an instance from.</summary>
        public Symbol Symbol { get; }

        public Guid Id { get; }

        public Symbol? Parent { get; }

        public string Name { get; set; }

        public string ReadableName => string.IsNullOrEmpty(Name) ? Symbol.Name : Name;
        public bool HasCustomName => !string.IsNullOrEmpty(Name);

        public bool IsBypassed { get => _isBypassed; set => SetBypassed(value); }

        public bool IsDisabled
        {
            get
            {
                // Avoid LINQ because of allocations in inner loop
                foreach (var x in Outputs.Values)
                {
                    if (x.IsDisabled)
                        return true;
                }

                return false;
                //return Outputs.FirstOrDefault().Value?.IsDisabled ?? false;
            }
            set => SetDisabled(value);
        }

        public Dictionary<Guid, Input> Inputs { get; private init; } = new();
        public Dictionary<Guid, Output> Outputs { get; private init; } = new(); 
        internal IEnumerable<Instance> Instances
        {
            get
            {
                lock(_creationLock)
                    return _instancesOfSelf.Values;
            }
        }

        private readonly Dictionary<int, Instance> _instancesOfSelf = [];
        private readonly object _creationLock;
        // ReSharper disable once NotAccessedField.Local
        private readonly bool _isGeneric;

        public Guid? PreviousId { get; private set; }


        internal Child(Symbol symbol, Guid childId, Symbol? parent, string? name, bool isBypassed, object creationLock, Guid? previousId = null)
        {
            _creationLock = creationLock;
            Symbol = symbol;
            Id = childId;
            Parent = parent;
            Name = name ?? string.Empty;
            _isBypassed = isBypassed;
            _isGeneric = symbol.IsGeneric;
            PreviousId = previousId;

            foreach (var inputDefinition in symbol.InputDefinitions)
            {
                if (!Inputs.TryAdd(inputDefinition.Id, new Input(inputDefinition)))
                {
                    throw new ApplicationException($"The ID for symbol input {symbol.Name}.{inputDefinition.Name} must be unique.");
                }
            }

            foreach (var outputDefinition in symbol.OutputDefinitions)
            {
                Symbol.OutputDefinition.TryGetNewOutputDataType(outputDefinition, out var outputData);
                var output = new Output(outputDefinition, outputData) { DirtyFlagTrigger = outputDefinition.DirtyFlagTrigger };
                if (!Outputs.TryAdd(outputDefinition.Id, output))
                {
                    throw new ApplicationException($"The ID for symbol output {symbol.Name}.{outputDefinition.Name} must be unique.");
                }
            }
        }

        private void SetDisabled(bool shouldBeDisabled)
        {
            if (Parent == null)
                return;

            var outputDefinitions = Symbol.OutputDefinitions;

            // Set disabled status on this child's outputs
            foreach (var outputDef in outputDefinitions)
            {
                if (outputDef == null)
                {
                    Log.Warning($"{Symbol.GetType()} {Symbol.Name} contains a null {typeof(Symbol.OutputDefinition)}", Id);
                    continue;
                }

                if (Outputs.TryGetValue(outputDef.Id, out var childOutput))
                {
                    childOutput.IsDisabled = shouldBeDisabled;

                }
                else
                {
                    Log.Warning($"{typeof(Symbol.Child)} {ReadableName} does not have the following child output as defined: " +
                                $"{childOutput?.OutputDefinition.Name}({nameof(Guid)}{childOutput?.OutputDefinition.Id})");
                }
            }

            // Set disabled status on outputs of each instanced copy of this child within all parents that contain it
            foreach (var parentInstance in Parent.InstancesOfSelf)
            {
                // This parent doesn't have an instance of our SymbolChild. Ignoring and continuing.
                if (!parentInstance.Children.TryGetChildInstance(Id, out var matchingChildInstance))
                    continue;

                // Set disabled status on all outputs of each instance
                foreach (var slot in matchingChildInstance.Outputs)
                {
                    slot.IsDisabled = shouldBeDisabled;
                }
            }
        }

        #region sub classes =============================================================
        public sealed class Output
        {
            public Symbol.OutputDefinition OutputDefinition { get; }
            public IOutputData OutputData { get; }

            public bool IsDisabled { get; set; }

            public DirtyFlagTrigger DirtyFlagTrigger
            {
                get => _dirtyFlagTrigger ?? OutputDefinition.DirtyFlagTrigger;
                set => _dirtyFlagTrigger = (value != OutputDefinition.DirtyFlagTrigger) ? (DirtyFlagTrigger?)value : null;
            }

            private DirtyFlagTrigger? _dirtyFlagTrigger = null;

            internal Output(Symbol.OutputDefinition outputDefinition, IOutputData outputData)
            {
                OutputDefinition = outputDefinition;
                OutputData = outputData;
            }

            public Output DeepCopy()
            {
                return new Output(OutputDefinition, OutputData);
            }
        }

        public sealed class Input
        {
            public InputDefinition InputDefinition { get; }
            public Guid Id => InputDefinition.Id;
            public bool IsMultiInput => InputDefinition.IsMultiInput;
            public InputValue DefaultValue => InputDefinition.DefaultValue;

            public string Name => InputDefinition.Name;

            /// <summary>The input value used for this symbol child</summary>
            public InputValue Value { get; }

            public bool IsDefault { get; set; }

            public Input(Symbol.InputDefinition inputDefinition)
            {
                InputDefinition = inputDefinition;
                Value = DefaultValue.Clone();
                IsDefault = true;
            }

            public void SetCurrentValueAsDefault()
            {
                if (DefaultValue.IsEditableInputReferenceType)
                {
                    DefaultValue.AssignClone(Value);
                }
                else
                {
                    DefaultValue.Assign(Value);
                }

                IsDefault = true;
            }

            public void ResetToDefault()
            {
                if (DefaultValue.IsEditableInputReferenceType)
                {
                    Value.AssignClone(DefaultValue);
                }
                else
                {
                    Value.Assign(DefaultValue);
                }

                IsDefault = true;
            }
        }
        #endregion
        
        #region Bypass

        private bool _isBypassed;

        public bool IsBypassable()
        {
            if (Symbol.OutputDefinitions.Count == 0)
                return false;

            if (Symbol.InputDefinitions.Count == 0)
                return false;

            var mainInput = Symbol.InputDefinitions[0];
            var mainOutput = Symbol.OutputDefinitions[0];

            var defaultValueType = mainInput.DefaultValue.ValueType;
            if (defaultValueType != mainOutput.ValueType)
                return false;

            return _bypassableTypes.Contains(defaultValueType);
        }
        
        private static readonly Type[] _bypassableTypes =
        {
            typeof(Command),
            typeof(Texture2D),
            typeof(BufferWithViews),
            typeof(MeshBuffers),
            typeof(float),
            typeof(Vector2),
            typeof(Vector3),
            typeof(string),
            typeof(ShaderGraphNode)
        };

        private void SetBypassed(bool shouldBypass)
        {
            if (shouldBypass == _isBypassed)
                return;

            if (!IsBypassable())
                return;

            if (Parent == null)
            {
                // Clarify: shouldn't this be shouldBypass?
                _isBypassed = shouldBypass; // during loading parents are not yet assigned. This flag will later be used when creating instances
                return;
            }

            lock (_creationLock)
            {
                if (_instancesOfSelf.Count == 0)
                {
                    _isBypassed = shouldBypass; // while duplicating / cloning as new symbol there are no instances yet.
                    return;
                }
            }

            // check if there is a connection
            var isOutputConnected = false;
            var mainOutputDef = Symbol.OutputDefinitions[0];
            foreach (var connection in Parent.Connections)
            {
                if (connection.SourceSlotId != mainOutputDef.Id || connection.SourceParentOrChildId != Id)
                    continue;

                isOutputConnected = true;
                break;
            }

            if (!isOutputConnected)
                return;

            var id = Id;
            foreach (var parentInstance in Parent.InstancesOfSelf)
            {
                var instance = parentInstance.Children[id];
                Instance.SetBypassFor(instance, shouldBypass);
            }

            _isBypassed = shouldBypass;
        }
        
        #endregion Bypass

        public override string ToString()
        {
            return Parent?.Name + ">" + ReadableName;
        }

        internal static unsafe Guid CreateIdDeterministically(Symbol symbol, Symbol? parent, Guid? extra = null)
        {
            //deterministically create a new guid from the symbol id
            using var hashComputer = IncrementalHash.CreateHash(HashAlgorithmName.SHA1);
            var symbolId = symbol.Id;
            var symbolIdBytes = new ReadOnlySpan<byte>(&symbolId, 16);
            hashComputer.AppendData(symbolIdBytes);

            if (parent != null)
            {
                var parentId = parent.Id;
                var parentIdBytes = new ReadOnlySpan<byte>(&parentId, 16);
                hashComputer.AppendData(parentIdBytes);
            }

            if (extra != null)
            {
                var val = extra.Value;
                var bytes = new ReadOnlySpan<byte>(&val, 16);
                hashComputer.AppendData(bytes);
            }

            // SHA1 is 20 bytes long, but we only need 16 bytes for a guid
            var newGuidBytes = new ReadOnlySpan<byte>(hashComputer.GetHashAndReset(), 0, 16);
            return new Guid(newGuidBytes);
        }

        internal void RemoveChildInstancesOf(Child child)
        {
            var idToDestroy = child.Id;
            lock (_creationLock)
            {
                foreach (var instance in _instancesOfSelf.Values)
                {
                    //var instance = instanceKvp.Value;
                    if (instance.Children.TryGetChildInstance(idToDestroy, out var childInstance, false))
                    {
                        childInstance.DisposePackage(null);
                    }
                }
            }
        }

        private void DestroyAndClearAllInstances(SymbolPackage? onlyDisposeInPackage)
        {
            lock (_creationLock)
            {
                var allInstances = _instancesOfSelf.Values.ToArray();
                for (int i = allInstances.Length - 1; i >= 0; i--)
                {
                    allInstances[i].DisposePackage(onlyDisposeInPackage); // removes self from _instancesOfSelf dict
                }
                
                Debug.Assert(_instancesOfSelf.Count == 0, $"All instances of {Symbol.Name} should have been disposed, but {_instancesOfSelf.Count} remain.");
            }
        }

        internal void Dispose()
        {
            DestroyAndClearAllInstances(null);
            lock (_creationLock)
            {
                var removed = Symbol._childrenCreatedFromMe.Remove(Id, out _);
                Debug.Assert(removed);
            }
        }

        internal void AddChildInstances(Child newChild, ICollection<Instance> listToAddNewInstancesTo)
        {
            lock (_creationLock)
            {
                foreach (var instance in _instancesOfSelf.Values)
                {
                    var path = instance.InstancePath.Append(newChild.Id).ToArray();
                    if (newChild.TryGetOrCreateInstance(path, out var newInstance, out var created, true))
                    {
                        if (created)
                        {
                            listToAddNewInstancesTo.Add(newInstance);
                        }
                    }
                }
            }
        }

        internal bool UpdateIOAndConnections(SlotChangeInfo slotChanges)
        {
            UpdateSymbolChildIO(this, slotChanges);

            if (Parent == null)
            { 
                DestroyAndClearAllInstances(Symbol.SymbolPackage);
                // just destroy all instances - we have no connections to worry about since we dont have a parent
                return false;
            }

            // we dont need to update our instances/connections - our parents do that for us if they need it
            if (Parent.NeedsTypeUpdate && Parent.SymbolPackage == Symbol.SymbolPackage)
            {
                // destroy all instances if necessary? probably not...
                //DestroyAndClearAllInstances();
                return false;
            }

            // deal with removed connections
            var parentConnections = Parent!.Connections;
            // get all connections that belong to this instance
            var connectionsToReplace = parentConnections.FindAll(c => c.SourceParentOrChildId == Id ||
                                                                      c.TargetParentOrChildId == Id);

            // first remove those connections where the inputs/outputs doesn't exist anymore
            var connectionsToRemove =
                connectionsToReplace.FindAll(c =>
                                             {
                                                 return slotChanges.RemovedOutputDefinitions.Any(output =>
                                                                                                 {
                                                                                                     var outputId = output.Id;
                                                                                                     return outputId == c.SourceSlotId ||
                                                                                                         outputId == c.TargetSlotId;
                                                                                                 })
                                                        || slotChanges.RemovedInputDefinitions.Any(input =>
                                                                                                   {
                                                                                                       var inputId = input.Id;
                                                                                                       return inputId == c.SourceSlotId ||
                                                                                                           inputId == c.TargetSlotId;
                                                                                                   });
                                             });

            foreach (var connection in connectionsToRemove)
            {
                Parent.RemoveConnection(connection); // TODO: clarify if we need to iterate over all multi input indices
                connectionsToReplace.Remove(connection);
            }

            // now create the entries for those that will be reconnected after the instance has been replaced. Take care of the multi input order
            //connectionsToReplace.Reverse();

            foreach (var con in connectionsToReplace)
            {
                Parent.ReplaceConnection(con);
            }
            
            return false;
        }

        private bool TryCreateNewInstance(Instance? parentInstance,
                                           [NotNullWhen(true)] out Instance? newInstance)
        {
            var path = parentInstance == null ? [Id] : parentInstance.InstancePath.Append(Id).ToArray();
            var parent = parentInstance?.SymbolChild;
            var pathHash = HashCodeOf(path);
            lock (_creationLock)
            {
                if (_instancesOfSelf.TryGetValue(pathHash, out newInstance))
                {
                    // instance already exists
                    //return true;
                    throw new InvalidOperationException($"Instance {Name} with id ({Id}) already exists at path {string.Join(" > ", path)}");
                }

                if (!TryCreateAndConnectInstance(parent, parentInstance, path, out newInstance, out var reason))
                {
                    Log.Error(reason);
                    return false;
                }
                
            }

            return true;

            bool TryCreateAndConnectInstance(Symbol.Child? parentSymbolChild, Instance? parentInst, Guid[] newInstancePath,
                                   [NotNullWhen(true)] out Instance? newInstance,
                                   [NotNullWhen(false)] out string? reason2)
            {
                if(parentSymbolChild != null)
                {
                    if(parentSymbolChild.Symbol != Parent)
                    {
                        throw new InvalidOperationException($"Parent symbol {parentSymbolChild.Symbol} does not match {Symbol}");
                    }
                    
                    if (newInstancePath[^2] != parentSymbolChild.Id)
                    {
                        throw new InvalidOperationException($"Instance path does not match parent id {parentSymbolChild.Id}");
                    }
                }
                else
                {
                    if(Parent != null)
                        throw new InvalidOperationException("symbol child has no parent but parent instance provided is not null");
                }

                // make sure we're not instantiating a child that needs to be updated again later
                //Symbol.UpdateInstanceType();

                if (!TryInstantiate(out newInstance, out reason2))
                {
                    Log.Error(reason2);
                    return false;
                }
                
                if (!_instancesOfSelf.TryAdd(pathHash, newInstance))
                {
                    throw new InvalidOperationException("Attempted to create a new instance when one already exists at that path");
                }
                
                newInstance.SetSymbolInfo(this, parentSymbolChild, newInstancePath, pathHash);
                newInstance.Initialize(parentInst);
                
                // cache property accesses for performance
                var newInstanceInputDefinitions = Symbol.InputDefinitions;
                var newInstanceInputDefinitionCount = newInstanceInputDefinitions.Count;

                var newInstanceInputs = newInstance.Inputs;
                var newInstanceInputCount = newInstanceInputs.Count;

                var symbolChildInputs = Inputs;

                // set up the inputs for the child instance
                for (int i = 0; i < newInstanceInputDefinitionCount; i++)
                {
                    if (i >= newInstanceInputCount)
                    {
                        Log.Warning($"Skipping undefined input index");
                        continue;
                    }

                    var inputDefinitionId = newInstanceInputDefinitions[i].Id;
                    var inputSlot = newInstanceInputs[i];
                    if (!symbolChildInputs.TryGetValue(inputDefinitionId, out var input))
                    {
                        Log.Warning($"Skipping undefined input: {inputDefinitionId}");
                        continue;
                    }

                    inputSlot.Input = input;
                    inputSlot.Id = inputDefinitionId;
                }

                // cache property accesses for performance
                var childOutputDefinitions = Symbol.OutputDefinitions;
                var childOutputDefinitionCount = childOutputDefinitions.Count;

                var childOutputs = newInstance.Outputs;

                var symbolChildOutputs = Outputs;

                // set up the outputs for the child instance
                for (int i = 0; i < childOutputDefinitionCount; i++)
                {
                    Debug.Assert(i < childOutputs.Count);
                    var outputDefinition = childOutputDefinitions[i];
                    var id = outputDefinition.Id;
                    if (i >= childOutputs.Count)
                    {
                        Log.Warning($"Skipping undefined output: {id}");
                        continue;
                    }

                    var outputSlot = childOutputs[i];
                    outputSlot.Id = id;
                    var symbolChildOutput = symbolChildOutputs[id];
                    if (outputDefinition.OutputDataType != null)
                    {
                        // output is using data, so link it
                        if (outputSlot is IOutputDataUser outputDataConsumer)
                        {
                            outputDataConsumer.SetOutputData(symbolChildOutput.OutputData);
                        }
                    }

                    outputSlot.DirtyFlag.Trigger = symbolChildOutput.DirtyFlagTrigger;
                    outputSlot.IsDisabled = symbolChildOutput.IsDisabled;
                }

                return true;

                bool TryInstantiate([NotNullWhen(true)] out Instance? instance,
                                    [NotNullWhen(false)] out string? reason3)
                {
                    if (Symbol.SymbolPackage.AssemblyInformation.OperatorTypeInfo.TryGetValue(Symbol.Id, out var typeInfo))
                    {
                        var constructor = typeInfo.GetConstructor();
                        try
                        {
                            instance = (Instance)constructor.Invoke();
                            reason3 = string.Empty;
                            return true;
                        }
                        catch (Exception e)
                        {
                            reason3 = $"Failed to create instance of type {Symbol.InstanceType} with id {Id}: {e}";
                            instance = null;
                            return false;
                        }
                    }

                    Log.Error($"No constructor found for {Symbol.InstanceType}. This should never happen!! Please report this");

                    try
                    {
                        // create instance through reflection
                        instance = Activator.CreateInstance(Symbol.InstanceType,
                                                            AssemblyInformation.ConstructorBindingFlags,
                                                            binder: null,
                                                            args: Array.Empty<object>(),
                                                            culture: null) as Instance;

                        if (instance is null)
                        {
                            reason3 = $"(Instance creation fallback failure) Failed to create instance of type " +
                                      $"{Symbol.InstanceType} with id {Id} - result was null";
                            return false;
                        }

                        Log.Warning($"(Instance creation fallback) Created instance of type {Symbol.InstanceType} with id {Id} through reflection");

                        reason3 = string.Empty;
                        return true;
                    }
                    catch (Exception e)
                    {
                        reason3 = $"(Instance creation fallback failure) Failed to create instance of type {Symbol.InstanceType} with id {Id}: {e}";
                        instance = null;
                        return false;
                    }
                }
            }
        }

        internal void AddConnectionToInstances(Connection connection, int multiInputIndex, bool allowCreate)
        {
            lock (_creationLock)
            {
                foreach (var instance in _instancesOfSelf.Values)
                        {
                    instance.TryAddConnection(connection, multiInputIndex, allowCreate);
                }
            }
        }

        internal void RemoveConnectionFromInstances(Connection connection, int multiInputIndex)
        {
            lock (_creationLock)
            {
                foreach (var instance in _instancesOfSelf.Values)
                {
                    if (instance.TryGetTargetSlot(connection, out var targetSlot, false))
                    {
                        targetSlot.RemoveConnection(multiInputIndex);
                        // Ensure reconnect/replace operations always propagate dirtiness,
                        // even when the slot still has other connections (e.g. multi-input replace).
                        targetSlot.InvalidateGraph();
                    }
                }
            }
        }

        internal void InvalidateInputDefaultInInstances(in Guid inputId)
        {
            lock (_creationLock)
            {
                foreach (var instance in _instancesOfSelf.Values)
                {
                    var inputSlots = instance.Inputs;
                    for (int i = 0; i < inputSlots.Count; i++)
                    {
                        var slot = inputSlots[i];
                        if (slot.Id != inputId)
                            continue;

                        if (!slot.Input.IsDefault)
                            continue;

                        slot.DirtyFlag.Invalidate();
                        break;
                    }
                }
            }
        }

        internal void InvalidateInputInChildren(in Guid inputId, in Guid childId)
        {
            lock (_creationLock)
            {
                foreach (var instanceInfo in _instancesOfSelf)
                {
                    var instance = instanceInfo.Value;
                    
                    //var child = instance.Children[childId];
                    if (!instance.Children.TryGetChildInstance(childId, out var child))
                    {
                        Log.Debug("Failed to invalidate missing child");
                        continue;
                    }

                    var inputSlots = child.Inputs;
                    for (int j = 0; j < inputSlots.Count; j++)
                    {
                        var slot = inputSlots[j];
                        if (slot.Id != inputId)
                            continue;

                        slot.DirtyFlag.Invalidate();
                        break;
                    }
                }
            }
        }

        internal void SortInputSlotsByDefinitionOrder()
        {
            lock (_creationLock)
            {
                foreach (var instance in _instancesOfSelf.Values)
                {
                    Instance.SortInputSlotsByDefinitionOrder(instance);
                }
            }
        }

        internal void RemoveDisposedInstance(Instance child, int hash)
        {
            lock (_creationLock)
            {
                if (!_instancesOfSelf.Remove(hash))
                {
                    Log.Error($"Could not find instance {child} to remove from {this}");
                }
            }
        }

        internal void PrepareForReload()
        {
            DestroyAndClearAllInstances(Symbol.SymbolPackage);
        }

        public bool TryGetOrCreateInstance(IReadOnlyList<Guid> path, [NotNullWhen(true)] out Instance? instance, out bool created, bool allowCreate = true)
        {
            // throw exceptions if the path is invalid
            if (path.Count == 0)
            {
                throw new ArgumentException("Path must not be empty");
            }
            
            if(!path[^1].Equals(Id))
            {
                throw new ArgumentException($"Path must end with {Id}");
            }

            if (Parent == null)
            {
                if(path.Count != 1)
                    throw new ArgumentException("Path must be of length 1 if parent is null");
                
                if(path[0] != Id)
                    throw new ArgumentException($"Path must be {Id} if parent is null");
            }
            else if (path.Count < 2)
            {
                throw new ArgumentException("Path must be of length 2 or more if parent is not null");
            }
            
            var hash = HashCodeOf(path);

            lock (_creationLock)
            {
                if (_instancesOfSelf.TryGetValue(hash, out instance))
                {
                    // instance already exists
                    created = false;

                    if (allowCreate)
                    {
                        if (instance.TryGetParentInstance(out var parent, allowCreate) && parent is { NeedsInternalReconnections: true, Initialized: true })
                        {
                            parent.ReconnectChildren();
                        }
                        else if (instance.NeedsInternalReconnections && allowCreate)
                        {
                            instance.ReconnectChildren();
                        }
                    }

                    return true;
                }
                
                if(!allowCreate)
                {
                    created = false;
                    return false;
                }

                if (Parent == null)
                {
                    created = TryCreateNewInstance(null, out instance);
                    return created;
                }

                if (TryGetParentInstance(path, out created, out var parentInstance))
                {
                    // try to get our instance straight from the parent
                    if (!parentInstance.Children.TryGetChildInstance(Id, out instance, false))
                    {
                        // since we dont exist yet, lets create us
                        created = TryCreateNewInstance(parentInstance, out instance);
                        return created;
                    }

                    // if we're here, we already exist in the parent instance
                    // we just need to make sure we add our instance to our own collection
                    if (!_instancesOfSelf.ContainsKey(hash))
                    {
                        // Synchronization issue detected: instance exists in parent but not in our tracking
                        // This can happen during complex initialization or reload scenarios
                        Log.Warning($"Instance {ReadableName} found in parent but missing from child tracking. Resyncing.");
                        _instancesOfSelf[hash] = instance;
                    }
                    
                    created = false;
                    return true;
                }
            }

            created = false;
            return false;

            bool GetParentAsChild(IReadOnlyList<Guid> readOnlyList, [NotNullWhen(true)] out Child? child)
            {
                var parentSymbolChildId = readOnlyList[^2];
                return Parent.ChildrenCreatedFromMe.TryGetValue(parentSymbolChildId, out child);
            }

            bool TryGetParentInstance(IReadOnlyList<Guid> guids, out bool wasCreated, [NotNullWhen(true)] out Instance? parentInstance)
            {
                if (!GetParentAsChild(guids, out var parentSymbolChild))
                {
                    parentInstance = null;
                    wasCreated = false;
                    return false;
                }
                //var parentSymbolChild = GetParentAsChild(guids);
                var parentPath = guids.SkipLast(1).ToArray();
                var gotParent = parentSymbolChild.TryGetOrCreateInstance(parentPath, out parentInstance, out wasCreated);
                return gotParent;
            }

            // TODO: No longer needed?
            // void EnsureInstanceSlotsAreConnected(IReadOnlyList<Guid> instancePath, Instance existingInstance)
            // {
            //     if (existingInstance is { NeedsInternalReconnections: true })
            //     {
            //         existingInstance.ReconnectChildren();
            //     }
            //
            //     if (Parent is null)
            //     {
            //         // if we have no parent we have no connections to reconnect
            //         return;
            //     }
            //     
            //     if(TryGetParentInstance(instancePath, out var wasCreated, out var parent))
            //     {
            //         if (wasCreated)
            //         {
            //             // if the parent was just created via this invocation, then this instance should have been marked as not needing reconnections
            //             // so we can skip this
            //             Log.Debug("Recreated parent instance from child reference", parent);
            //             Debug.Assert(!existingInstance.NeedsInternalReconnections);
            //             return;
            //         }
            //         
            //         if (parent.NeedsInternalReconnections)
            //         {
            //             parent.ReconnectChildren();
            //             Log.Debug("Regenerated connections for parent", parent);
            //         }
            //     }
            //     else 
            //     {
            //         Log.Error("Instance needs reconnections but parent is null - this probably shouldn't happen", existingInstance);
            //     }
            // }
        }
        

        public static int HashCodeOf(IReadOnlyList<Guid> path)
        {
            int hash = path[0].GetHashCode();
            for (int i = 1; i < path.Count; i++)
            {
                hash = HashCode.Combine(hash, path[i].GetHashCode());
            }
            return hash;
        }

        public void ClearPreviousId()
        {
            PreviousId = null;
        }

  

        public bool SearchForChild(Guid search, [NotNullWhen(true)] out Child? child, [NotNullWhen(true)] out IReadOnlyList<Guid>? path)
        {
            return SearchForChild(search, ReadOnlySpan<Guid>.Empty, out child, out path);
        }

        private bool SearchForChild(Guid search, ReadOnlySpan<Guid> path, out Child? child, [NotNullWhen(true)] out IReadOnlyList<Guid>? fullPath)
        {
            Span<Guid> pathIncludingMe = stackalloc Guid[path.Length + 1];
            path.CopyTo(pathIncludingMe);
            pathIncludingMe[^1] = Id;
            if (Id == search)
            {
                child = this;
                fullPath = pathIncludingMe.ToArray();
                return true;
            }

            var symbol = Symbol;
            foreach (var symbolChild in symbol.Children.Values)
            {
                if(symbolChild.SearchForChild(search, pathIncludingMe, out var foundChild, out var foundPath))
                {
                    child = foundChild;
                    fullPath = foundPath;
                    return true;
                }
            }
            
            child = null;
            fullPath = null;
            return false;
        }

        internal void ReconnectAllChildren()
        {
            lock (_creationLock)
            {
                foreach (var inst in _instancesOfSelf.Values)
                {
                    inst.ReconnectChildren();
                }
            }
        }
        
        /// <summary>
        /// Disposes all live instances of this child (releasing native/GPU resources).
        /// </summary>
        /// <remarks>
        /// Use only when the child is being removed or the parent is reloaded. This is immediate and irreversible; prefer reconnecting to preserve instance state.
        /// </remarks>
        public void DestroyAllInstances()
        {
            lock (_creationLock)
            {
                // toArray as a defensive copy - these instances will be removed from the dictionary as a result of calling this func
                foreach(var instance in _instancesOfSelf.Values.ToArray())
                {
                    instance.DisposePackage(null);
                }
            }
        }
    }
}