/*
using System.Collections.Generic;
using System.Linq;
using UnityEditor;

using UnityEngine;
using UnityEngine.UIElements;

[CustomEditor(typeof(NanoBrain))]
public class NanoBrainInspector : Editor {
    protected static VisualElement mainContainer;
    protected static VisualElement inspectorContainer;

    protected bool breakOnWake = false;

    #region Start

    public override VisualElement CreateInspectorGUI() {
        NanoBrain brain = target as NanoBrain;

        serializedObject.Update();

        VisualElement root = new();
        //root.style.flexDirection = FlexDirection.Row; // side-by-side layout
        //root.style.flexGrow = 1;
        //root.style.minHeight = 600;
        root.style.paddingLeft = 0;
        root.style.paddingRight = 0;
        root.style.paddingTop = 0;
        root.style.paddingBottom = 0;

        root.styleSheets.Add(Resources.Load<StyleSheet>("GraphStyles"));

        mainContainer = new() {
            // name = "main",
            style = {
                // flexDirection = FlexDirection.Row,
                // flexGrow = 1,
                height = 450,
                }
        };
        GraphView graph = new();
        graph.style.flexGrow = 1;

        inspectorContainer = new VisualElement {
            // name = "inspector"
        };

        mainContainer.Add(graph);
        mainContainer.Add(inspectorContainer);
        root.Add(mainContainer);

        // Run once for initial state (use resolved style width if available)
        float initialWidth = root.layout.width > 0 ? root.layout.width : root.contentRect.width;
        UpdateLayout(initialWidth);

        // React to size changes of root (or parent if appropriate)
        root.RegisterCallback<GeometryChangedEvent>(evt => {
            UpdateLayout(evt.newRect.width);
        });

        if (brain != null)
            graph.SetGraph(null, brain, brain.output, inspectorContainer);
        else
            Debug.LogWarning(" No brain!");

        serializedObject.ApplyModifiedProperties();
        return root;
    }

    public class GraphView : VisualElement {
        NanoBrain brain;
        SerializedObject serializedBrain;
        INucleus currentNucleus;
        GameObject gameObject;
        private List<NeuroidLayer> layers = new();
        private readonly Dictionary<IReceptor, Vector2Int> neuroidPositions = new();

        Vector2 pan = Vector2.zero;
        //float zoom = 1f;
        bool draggingCanvas = false;
        Vector2 lastMouse;
        GraphNodeWrapper currentWrapper;

        public GraphView() {
            name = "content";
            style.flexGrow = 1;

            IMGUIContainer imguiContainer = new(OnIMGUI);
            imguiContainer.style.position = Position.Absolute;
            imguiContainer.style.left = 0; imguiContainer.style.top = 0;
            imguiContainer.style.right = 0; imguiContainer.style.bottom = 0;
            imguiContainer.pickingMode = PickingMode.Position;
            imguiContainer.focusable = true;
            Add(imguiContainer);

            //RegisterCallback<WheelEvent>(OnWheel);
            RegisterCallback<MouseDownEvent>(OnMouseDown);
            RegisterCallback<MouseMoveEvent>(OnMouseMove);
            RegisterCallback<MouseUpEvent>(OnMouseUp);
        }

        public void SetGraph(GameObject gameObject, NanoBrain brain, Nucleus nucleus, VisualElement inspectorContainer) {
            this.gameObject = gameObject;
            this.brain = brain;
            if (Application.isPlaying == false)
                this.serializedBrain = new SerializedObject(brain);
            this.currentNucleus = nucleus;
            Rebuild(inspectorContainer);
        }

        void Rebuild(VisualElement inspectorContainer) {
            BuildLayers();

            if (this.currentNucleus == null) {
                inspectorContainer.Clear();
                return;
            }

            if (currentWrapper != null)
                DestroyImmediate(currentWrapper);
            currentWrapper = CreateInstance<GraphNodeWrapper>().Init(this.currentNucleus, brain);
            DrawInspector(inspectorContainer);
        }

        private void BuildLayers() {
            // A temporary list to track what's been added to layers
            this.layers = new();
            int layerIx = 0;

            INucleus selectedNucleus = this.currentNucleus;
            if (selectedNucleus == null)
                return;
            NeuroidLayer currentLayer = new() { ix = layerIx };

            if (selectedNucleus.receivers != null) {
                foreach (INucleus receiver in selectedNucleus.receivers) {
                    INucleus outputNeuroid = receiver;
                    if (outputNeuroid != null) {
                        AddToLayer(currentLayer, outputNeuroid);
                        // Debug.Log($"layer {layerIx} nucleus {outputNeuroid.name}");
                    }
                }
            }
            if (currentLayer.neuroids.Count > 0) {
                this.layers.Add(currentLayer);
                layerIx++;
                currentLayer = new() { ix = layerIx };
            }

            AddToLayer(currentLayer, selectedNucleus);
            this.layers.Add(currentLayer);
            // Debug.Log($"layer {layerIx} nucleus {selectedNucleus.name}");

            layerIx++;
            currentLayer = new() { ix = layerIx };

            if (selectedNucleus.synapses != null) {
                foreach (Synapse synapse in selectedNucleus.synapses) {
                    IReceptor input = synapse.nucleus;
                    AddToLayer(currentLayer, input);
                    // Debug.Log($"layer {layerIx} nucleus {input.name}");
                }
            }
            if (currentLayer.neuroids.Count > 0) {
                this.layers.Add(currentLayer);
            }
        }

        private void AddToLayer(NeuroidLayer layer, IReceptor nucleus) {
            if (nucleus == null)
                return;
            layer.neuroids.Add(nucleus);
            //nucleus.layerIx = layer.ix;
            // Store its position
            Vector2Int neuroidPosition = new(layer.ix, layer.neuroids.Count - 1);
            neuroidPositions[nucleus] = neuroidPosition;

        }

        void OnMouseDown(MouseDownEvent e) {
            if (e.button == 2) { draggingCanvas = true; lastMouse = e.mousePosition; e.StopPropagation(); }
        }
        void OnMouseMove(MouseMoveEvent e) {
            if (draggingCanvas) {
                var delta = e.mousePosition - lastMouse;
                pan += delta;
                //content.style.left = pan.x;
                //content.style.top = pan.y;
                lastMouse = e.mousePosition;
            }
        }
        void OnMouseUp(MouseUpEvent e) { if (e.button == 2) draggingCanvas = false; }

        void OnIMGUI() {
            if (currentNucleus == null)
                return;

            if (Application.isPlaying == false)
                serializedBrain.Update();

            Handles.BeginGUI();
            DrawGraph();
            Handles.EndGUI();

        }

        private void DrawGraph() {
            float size = 20;
            Vector3 position = new(150, 210, 0);

            DrawReceivers(this.currentNucleus, position, size);
            DrawSynapses(this.currentNucleus, position, size);

            // Draw selected Nucleus
            Handles.color = Color.white;
            Handles.DrawSolidDisc(position, Vector3.forward, size + 2);
            DrawNucleus(this.currentNucleus, position, this.currentNucleus.outputValue.magnitude, 20);
        }

        private void DrawReceivers(INucleus nucleus, Vector3 parentPos, float size) {
            int nodeCount = nucleus.receivers.Count;

            // Determine the maximum value in this layer
            // This is used to 'scale' the output value colors of the nuclei
            float maxValue = 0;
            foreach (INucleus receiver in nucleus.receivers) {
                if (receiver is Neuroid neuroid) {
                    float value = neuroid.outputValue.magnitude;
                    if (value > maxValue)
                        maxValue = value;
                }
            }

            // Determine the spacing of the nuclei in the layer
            float spacing = 400f / nodeCount;
            float margin = 10 + spacing / 2;

            int row = 0;
            foreach (INucleus receiver in nucleus.receivers) {
                INucleus receiverNucleus = receiver;
                if (receiverNucleus == null)
                    continue;

                Vector3 pos = new(50, margin + row * spacing, 0.0f);
                Handles.color = Color.white;
                Handles.DrawLine(parentPos, pos);

                DrawNucleus(receiverNucleus, pos, maxValue, size);
                row++;
            }
        }

        private void DrawSynapses(INucleus nucleus, Vector3 parentPos, float size) {
            int nodeCount = nucleus.synapses.Count;

            // Determine the maximum value in this layer
            // This is used to 'scale' the output value colors of the nuclei
            float maxValue = 0;
            foreach (Synapse receiver in nucleus.synapses) {
                if (receiver.nucleus is Neuroid neuroid) {
                    float value = neuroid.outputValue.magnitude;
                    if (value > maxValue)
                        maxValue = value;
                }
            }

            // Determine the spacing of the nuclei in the layer
            float spacing = 400f / nodeCount;
            float margin = 10 + spacing / 2;

            int row = 0;
            List<PercepteiArray> drawnArrays = new();
            foreach (Synapse synapse in nucleus.synapses) {
                Vector3 pos = new(250, margin + row * spacing, 0.0f);
                Handles.color = Color.white;
                Handles.DrawLine(parentPos, pos);
                // if (synapse.nucleus is Perceptoid perceptoid && perceptoid.array != null) {
                //     // if (drawnArrays.Contains(perceptoid.array))
                //     //     // We already drawn this array
                //     //     continue;

                //     drawnArrays.Add(perceptoid.array);
                //     DrawArray(perceptoid.array, pos, size);
                // }
                // else {

                DrawNucleus(synapse.nucleus, pos, maxValue, size);
                row++;
                // }
            }
        }

        private void DrawNucleus(IReceptor nucleus, Vector3 position, float maxValue, float size) {
            if (nucleus.isSleeping)
                Handles.color = Color.darkRed;
            else {
                if (Application.isPlaying) {
                    float brightness = nucleus.outputValue.magnitude / maxValue;
                    Handles.color = new Color(brightness, brightness, brightness, 1f);
                }
                else
                    Handles.color = Color.black;
            }
            Handles.DrawSolidDisc(position, Vector3.forward, size);

            Handles.color = Color.white;
            // Position the label in front of the disc
            Vector3 labelPosition = position + (Vector3.forward * 0.1f);

            GUIStyle style = new(EditorStyles.label) {
                alignment = TextAnchor.MiddleCenter,
                normal = { textColor = Color.white },
                fontStyle = FontStyle.Bold,
            };
            if (nucleus is Perceptoid perceptoid) {
                if (perceptoid.array == null || perceptoid.array.perceptei == null || perceptoid.array.perceptei.Length == 0)
                    perceptoid.array = new PercepteiArray(perceptoid);

                if (perceptoid.array.perceptei.Length > 1) {
                    Handles.Label(labelPosition, perceptoid.array.perceptei.Length.ToString(), style);
                }
            }

            style.alignment = TextAnchor.UpperCenter;
            Vector3 labelPos = position - Vector3.down * (size + 0.2f); // below disc along up axis
            Handles.Label(labelPos, nucleus.name, style);

            Rect neuronRect = new(position.x - size, position.y - size, size * 2, size * 2);
            int id = GUIUtility.GetControlID(FocusType.Passive);
            Event e = Event.current;
            EventType et = e.GetTypeForControl(id);
            if (e != null && neuronRect.Contains(e.mousePosition)) {
                // Process Hover
                HandleMouseHover(nucleus, neuronRect);
                // Process click
                if (e.type == EventType.MouseDown && e.button == 0) {
                    // Consume the event so the scene doesn't also handle it
                    e.Use();
                    HandleClicked(nucleus);
                }
            }
        }

        private void DrawArray(PercepteiArray array, Vector3 position, float size) {
            Vector3 offset = new(size / 4, size / 4, 0);
            Handles.color = Color.black;
            Handles.DrawSolidDisc(position, Vector3.forward, size);

            GUIStyle style = new(EditorStyles.label) {
                alignment = TextAnchor.UpperCenter,
                normal = { textColor = Color.white },
                fontStyle = FontStyle.Bold
            };
            Handles.Label(position, array.perceptei.Length.ToString(), style);
            Vector3 labelPos = position - Vector3.down * (size + 0.2f); // below disc along up axis
            Handles.Label(labelPos, array.name, style);

            // To do: add HandleClick (see above) to expand the array
        }

        private void HandleMouseHover(IReceptor nucleus, Rect rect) {
            GUIContent tooltip;
            if (nucleus is Perceptoid perceptoid) {
                if (perceptoid.receptor != null) {
                    tooltip = new(
                        $"{perceptoid.name}" +
                        // $"\nType {perceptoid.receptor.thingType}" +
                        $" Thing {perceptoid.thingId}" +
                        $"\nValue: {nucleus.outputValue}");
                }
                else {
                    tooltip = new(
                        $"{perceptoid.name}" +
                        $"\nThing {perceptoid.thingId}" +
                        $"\nValue: {nucleus.outputValue}");
                }
            }
            else if (nucleus is INucleus n) {
                tooltip = new(
                    $"{nucleus.name}" +
                    $"\nsynapse count {n.synapses.Count}" +
                    $"\nValue: {nucleus.outputValue}");
            }
            else {
                tooltip = new(
                    $"{nucleus.name}" +
                    $"\nValue: {nucleus.outputValue}");
            }

            Vector2 mousePosition = Event.current.mousePosition;

            // Display tooltip with some offset
            Vector2 tooltipSize = GUI.skin.box.CalcSize(tooltip);
            Rect tooltipRect = new Rect(mousePosition.x + 10, mousePosition.y + 10, tooltipSize.x, tooltipSize.y);

            GUI.Box(tooltipRect, tooltip);
        }

        private void HandleClicked(IReceptor nucleus) {
            if (nucleus is INucleus n) {
                this.currentNucleus = n;
                BuildLayers();
            }
        }

        void DrawInspector(VisualElement inspectorContainer) {
            if (inspectorContainer == null)
                return;

            inspectorContainer.Clear();
            if (this.currentNucleus == null)
                return;

            // create a SerializedObject wrapper so Unity inspector controls work (and Undo)
            SerializedObject so = new(currentWrapper);
            IMGUIContainer container = new(() => {
                if (so.targetObject == null)
                    return;
                so.Update();

                if (this.currentNucleus == null)
                    return;

                this.currentNucleus.name = EditorGUILayout.TextField(this.currentNucleus.name);
                if (this.currentNucleus is Perceptoid perceptoid) {
                    // perceptoid.receptor.thingType = EditorGUILayout.IntField("Thing Type", perceptoid.receptor.thingType);

                    if (perceptoid.array == null || perceptoid.array.perceptei == null || perceptoid.array.perceptei.Length == 0)
                        perceptoid.array = new PercepteiArray(perceptoid);
                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.IntField("Array size", perceptoid.array.perceptei.Length);
                    if (GUILayout.Button("Add"))
                        perceptoid.array.AddPerceptoid();
                    if (GUILayout.Button("Del"))
                        perceptoid.array.RemovePerceptoid();
                    EditorGUILayout.EndHorizontal();
                }
                else if (this.currentNucleus is Neuroid neuroid) {
                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.LabelField("Activation Curve", GUILayout.Width(150));
                    if (neuroid.curveMax > 0)
                        EditorGUILayout.CurveField(neuroid.curve, Color.cyan, new Rect(0, 0, 1, neuroid.curveMax));
                    else
                        EditorGUILayout.CurveField(neuroid.curve, Color.cyan, new Rect(0, neuroid.curveMax, 1, -neuroid.curveMax));
                    neuroid.curvePreset = (Neuroid.CurvePresets)EditorGUILayout.EnumPopup(neuroid.curvePreset, GUILayout.Width(100));
                    EditorGUILayout.EndHorizontal();
                }

                if (Application.isPlaying)
                    EditorGUILayout.FloatField("Output", this.currentNucleus.outputValue.magnitude);
                else
                    EditorGUILayout.LabelField(" ");

                if (this.currentNucleus.synapses.Count > 0) {
                    Synapse[] synapses = this.currentNucleus.synapses.ToArray();
                    foreach (Synapse synapse in synapses) {
                        if (synapse.nucleus != null) {
                            EditorGUILayout.Space();

                            EditorGUI.BeginDisabledGroup(synapse.nucleus.isSleeping);
                            if (Application.isPlaying)
                                EditorGUILayout.FloatField(synapse.nucleus.name, synapse.nucleus.outputValue.magnitude * synapse.weight);
                            else {
                                EditorGUILayout.BeginHorizontal();
                                EditorGUILayout.LabelField(synapse.nucleus.name);
                                // if (synapse.nucleus is Perceptoid perceptoid) {
                                //     if (perceptoid.array == null || perceptoid.array.perceptei == null || perceptoid.array.perceptei.Length == 0) {
                                //         perceptoid.array = new PercepteiArray(perceptoid);
                                //     }
                                //     EditorGUILayout.IntField(perceptoid.array.perceptei.Length);
                                //     if (GUILayout.Button("Add"))
                                //         perceptoid.array.AddPerceptoid();
                                // }
                                if (GUILayout.Button("Disconnect"))
                                    synapse.nucleus.RemoveReceiver(this.currentNucleus);
                                EditorGUILayout.EndHorizontal();
                            }

                            EditorGUI.indentLevel++;
                            synapse.weight = EditorGUILayout.FloatField("Weight", synapse.weight);
                            EditorGUI.indentLevel--;
                            EditorGUI.EndDisabledGroup();
                        }
                    }
                }

                EditorGUILayout.Space();

                ConnectNucleus(this.currentNucleus);
                if (GUILayout.Button("Add Input Neuron"))
                    AddInputNeuron(this.currentNucleus);
                if (GUILayout.Button("Add Input Perceptoid"))
                    AddPerceptoid(this.currentNucleus);
                if (GUILayout.Button("Add Input Cluster"))
                    AddCluster(this.currentNucleus);

                EditorGUILayout.Space();

                if (GUILayout.Button("Delete this neuron"))
                    DeleteNeuron(this.currentNucleus);

                //DisconnectNucleus(this.currentNucleus);

                if (this.gameObject != null) {
                    Vector3 worldVector = this.gameObject.transform.TransformVector(this.currentNucleus.outputValue);
                    Debug.DrawRay(this.gameObject.transform.position, worldVector, Color.yellow);
                }
            });

            inspectorContainer.Add(container);
        }

        protected virtual void AddInputNeuron(INucleus nucleus) {
            Neuroid newNeuroid = new(this.brain.cluster, "New neuron");
            newNeuroid.AddReceiver(nucleus);
            this.currentNucleus = newNeuroid;
            BuildLayers();
        }

        protected virtual void DeleteNeuron(INucleus nucleus) {
            if (nucleus == null)
                return;
            if (nucleus.cluster != null)
                this.currentNucleus = nucleus.cluster.output;
            foreach (INucleus receiver in nucleus.receivers) {
                if (receiver != null) {
                    this.currentNucleus = receiver;
                    break;
                }
            }
            Nucleus.Delete(nucleus);
            BuildLayers();
        }

        protected virtual void AddPerceptoid(INucleus nucleus) {
            Perceptoid newPerceptoid = new(this.brain, 0, "New Perceptoid");
            newPerceptoid.AddReceiver(nucleus);
            this.currentNucleus = newPerceptoid;
            BuildLayers();
        }

        protected virtual void AddCluster(INucleus nucleus) {
            BrainPickerWindow.ShowPicker(brain => OnClusterPicked(nucleus, brain), "Select Cluster");
        }

        private void OnClusterPicked(INucleus nucleus, NanoBrain brain) {
            NanoBrain brainInstance = Instantiate(brain);
            brainInstance.AddReceiver(nucleus);
        }

        protected virtual void ConnectNucleus(INucleus nucleus) {
            if (this.currentNucleus.cluster == null)
                return;

            IEnumerable<string> synapseNuclei = this.currentNucleus.synapses.Select(synapse => synapse.nucleus.name);
            //IEnumerable<string> perceptei = this.currentNucleus.brain.perceptei.Select(i => i.name).Except(synapseNuclei);
            IEnumerable<string> nuclei = this.currentNucleus.cluster.nuclei.Select(i => i.name).Except(synapseNuclei);
            //string[] names = perceptei.Concat(nuclei).ToArray();
            string[] names = nuclei.ToArray();
            int selectedIndex = -1;
            selectedIndex = EditorGUILayout.Popup("Connect to", selectedIndex, names);
            if (selectedIndex >= 0) {
                // if (selectedIndex < perceptei.Count()) {
                //     Nucleus n = this.currentNucleus.brain.perceptei[selectedIndex];
                //     n.AddReceiver(this.currentNucleus);
                // }
                // else {
                //     Nucleus n = this.currentNucleus.brain.nuclei[selectedIndex - perceptei.Count()];
                //     n.AddReceiver(this.currentNucleus);
                // }
                INucleus n = this.currentNucleus.cluster.nuclei[selectedIndex];
                n.AddReceiver(this.currentNucleus);
            }
        }

        protected virtual void DisconnectNucleus(Nucleus nucleus) {
            if (this.currentNucleus.cluster == null)
                return;
            string[] names = this.currentNucleus.synapses.Select(synapse => synapse.nucleus.name).ToArray();
            int selectedIndex = -1;
            selectedIndex = EditorGUILayout.Popup("Disconnect from", selectedIndex, names);
            //if (selectedIndex >= 0 && selectedIndex < this.currentNucleus.brain.perceptei.Count) {
            if (selectedIndex >= 0 && selectedIndex < this.currentNucleus.cluster.nuclei.Count) {
                Synapse synapse = this.currentNucleus.synapses[selectedIndex];
                synapse.nucleus.RemoveReceiver(this.currentNucleus);
            }
        }
    }

    #endregion Start    

    #region Update

    private void UpdateLayout(float containerWidth) {
        if (containerWidth > 600f) {
            mainContainer.style.flexDirection = FlexDirection.Row;
            inspectorContainer.style.width = 300;        // fixed sidebar width
            inspectorContainer.style.flexGrow = 0;
        }
        else {
            mainContainer.style.flexDirection = FlexDirection.Column;
            inspectorContainer.style.width = Length.Percent(100); // full width below
            inspectorContainer.style.flexDirection = FlexDirection.Column;
            inspectorContainer.style.flexGrow = 1; // can set 0 or keep as needed
        }
    }

    #endregion Update
}

/*
public class NeuroidLayer {
    public int ix = 0;
    public List<INucleus> neuroids = new();
}
*/

/*
public class GraphNodeWrapper : ScriptableObject {
    // expose fields that map to GraphNode
    //public string title;
    public Vector2 position;
    INucleus node;
    NanoBrain graph; // needed to write back and mark dirty

    public GraphNodeWrapper Init(INucleus node, NanoBrain graphAsset) {
        this.node = node;
        this.graph = graphAsset;
        //this.title = " A " + node.name;
        //position = node.position;
        return this;
    }
    void OnValidate() {
        if (node != null) {
            //node.name = title;
            //node.position = position;
#if UNITY_EDITOR
            if (graph != null)
                UnityEditor.EditorUtility.SetDirty(graph);
#endif
        }
    }
}
*/