#nullable enable
using System.Diagnostics.CodeAnalysis;
using T3.Core.Animation;
using T3.Core.Operator;
using T3.Core.Operator.Slots;

// ReSharper disable ForCanBeConvertedToForeach

namespace T3.Editor.UiModel.ProjectHandling;

/// <summary>
/// each GraphWindow class should have its own Structure object, and some of this logic should
/// be moved out where applicable (i.e. dealing with packages, selecting root instances, etc.) 
/// </summary>
internal sealed class Structure
{
    private readonly Func<Symbol.Child> _getRootAction;
    
    public Structure(Func<Symbol.Child> getRootAction)
    {
        _getRootAction = getRootAction;
    }

    public Instance? GetRootInstance()
    {
        return GetInstanceFromIdPath([_getRootAction().Id]);
    }
    
    public Instance? GetInstanceFromIdPath(IReadOnlyList<Guid>? childPath)
    {
        if (childPath == null || childPath.Count == 0)
        {
            return null;
        }

        Symbol.Child? rootSymbolChild = _getRootAction();
        if (rootSymbolChild == null)
        {
            Log.Error("Root does not exist? \n" + Environment.StackTrace);
            return null;
        }

        if (childPath[0] != rootSymbolChild.Id)
        {
            //Log.Warning("Can't access instance after root changed.\n" + Environment.StackTrace);
            return null;
        }
        
        var current = rootSymbolChild;
        for (int i = 1; i < childPath.Count; i++)
        {
            if (!current.Symbol.Children.TryGetValue(childPath[i], out current))
            {
                // Commented out, because this frequently happens after deleting pinned Instance
                //Log.Error("Did not find child in path provided.\n" + Environment.StackTrace);
                return null;
            }
        }
        
        _ = current.TryGetOrCreateInstance(childPath, out var instance, out _);
        return instance;
    }

    public List<string> GetReadableInstancePath(IReadOnlyList<Guid>? path, bool includeLeave = true)
    {
        if (path == null || (includeLeave && path.Count == 0) || (!includeLeave && path.Count == 1))
            return ["Path empty"];

        var instance = GetInstanceFromIdPath(path);

        if (instance == null)
            return ["Path invalid"];

        var newList = new List<string>();

        var isFirst = true;

        while (true)
        {
            var parent = instance.Parent;
            if (parent == null)
            {
                break;
            }

            if (!includeLeave && isFirst)
            {
                isFirst = false;
                instance = parent;
                continue;
            }

            isFirst = false;

            var parentSymbolUi = parent.GetSymbolUi();
            var childUisWithThatType = parentSymbolUi.ChildUis.Values
                                                     .Where(c => c.SymbolChild.Symbol == instance.Symbol)
                                                     .ToList();
            var indexLabel = "";

            var symbolUiChild = childUisWithThatType.Single(c => c.Id == instance.SymbolChildId);

            if (childUisWithThatType.Count > 1)
            {
                var index = childUisWithThatType.IndexOf(symbolUiChild);
                indexLabel = $"#{index}";
            }

            var readableNameSuffice = !string.IsNullOrEmpty(symbolUiChild.SymbolChild.Name)
                                          ? $" ({symbolUiChild.SymbolChild.Name})"
                                          : "";

            newList.Insert(0, instance.Symbol.Name + indexLabel + readableNameSuffice);

            instance = parent;
        }

        return newList;
    }

    public static TimeClip? GetCompositionTimeClip(Instance? compositionOp)
    {
        if (compositionOp == null)
        {
            Log.Error("Can't get time clip from null composition op");
            return null;
        }

        foreach (var clipProvider in compositionOp.Outputs.OfType<ITimeClipProvider>())
        {
            return clipProvider.TimeClip;
        }

        return null;
    }

    /// <summary>
    /// This is slow and should be refactored into something else
    /// </summary>
    public static IEnumerable<TimeClip> GetAllTimeClips(Instance compositionOp)
    {
        foreach (var child in compositionOp.Children.Values)
        {
            var outputs = child.Outputs;
            for (var i = 0; i < outputs.Count; i++)
            {
                if (outputs[i] is ITimeClipProvider clipProvider)
                {
                    yield return clipProvider.TimeClip; 
                }
            }
        }
    }

    public static bool TryGetUiAndInstanceInComposition(Guid id,
                                                        Instance compositionOp,
                                                        [NotNullWhen(true)] out SymbolUi.Child? childUi,
                                                        [NotNullWhen(true)] out Instance? instance)
    {
        if (!compositionOp.Children.TryGetChildInstance(id, out instance))
        {
            Log.Warning($"Failed to get instance for {id} in {compositionOp.Symbol.Name}");
            childUi = null;
            return false;
        }
        
        childUi = instance.SymbolChild.GetChildUi();
        return true;
    }

    public static IEnumerable<Symbol> CollectDependingSymbols(Symbol symbol)
    {
        var symbolId = symbol.Id;
        foreach (var s in EditorSymbolPackage.AllSymbols)
        {
            foreach (var child in s.Children.Values)
            {
                if (child.Symbol.Id != symbolId)
                    continue;

                yield return s;
                break;
            }
        }
    }

    internal static HashSet<Guid> CollectConnectedChildren(Symbol.Child child, Symbol compositionSymbol, HashSet<Guid>? set = null)
    {
        set ??= [];

        set.Add(child.Id);
        //var compositionSymbol = composition.Symbol;
        var connectedChildren = (from con in compositionSymbol.Connections
                                 where !con.IsConnectedToSymbolInput && !con.IsConnectedToSymbolOutput
                                 from sourceChild in compositionSymbol.Children.Values
                                 where con.SourceParentOrChildId == sourceChild.Id
                                       && con.TargetParentOrChildId == child.Id
                                 select sourceChild).Distinct().ToArray();

        foreach (var connectedChild in connectedChildren)
        {
            set.Add(connectedChild.Id);
            CollectConnectedChildren(connectedChild, compositionSymbol, set);
        }

        return set;
    }
    
    internal static HashSet<Guid> CollectConnectedChildrenOut(Symbol.Child child, Symbol compositionSymbol, HashSet<Guid>? set = null)
    {
        set ??= [];
        
        set.Add(child.Id);
        var connectedChildren = (from con in compositionSymbol.Connections
                                 where !con.IsConnectedToSymbolInput && !con.IsConnectedToSymbolOutput
                                 from targetChild in compositionSymbol.Children.Values
                                 where (con.SourceParentOrChildId == child.Id
                                       && con.TargetParentOrChildId ==targetChild.Id ) 
                                 select targetChild).Distinct();

        foreach (var connectedChild in connectedChildren)
        {
            set.Add(connectedChild.Id);
            CollectConnectedChildrenOut(connectedChild, compositionSymbol, set);
        }

        return set;
    }
    
    internal static void CollectConnectedChildIds(Symbol compositionSymbol, List<Symbol.Child> selectedChildren, HashSet<Guid>? connectedIds)
    {
        connectedIds ??= [];

        foreach (var selected in selectedChildren)
        {
            connectedIds.Add(selected.Id);
        }
        
        while(true)
        {
            var foundNew = false;
            foreach (var c in compositionSymbol.Connections)
            {
                var connectedInput = !c.IsConnectedToSymbolInput &&  connectedIds.Contains(c.TargetParentOrChildId);
                var connectedOutput = !c.IsConnectedToSymbolOutput &&  connectedIds.Contains(c.SourceParentOrChildId);

                if ((connectedInput || connectedOutput) && (connectedInput != connectedOutput))
                {
                    foundNew |= connectedIds.Add(!connectedInput ? c.TargetParentOrChildId : c.SourceParentOrChildId);
                }
            }

            if (!foundNew)
                break;
        }
    }
    
    
    /// <summary>
    /// Scan all slots required for updating a Slot.
    /// This can be used for invalidation and cycle checking. 
    /// </summary>
    private static HashSet<ISlot> CollectSlotDependencies(ISlot slot, HashSet<ISlot>? all = null)
    {
        all ??= [];

        var stack = new Stack<ISlot>();
        stack.Push(slot);

        while (stack.Count > 0)
        {
            var currentSlot = stack.Pop();

            if (!all.Add(currentSlot))
                continue;

            if (currentSlot.TryGetFirstConnection(out var firstConnection))
            {
                stack.Push(firstConnection);
            }
            else
            {
                var op = currentSlot.Parent;
                var opInputs = op.Inputs;

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

                    // Skip if not connected
                    if (!input.TryGetFirstConnection(out var connectedCompInputSlot))
                        continue;

                    if (input.TryGetAsMultiInput(out var multiInput))
                    {
                        var collectedInputs = multiInput.GetCollectedInputs();
                        for (var j = 0; j < collectedInputs.Count; j++)
                        {
                            stack.Push(collectedInputs[j]);
                        }
                    }
                    else
                    {
                        stack.Push(connectedCompInputSlot);
                    }
                }
            }
        }

        return all;
    }

    /** Returns true if connecting the outputSlot to an input of the op with a symbolChildId would result in a cycle */
    internal static bool CheckForCycle(ISlot outputSlot, Guid targetOpId)
    {
        var linkedSlots = CollectSlotDependencies(outputSlot);
        foreach (var linkedSlot in linkedSlots)
        {
            if (linkedSlot.Parent.SymbolChildId != targetOpId)
                continue;

            return true;
        }

        return false;
    }

    /** Returns true if connecting the outputSlot to an input of the op with a symbolChildId would result in a cycle */
    internal static bool CheckForCycle(Instance sourceInstance, Guid targetOpId)
    {
        var linkedSlots = new HashSet<ISlot>();
        foreach (var inputSlot in sourceInstance.Inputs)
        {
            CollectSlotDependencies(inputSlot, linkedSlots);
        }

        //var linkedSlots = CollectSlotDependencies(outputSlot);
        foreach (var linkedSlot in linkedSlots)
        {
            if (linkedSlot.Parent.SymbolChildId != targetOpId)
                continue;

            return true;
        }

        return false;
    }

    internal static bool CheckForCycle(Symbol compositionSymbol, Symbol.Connection connection)
    {
        var dependingSourceItemIds = new HashSet<Guid>();

        CollectDependentChildren(connection.SourceParentOrChildId);

        return dependingSourceItemIds.Contains(connection.TargetParentOrChildId);

        void CollectDependentChildren(Guid sourceChildId)
        {
            if (sourceChildId == Guid.Empty || !dependingSourceItemIds.Add(sourceChildId))
                return;

            // find all connections into child...
            foreach (var c in compositionSymbol.Connections)
            {
                if (sourceChildId == Guid.Empty || c.TargetParentOrChildId != sourceChildId)
                    continue;

                CollectDependentChildren(c.SourceParentOrChildId);
            }
        }
    }

    public static IEnumerable<Instance> CollectParentInstances(Instance compositionOp)
    {
        var parents = new List<Instance>();
        var op = compositionOp;

        while (op.Parent != null)
        {
            op = op.Parent;
            parents.Insert(0, op);
        }

        return parents;
    }

    public static void PopulateInstancePath(Instance instance, IList<Guid> path)
    {
        path.Insert(0, instance.SymbolChildId);
        var parent = instance.Parent;
        while (parent != null)
        {
            path.Insert(0, parent.SymbolChildId);
            parent = parent.Parent;
        }
    }

    public static bool TryGetInstanceFromPath(IReadOnlyList<Guid> entrySourceIdPath, out Instance? hoveredSourceInstance,
                                              out List<string> readableInstancePath)
    {
        var hasInstancePath = entrySourceIdPath.Count > 0;
        var focusedView = ProjectView.Focused;

        var childIdPath = entrySourceIdPath.ToList();
        hoveredSourceInstance = hasInstancePath && focusedView != null
                                    ? focusedView.Structure.GetInstanceFromIdPath(childIdPath)
                                    : null;

        readableInstancePath = hoveredSourceInstance != null ? focusedView!.Structure.GetReadableInstancePath(childIdPath) : [];
        return hasInstancePath;
    }
}