using NodeDev.Core.Connections;

using NodeDev.Core.NodeDecorations;

using NodeDev.Core.Types;

using System.Linq.Expressions;

namespace NodeDev.Core.Nodes

{

[System.Diagnostics.DebuggerDisplay("{Name}. Inputs: {Inputs.Count}. Outputs: {Outputs.Count}")]

public abstract class Node

{

public Node(Graph graph, string? id = null)

{

Graph = graph;

Id = id ?? (Guid.NewGuid().ToString());

}

public string Id { get; }

public virtual string Name { get; set; } = "";

public virtual bool AllowEditingName { get; } = false;

public Graph Graph { get; }

public abstract string TitleColor { get; }

public List<Connection> Inputs { get; } = [];

public List<Connection> Outputs { get; } = [];

public IEnumerable<Connection> InputsAndOutputs => Inputs.Concat(Outputs);

public abstract bool IsFlowNode { get; }

public TypeFactory TypeFactory => Project.TypeFactory;

public Project Project => Graph.SelfClass.Project;

public virtual bool FetchState => false;

public virtual bool ReOrderExecInputsAndOutputs => true;

public bool CanBeInlined => !InputsAndOutputs.Any(x => x.Type.IsExec);

/// <summary>

/// True to allow remerging exec connection together later in the graph.

/// This is used by nodes that have multiple exec outputs such as Branch, Loop, etc.

/// If the value is false, such as for Loop, each exec output has to be a separate path.

/// Ex, for ForEach node the value is false since "Loop Exec" path cannot have shared path with the "ExecOut" path.

/// </summary>

public virtual bool AllowRemergingExecConnections => true;

/// <summary>

/// Global index of this node in the graph. Each node in a graph has a unique index.

/// </summary>

public int GraphIndex { get; set; } = -1;

public virtual IEnumerable<string> GetUndefinedGenericTypes() => InputsAndOutputs.SelectMany(x => x.Type.GetUndefinedGenericTypes()).Distinct();

/// <summary>

/// Called before the generic type are set on every connections

/// </summary>

public virtual void OnBeforeGenericTypeDefined(IReadOnlyDictionary<string, TypeBase> changedGenerics) { }

public record class AlternateOverload(TypeBase ReturnType, List<IMethodParameterInfo> Parameters);

public virtual IEnumerable<AlternateOverload> AlternatesOverloads => [];

/// <summary>

/// Triggered when the generic type of the connection has been defined (found and applied already).

/// </summary>

/// <param name="connection">The connection that was generic, it is not generic anymore</param>

/// <returns>Returns a list of changed connections, if any.</returns>

public virtual List<Connection> GenericConnectionTypeDefined(Connection connection)

{

return [];

}

public virtual void SelectOverload(AlternateOverload overload, out List<Connection> newConnections, out List<Connection> removedConnections)

{

throw new NotImplementedException();

}

internal virtual Expression BuildExpression(Dictionary<Connection, Graph.NodePathChunks>? subChunks, BuildExpressionInfo info) => throw new NotImplementedException();

internal virtual void BuildInlineExpression(BuildExpressionInfo info) => throw new NotImplementedException();

/// <summary>

/// Create an Expression node that can be used in the graph.

/// Ie, the "Add" node will have two local variables, one for each input, and one output local variable.

/// In C#, that would look like doing :

/// var input1 = ..., input2 = ...; // ... would be replaced by the output local variable of the previous node

/// var output = input1 + input2;

///

/// This will ignore the exec connections.

/// </summary>

internal virtual IEnumerable<(Connection Connection, ParameterExpression LocalVariable)> CreateOutputsLocalVariableExpressions(BuildExpressionInfo info)

{

foreach (var output in Outputs)

{

if (output.Type.IsExec)

continue;

var variable = Expression.Variable(output.Type.MakeRealType(), $"{Name}_{output.Name}"

.Replace(" ", string.Empty)

.Replace(".", string.Empty)

.Replace("<", string.Empty)

.Replace(">", string.Empty));

yield return (output, variable);

}

}

#region Path merging / Crossing examinations

public abstract string GetExecOutputPathId(string pathId, Connection execOutput);

public abstract bool DoesOutputPathAllowDeadEnd(Connection execOutput);

public abstract bool DoesOutputPathAllowMerge(Connection execOutput);

/// <summary>

/// Returns true if this node breaks a dead end. These are usually "Return", "Break", "Continue", etc.

/// This will allow a dead end in places where it shouldn't be allowed, such as a "Branch" node.

/// </summary>

public virtual bool BreaksDeadEnd => false;

public class InfiniteLoopException(Node node) : Exception

{

public Node Node { get; } = node;

}

/// <summary>

/// Returns all the possible execution path from this node.

/// I know, I know. All of this is slow.

/// </summary>

public NodePaths SearchAllExecPaths(HashSet<Node> nodesBefore)

{

if (nodesBefore.Contains(this))

throw new InfiniteLoopException(this);

var execOutputs = Outputs.Where(x => x.Type.IsExec).ToList();

if (execOutputs.Count == 0)

return new();

// Prevent any children path from looping back to us

nodesBefore.Add(this);

var allPaths = new NodePaths();

foreach (var execOutput in execOutputs)

{

// Create a copy of the nodes already used since each execOutput can possibly hit the same nodes without it being an issue

var nodesBefore_local = new HashSet<Node>(nodesBefore);

var subPaths = SearchAllExecPaths(execOutput, nodesBefore_local);

if (subPaths.CountPossiblePaths != 0) // it led somewhere

{

// Add the execOutput to the beginning of each path

subPaths.PrependPath(new([execOutput]));

}

else // it led nowhere, the path is just the execOutput and that's it

subPaths.AddNewIndependantBranch(new NodePath([execOutput]));

allPaths.AddNewIndependantBranch(subPaths);

}

return allPaths;

}

/// <summary>

/// List all the possible path taken from the output exec connection.

/// </summary>

private static NodePaths SearchAllExecPaths(Connection outputExec, HashSet<Node> alreadySeenNodes)

{

if (outputExec.Connections.Count == 0)

return new(); // we're connected to nothing

// If we are going through NormalFlowNodes, we can simply accumulate the connections one after the other

// Then, we multiple paths offers, we can search those paths and Prepend the straightConnections to them

var straightConnections = new NodePath();

var inputExec = outputExec.Connections.FirstOrDefault();

while (inputExec != null)

{

var otherNode = inputExec.Parent;

if (otherNode is NormalFlowNode)

{

alreadySeenNodes.Add(otherNode); // used to prevent any children path from looping back to us

var otherExec = otherNode.Outputs.Single(x => x.Type.IsExec);

straightConnections.AppendPath(otherExec);

inputExec = otherExec.Connections.FirstOrDefault();

}

else

{

// We've hit a possible separation in the paths we can follow

// We can recursively start a search again.

// There is no need to add the current node to the alreadySeenNodes since the SearchAllExecPaths will do it for us

var allSubPaths = otherNode.SearchAllExecPaths(alreadySeenNodes);

// Append each path returned to the straightConnections

allSubPaths.PrependPath(straightConnections);

return allSubPaths;

}

}

// if we're here, it means we never hit any branching of paths, we can return a single path possible

if (straightConnections.Length == 0)

return new(); // we're connected to nothing

else

return new NodePaths(straightConnections);

}

#endregion

#region Decorations

public Dictionary<Type, INodeDecoration> Decorations { get; init; } = [];

public void AddDecoration<T>(T attribute) where T : INodeDecoration => Decorations[typeof(T)] = attribute;

public T GetOrAddDecoration<T>(Func<T> creator) where T : INodeDecoration

{

if (Decorations.TryGetValue(typeof(T), out var decoration))

return (T)decoration;

var v = creator();

Decorations[typeof(T)] = v;

return v;

}

#endregion

#region Serialization

public record SerializedNode(string Type, string Id, string Name, List<Connection.SerializedConnection> Inputs, List<Connection.SerializedConnection> Outputs, Dictionary<string, string> Decorations);

internal SerializedNode Serialize()

{

var serializedNode = new SerializedNode(GetType().FullName!, Id, Name, Inputs.Select(x => x.Serialize()).ToList(), Outputs.Select(x => x.Serialize()).ToList(), Decorations.ToDictionary(x => x.Key.FullName!, x => x.Value.Serialize()));

return serializedNode;

}

internal static Node Deserialize(Graph graph, SerializedNode serializedNodeObj)

{

var type = TypeFactory.GetTypeByFullName(serializedNodeObj.Type) ?? throw new Exception($"Unable to find type: {serializedNodeObj.Type}");

var node = (Node?)Activator.CreateInstance(type, graph, serializedNodeObj.Id) ?? throw new Exception($"Unable to create instance of type: {serializedNodeObj.Type}");

foreach (var decoration in serializedNodeObj.Decorations)

{

var decorationType = TypeFactory.GetTypeByFullName(decoration.Key) ?? throw new Exception($"Unable to find type: {decoration.Key}");

var method = decorationType.GetMethod(nameof(INodeDecoration.Deserialize), System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static);

if (method == null)

throw new Exception($"Unable to find Deserialize method on type: {decoration.Key}");

if (method.Invoke(null, [graph.SelfClass.TypeFactory, decoration.Value]) is not INodeDecoration decorationObj)

throw new Exception($"Unable to deserialize decoration: {decoration.Key}");

node.Decorations[decorationType] = decorationObj;

}

node.Deserialize(serializedNodeObj);

return node;

}

protected virtual void Deserialize(SerializedNode serializedNodeObj)

{

Inputs.Clear();

Outputs.Clear();

Name = serializedNodeObj.Name;

foreach (var input in serializedNodeObj.Inputs)

{

var connection = Connection.Deserialize(this, input, true);

Inputs.Add(connection);

}

foreach (var output in serializedNodeObj.Outputs)

{

var connection = Connection.Deserialize(this, output, false);

Outputs.Add(connection);

}

}

#endregion

}

}