using System;
using System.Collections;
using System.Collections.Generic;

using Syntriax.Engine.Core.Abstract;

namespace Syntriax.Engine.Core;

public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : class, IBehaviour
{
    public event IAssignable.UnassignEventHandler? OnUnassigned = null;
    public event IHasUniverse.UniverseAssignedEventHandler? OnUniverseAssigned = null;

    public event IBehaviourCollector<T>.CollectedEventHandler? OnCollected = null;
    public event IBehaviourCollector<T>.RemovedEventHandler? OnRemoved = null;

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

    public IReadOnlyList<T> Behaviours => activeBehaviours;
    public IUniverse Universe { get; private set; } = null!;

    public T this[Index index] => activeBehaviours[index];

    public ActiveBehaviourCollector() { }
    public ActiveBehaviourCollector(IUniverse universe) => Assign(universe);

    private void OnUniverseObjectRegistered(IUniverse manager, IUniverseObject universeObject)
    {
        universeObject.BehaviourController.OnBehaviourAdded += OnBehaviourAdded;
        universeObject.BehaviourController.OnBehaviourRemoved += OnBehaviourRemoved;

        foreach (IBehaviour item in universeObject.BehaviourController)
            OnBehaviourAdded(universeObject.BehaviourController, item);
    }

    private void OnUniverseObjectUnregistered(IUniverse manager, IUniverseObject universeObject)
    {
        universeObject.BehaviourController.OnBehaviourAdded -= OnBehaviourAdded;
        universeObject.BehaviourController.OnBehaviourRemoved -= OnBehaviourRemoved;

        foreach (IBehaviour item in universeObject.BehaviourController)
            OnBehaviourRemoved(universeObject.BehaviourController, item);
    }

    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 += OnBehaviourStateChanged;
        OnBehaviourStateChanged(tBehaviour, !tBehaviour.IsActive);
    }

    private void OnBehaviourStateChanged(IActive sender, bool previousState)
    {
        T behaviour = monitoringActiveToBehaviour[sender];
        if (sender.IsActive)
        {
            activeBehaviours.Add(behaviour);
            OnBehaviourAdd(behaviour);
            OnCollected?.InvokeSafe(this, behaviour);
        }
        else if (activeBehaviours.Remove(behaviour))
        {
            OnBehaviourRemove(behaviour);
            OnRemoved?.InvokeSafe(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 -= OnBehaviourStateChanged;
        if (activeBehaviours.Remove(tBehaviour))
        {
            OnBehaviourRemove(tBehaviour);
            OnRemoved?.InvokeSafe(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 += OnUniverseObjectRegistered;
        universe.OnUniverseObjectUnRegistered += OnUniverseObjectUnregistered;

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

        return true;
    }

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

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

        Universe.OnUniverseObjectRegistered -= OnUniverseObjectRegistered;
        Universe.OnUniverseObjectUnRegistered -= OnUniverseObjectUnregistered;

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

    public IEnumerator<T> GetEnumerator() => activeBehaviours.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => activeBehaviours.GetEnumerator();
}