using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEditor;
using Unity.Mathematics;
using static Unity.Mathematics.math;

[Serializable]
public class Neuron : Nucleus {

    public Neuron(Cluster parent, string name) {
        this.parent = parent;
        this.name = name;
        this.parent?.nuclei.Add(this);
    }
    public Neuron(ClusterPrefab parent, string name) {
        this.cluster = parent;
        this.name = name;
        if (this.cluster != null) {
            this.cluster.nuclei.Add(this);
        }
        // else
        //     Debug.LogError("No neuroid network");
    }

    // [SerializeField]
    // protected string _name;
    // public virtual string name {
    //     get => _name;
    //     set => _name = value;
    // }

    // [SerializeField]
    // private List<Synapse> _synapses = new();
    // public List<Synapse> synapses => _synapses;

    // [SerializeReference]
    // private List<INucleus> _receivers = new();
    // public List<INucleus> receivers {
    //     get { return _receivers; }
    //     set { _receivers = value; }
    // }

    // [SerializeReference]
    // private NucleusArray _array;
    // public NucleusArray array {
    //     get { return _array; }
    //     set { _array = value; }
    // }

    #region Serialization

    public enum CurvePresets {
        Linear,
        Power,
        Sqrt,
        Reciprocal,
        Custom
    }
    [SerializeField]
    private CurvePresets _curvePreset;
    public CurvePresets curvePreset {
        get { return _curvePreset; }
        set {
            _curvePreset = value;
            this.curve = GenerateCurve();
        }
    }
    public AnimationCurve curve;
    public float curveMax = 1.0f;

    #region Parameters

    public bool average = false;

    #endregion Parameters

    public AnimationCurve GenerateCurve() {
        switch (this.curvePreset) {
            case CurvePresets.Linear:
                this.curveMax = 1;
                return Presets.Linear(1);
            case CurvePresets.Power:
                this.curveMax = 1;
                return Presets.Power(2.0f, 1);
            case CurvePresets.Sqrt:
                this.curveMax = 1;
                return Presets.Power(0.5f, 1);
            case CurvePresets.Reciprocal:
                this.curveMax = 1 / 0.01f * 1;
                return Presets.Reciprocal(1);
            default:
                this.curveMax = 1;
                return this.curve;
        }
    }

    public virtual void Deserialize(Neuron nucleus) { }

    #endregion Serialization

    #region Runtime state (not serialized)

    // public ClusterPrefab cluster { get; set; }
    // public Cluster parent { get; set; }

    #region Activation

    public static class Presets {
        private const int samples = 32;
        public static AnimationCurve Linear(float weight) {
            return AnimationCurve.Linear(0f, 0f, 1000f, weight * 1000);
        }
        public static AnimationCurve Power(float exponent, float weight) {
            // build keyframes
            Keyframe[] keys = new Keyframe[samples];
            for (int i = 0; i < samples; i++) {
                float t = i / (float)(samples - 1);
                float v = Mathf.Pow(t, exponent) * weight;
                keys[i] = new Keyframe(t, v);
            }

            AnimationCurve curve = new(keys);

            // set tangent modes for each key to Auto (smooth). Use Linear if you prefer straight segments.
            for (int i = 0; i < curve.length; i++) {
                AnimationUtility.SetKeyLeftTangentMode(curve, i, AnimationUtility.TangentMode.Auto);
                AnimationUtility.SetKeyRightTangentMode(curve, i, AnimationUtility.TangentMode.Auto);
            }

            return curve;
        }
        public static AnimationCurve Reciprocal(float weight) {
            int samples = 128;
            float xMin = 0.001f;
            float xMax = 1;
            var keys = new Keyframe[samples];
            for (int i = 0; i < samples; i++) {
                float t = i / (float)(samples - 1);
                float x = Mathf.Lerp(xMin, xMax, t);
                float y = 1f / x * weight;
                keys[i] = new Keyframe(x, y);
            }
            var curve = new AnimationCurve(keys);
            for (int i = 0; i < curve.length; i++) {
                AnimationUtility.SetKeyLeftTangentMode(curve, i, AnimationUtility.TangentMode.Linear);
                AnimationUtility.SetKeyRightTangentMode(curve, i, AnimationUtility.TangentMode.Linear);
            }
            return curve;
        }
    }

    #endregion Activation

    // protected float3 _outputValue;
    // public virtual float3 outputValue {
    //     get { return _outputValue; }
    //     set {
    //         this.stale = 0;
    //         // this._isSleeping = false;
    //         _outputValue = value;
    //     }
    // }

    // [NonSerialized]
    // private int stale = 1000;

    // private bool _isSleeping = false;
    // public bool isSleeping => _isSleeping;
    // public bool isSleeping => lengthsq(this.outputValue) == 0;

    // public void UpdateNuclei() {
    //     this.stale++;
    //     // this._isSleeping = this.stale > 2;
    //     // if (isSleeping)
    //     if (this.stale > 2)
    //         _outputValue = Vector3.zero;
    // }

    #endregion Runtime state

    // this clone the nucleus without the synapses and receivers
    public override Nucleus ShallowCloneTo(Cluster newParent) {
        Neuron clone = new(newParent, this.name) {
            array = null,
            curve = this.curve,
            curvePreset = this.curvePreset,
            curveMax = this.curveMax,
            average = this.average
        };
        return clone;
    }

    public override Nucleus Clone() {
        Neuron clone = new(this.cluster, this.name) {
        //Neuron clone = new(this.parent, this.name) {
            array = this.array,
            curve = this.curve,
            curvePreset = this.curvePreset,
            curveMax = this.curveMax,
            average = this.average
        };
        // if (clone.cluster != null)
        //     clone.cluster.nuclei.Add(clone);

        foreach (Synapse synapse in this.synapses) {
            Synapse clonedSynapse = clone.AddSynapse(synapse.nucleus);
            clonedSynapse.weight = synapse.weight;
        }
        foreach (Nucleus receiver in this.receivers) {
            clone.AddReceiver(receiver);
        }
        return clone;
    }

    // public virtual void AddReceiver(INucleus receivingNucleus, float weight = 1) {
    //     this._receivers.Add(receivingNucleus);
    //     receivingNucleus.AddSynapse(this, weight);
    // }

    // public void RemoveReceiver(INucleus receiverNucleus) {
    //     this._receivers.RemoveAll(receiver => receiver == receiverNucleus);
    //     receiverNucleus.synapses.RemoveAll(synapse => synapse.nucleus == this);
    // }

    public static void Delete(Nucleus nucleus) {
        foreach (Synapse synapse in nucleus.synapses) {
            if (synapse.nucleus is Neuron synapse_nucleus) {
                if (synapse_nucleus.receivers.Count > 1) {
                    // there is another nucleus feeding into this input nucleus
                    synapse_nucleus.receivers.RemoveAll(r => r == nucleus);
                }
                else {
                    // No other links, delete it.
                    Neuron.Delete(synapse_nucleus);
                }
            }
        }
        foreach (Nucleus receiver in nucleus.receivers) {
            if (receiver != null && receiver.synapses != null)
                receiver.synapses.RemoveAll(s => s.nucleus == nucleus);
        }

        if (nucleus.cluster != null) {
            nucleus.cluster.nuclei.RemoveAll(n => n == nucleus);
            nucleus.cluster.GarbageCollection();
        }
    }

    // public Synapse AddSynapse(IReceptor sendingNucleus, float weight = 1.0f) {
    //     Synapse synapse = new(sendingNucleus, weight);
    //     this.synapses.Add(synapse);
    //     return synapse;
    // }

    // public virtual void UpdateState() {
    //     //UpdateState(new float3(0, 0, 0));
    //     this.parent?.UpdateState();
    // }

    // public virtual void UpdateState(float3 inputValue) {
    //     float3 sum = inputValue;
    //     int n = 0;

    //     //Applying the weight factgors
    //     foreach (Synapse synapse in this.synapses) {
    //         sum += synapse.weight * synapse.nucleus.outputValue;

    //         // Perhaps synapses should be removed when the output value goes to 0....
    //         if (lengthsq(synapse.nucleus.outputValue) != 0)
    //             n++;
    //     }
    //     if (this.average && n > 0)
    //         sum /= n;

    //     // Activation function
    //     Vector3 result;
    //     switch (this.curvePreset) {
    //         case CurvePresets.Linear:
    //             result = sum;
    //             break;
    //         case CurvePresets.Sqrt:
    //             result = normalize(sum) * System.MathF.Sqrt(length(sum));
    //             break;
    //         case CurvePresets.Power:
    //             result = normalize(sum) * System.MathF.Pow(length(sum), 2);
    //             break;
    //         case CurvePresets.Reciprocal:
    //             result = normalize(sum) * (1 / length(sum));
    //             break;
    //         default:
    //             float activatedValue = this.curve.Evaluate(length(sum));
    //             result = normalize(sum) * activatedValue;
    //             break;
    //     }
    //     UpdateResult(result);
    // }

    // public virtual void UpdateStateIsolated() {
    //     UpdateStateIsolated(new float3(0, 0, 0));
    // }

    public float3 bias = float3(0, 0, 0);
    public override void UpdateStateIsolated(float3 bias_unused) {
        float3 sum = this.bias;
        int n = 0;

        //Applying the weight factgors
        foreach (Synapse synapse in this.synapses) {
            sum += synapse.weight * synapse.nucleus.outputValue;

            // Perhaps synapses should be removed when the output value goes to 0....
            if (lengthsq(synapse.nucleus.outputValue) != 0) {
                n++;
                this.stale = 0;
            }
        }
        if (this.average && n > 0)
            sum /= n;

        // Activation function
        float3 result = Vector3.zero;
        switch (this.curvePreset) {
            case CurvePresets.Linear:
                result = sum;
                break;
            case CurvePresets.Sqrt:
                result = normalize(sum) * System.MathF.Sqrt(length(sum));
                break;
            case CurvePresets.Power:
                result = normalize(sum) * System.MathF.Pow(length(sum), 2);
                break;
            case CurvePresets.Reciprocal: {
                    float magnitude = length(sum);
                    if (magnitude > 0)
                        result = normalize(sum) * (1 / magnitude);
                    break;
                }
            default:
                float activatedValue = this.curve.Evaluate(length(sum));
                result = normalize(sum) * activatedValue;
                break;
        }
        if (this.stale > 5)
            this.outputValue = new float3(0,0,0);
        else
            this.outputValue = result;
    }

    public virtual void ProcessStimulus(Vector3 inputValue, string thingName = null) {
        //this.outputValue = inputValue;
        this.stale = 0;
        //Debug.Log($"{this.name} processed stimulus");
        this.bias = inputValue;
    }

    // public virtual void UpdateResult(Vector3 result) {
    //     // float d = Vector3.Distance(result, this.outputValue);
    //     // if (d < 0.5f) {
    //     //     //Debug.Log($"insignificant update: {d}");
    //     //     return;
    //     // }

    //     this.outputValue = result;
    //     if (lengthsq(outputValue) != 0) {
    //         Debug.Log($"{this.parent.name}.{this.name}: {this.outputValue}");
    //     }

    //     foreach (INucleus receiver in this.receivers)
    //         receiver.UpdateState();

    // }
}