using System;
using System.Collections.Generic;

namespace Syntriax.Engine.Core;

public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : class, IBehaviour
{
    public Event<IBehaviourCollector<T>, T> OnCollected { get; private set; } = new();
    public Event<IBehaviourCollector<T>, T> OnRemoved { get; private set; } = new();
    public Event<IHasUniverse> OnUniverseAssigned { get; private set; } = new();
    public Event<IAssignable>? OnUnassigned { get; private set; } = new();

    private readonly Action<IBehaviourController, IBehaviour> cachedOnBehaviourAdded = null!;
    private readonly Action<IBehaviourController, IBehaviour> cachedOnBehaviourRemoved = null!;
    private readonly Action<IActive, bool> cachedOnBehaviourStateChanged = null!;
    private readonly Action<IUniverse, IUniverseObject> cachedOnUniverseObjectRegistered = null!;
    private readonly Action<IUniverse, IUniverseObject> cachedOnUniverseObjectUnregistered = null!;

    private readonly List<T> monitoringBehaviours = new(32);
    protected readonly List<T> activeBehaviours = new(32);
    protected readonly Dictionary<IActive, T> monitoringActiveToBehaviour = new(32);

    public IUniverse Universe { get; private set; } = null!;

    private void OnUniverseObjectRegistered(IUniverse manager, IUniverseObject universeObject)
    {
        universeObject.BehaviourController.OnBehaviourAdded.AddListener(cachedOnBehaviourAdded);
        universeObject.BehaviourController.OnBehaviourRemoved.AddListener(cachedOnBehaviourRemoved);

        for (int i = 0; i < universeObject.BehaviourController.Count; i++)
            OnBehaviourAdded(universeObject.BehaviourController, universeObject.BehaviourController[i]);
    }

    private void OnUniverseObjectUnregistered(IUniverse manager, IUniverseObject universeObject)
    {
        universeObject.BehaviourController.OnBehaviourAdded.RemoveListener(cachedOnBehaviourAdded);
        universeObject.BehaviourController.OnBehaviourRemoved.RemoveListener(cachedOnBehaviourRemoved);

        for (int i = 0; i < universeObject.BehaviourController.Count; i++)
            OnBehaviourRemoved(universeObject.BehaviourController, universeObject.BehaviourController[i]);
    }

    protected virtual void OnBehaviourAdd(IBehaviour behaviour) { }
    private void OnBehaviourAdded(IBehaviourController controller, IBehaviour behaviour)
    {
        if (behaviour is not T tBehaviour)
            return;

        monitoringBehaviours.Add(tBehaviour);
        monitoringActiveToBehaviour.Add(tBehaviour, tBehaviour);
        tBehaviour.OnActiveChanged.AddListener(cachedOnBehaviourStateChanged);
        OnBehaviourStateChanged(tBehaviour, !tBehaviour.IsActive);
    }

    private void OnBehaviourStateChanged(IActive sender, bool previousState)
    {
        T behaviour = monitoringActiveToBehaviour[sender];
        if (sender.IsActive)
        {
            activeBehaviours.Add(behaviour);
            OnBehaviourAdd(behaviour);
            OnCollected?.Invoke(this, behaviour);
        }
        else if (activeBehaviours.Remove(behaviour))
        {
            OnBehaviourRemove(behaviour);
            OnRemoved?.Invoke(this, behaviour);
        }
    }

    protected virtual void OnBehaviourRemove(IBehaviour behaviour) { }
    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviour behaviour)
    {
        if (behaviour is not T tBehaviour)
            return;

        if (!monitoringBehaviours.Remove(tBehaviour) || !monitoringActiveToBehaviour.Remove(tBehaviour))
            return;

        tBehaviour.OnActiveChanged.RemoveListener(cachedOnBehaviourStateChanged);
        if (activeBehaviours.Remove(tBehaviour))
        {
            OnBehaviourRemove(tBehaviour);
            OnRemoved?.Invoke(this, tBehaviour);
        }
    }

    public bool Assign(IUniverse universe)
    {
        if (Universe is not null)
            return false;

        foreach (IUniverseObject universeObject in universe.UniverseObjects)
            OnUniverseObjectRegistered(universe, universeObject);

        universe.OnUniverseObjectRegistered.AddListener(cachedOnUniverseObjectRegistered);
        universe.OnUniverseObjectUnRegistered.AddListener(cachedOnUniverseObjectUnregistered);

        Universe = universe;
        OnUniverseAssigned?.Invoke(this);

        return true;
    }

    public bool Unassign()
    {
        if (Universe is null)
            return false;

        foreach (IUniverseObject universeObject in Universe.UniverseObjects)
            OnUniverseObjectUnregistered(Universe, universeObject);

        Universe.OnUniverseObjectRegistered.RemoveListener(cachedOnUniverseObjectRegistered);
        Universe.OnUniverseObjectUnRegistered.RemoveListener(cachedOnUniverseObjectUnregistered);

        Universe = null!;
        OnUnassigned?.Invoke(this);
        return true;
    }

    public int Count => activeBehaviours.Count;
    public T this[Index index] => activeBehaviours[index];

    public ActiveBehaviourCollector()
    {
        cachedOnBehaviourAdded = OnBehaviourAdded;
        cachedOnBehaviourRemoved = OnBehaviourRemoved;
        cachedOnBehaviourStateChanged = OnBehaviourStateChanged;
        cachedOnUniverseObjectRegistered = OnUniverseObjectRegistered;
        cachedOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
    }
}