using System;

using Syntriax.Engine.Core.Exceptions;

namespace Syntriax.Engine.Core.Abstract;

public abstract class BaseEntity : IEntity
{
    public event IEntity.OnIdChangedEventHandler? OnIdChanged = null;

    public event IInitialize.OnInitializedEventHandler? OnInitialized = null;
    public event IInitialize.OnFinalizedEventHandler? OnFinalized = null;

    public event IAssignableStateEnable.OnStateEnableAssignedEventHandler? OnStateEnableAssigned = null;
    public event IAssignable.OnUnassignedEventHandler? OnUnassigned = null;


    private IStateEnable _stateEnable = null!;

    private bool _initialized = false;
    private string _id = string.Empty;

    public virtual IStateEnable StateEnable => _stateEnable;

    public virtual bool IsActive => StateEnable.Enabled;

    public string Id
    {
        get => _id;
        set
        {
            if (value == _id)
                return;

            string previousId = _id;

            _id = value;
            OnIdChanged?.Invoke(this, previousId);
        }
    }

    public bool IsInitialized
    {
        get => _initialized;
        private set
        {
            if (value == _initialized)
                return;

            _initialized = value;
            if (value)
                OnInitialized?.Invoke(this);
            else
                OnFinalized?.Invoke(this);
        }
    }

    public bool Assign(IStateEnable stateEnable)
    {
        if (IsInitialized)
            return false;

        _stateEnable = stateEnable;
        _stateEnable.Assign(this);
        OnStateEnableAssigned?.Invoke(this);
        return true;
    }

    protected virtual void UnassignInternal() { }
    public bool Unassign()
    {
        if (IsInitialized)
            return false;

        UnassignInternal();

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

    protected virtual void InitializeInternal() { }
    public bool Initialize()
    {
        if (IsInitialized)
            return false;

        NotAssignedException.Check(this, _stateEnable);

        InitializeInternal();

        IsInitialized = true;
        return true;
    }

    protected virtual void FinalizeInternal() { }
    public bool Finalize()
    {
        if (!IsInitialized)
            return false;

        FinalizeInternal();

        IsInitialized = false;
        return true;
    }

    protected BaseEntity() => _id = Guid.NewGuid().ToString("D");
    protected BaseEntity(string id) => _id = id;
}