using UnityEngine;

//[RequireComponent(typeof(NanoBrain))]
[RequireComponent(typeof(NanoBrainComponent))]
public class Boid : MonoBehaviour {
    public static int BoundaryType = 1;
    public static int BoidType = 2;

    public SwarmControl sc;
    public Vector3 velocity = Vector3.zero;
    public Vector3 acceleration = Vector3.zero;

    private Bounds innerBounds;

    public NanoBrainComponent nanoBrain;
    public Receptor boundaryReceptor;
    public Receptor boidReceptor;

    public int id;

    void Awake() {
        this.id = this.GetInstanceID();

        nanoBrain = GetComponent<NanoBrainComponent>();
        boundaryReceptor = Perceptoid.GetReceptor(nanoBrain.brain, BoundaryType);
        boidReceptor = Perceptoid.GetReceptor(nanoBrain.brain, BoidType);

        sc = FindFirstObjectByType<SwarmControl>();

        innerBounds = new(sc.transform.position, sc.spaceSize - 2 * sc.boundaryWidth);
    }

    void Update() {
        Collider[] results = Physics.OverlapSphere(this.transform.position, sc.perceptionDistance);
        foreach (Collider c in results) {
            if (c as CapsuleCollider != null) {
                Boid neighbour = c.GetComponentInParent<Boid>();
                if (neighbour == null || neighbour == this)
                    continue;

                Vector3 localPosition = this.transform.InverseTransformPoint(neighbour.transform.position);
                localPosition = localPosition.normalized * (localPosition.magnitude - sc.separationDistance);
                //Debug.DrawRay(this.transform.position, this.transform.TransformDirection(localPosition), Color.magenta);

                int thingId = neighbour.GetInstanceID();
                boidReceptor.ProcessStimulus(thingId, localPosition);
            }
        }

        if (!innerBounds.Contains(this.transform.position)) {
            Vector3 point = this.transform.position;
            Vector3 pointOnBounds = innerBounds.ClosestPoint(point);
            Vector3 desiredWorldSpace = (pointOnBounds - point).normalized * sc.speed;
            Vector3 desiredLocalSpace = -this.transform.InverseTransformPoint(desiredWorldSpace);
            boundaryReceptor.ProcessStimulus(777, desiredLocalSpace);
        }

        Vector3 worldForce = this.transform.TransformDirection(nanoBrain.root.outputValue.ToVector3());

        this.velocity = (1 - sc.inertia) * (worldForce * Time.deltaTime) + sc.inertia * velocity;
        if (this.velocity.magnitude > 0)
            this.velocity = this.velocity.normalized * sc.speed;
        else
            this.velocity = this.transform.forward * sc.speed;
        //Debug.DrawRay(this.transform.position, this.velocity, Color.blue);

        this.transform.position += this.velocity * Time.deltaTime;

        if (this.velocity != Vector3.zero) {
            Quaternion targetRotation = Quaternion.LookRotation(this.velocity);
            transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, Time.deltaTime * 5f); // Adjust the speed of rotation        
        }

        nanoBrain.brain.UpdateNuclei();
    }

}