namespace Nodebox;

public partial class Node {
    public class Serializable {
        public Serializable() { }

        [JsonInclude]
        [Property]
        public SerializableType SerializableType { get; set; } = null;

        [JsonIgnore]
        [Hide]
        public Type Type => SerializableType?.Type;

        [JsonInclude]
        [Property]
        public (List<Pin> Input, List<Pin> Output)? Pins { get; set; } = null;

        [JsonInclude]
        [Property]
        [Hide]
        public List<SerializableObject> Inputs { get; set; } = [];

        public Dictionary<string, SerializableObject> Properties { get; set; } = [];

        public static Serializable From<T>(List<object> inputs = null, Dictionary<string, object> properties = null)
            where T : Node =>
            new() {
                SerializableType = typeof(T),
                Pins = GetInitialPins<T>(),
                Inputs = inputs?.Select(x => new SerializableObject(x))?.ToList() ?? [],
                Properties = properties?.Select(x => (x.Key, new SerializableObject(x.Value)))?.ToDictionary() ?? [],
            };

        public Node Create() {
            var node = SerializableType.Create<Node>();

            if (Pins.HasValue) {
                // Log.Info(Pins.Value.Input.Count);
                node.SetPins((Pins.Value.Input, Pins.Value.Output));
            }

            foreach (var pair in Inputs.Enumerate()) {
                if (pair.Index >= node.inputValues.Count) {
                    // Log.Warning($"{pair.Index} >= {node.inputValues.Count}, out of range input value index");
                    break;
                }

                node.inputValues[pair.Index] = pair.Item.Value;
            }

            foreach (var pair in Properties) {
                node.SetProperty(pair.Key, pair.Value.Value);
            }

            return node;
        }
    }
}