using BeyondNetCode.Shell.Ddd.Rules;
using BeyondNetCode.Shell.Ddd.Interfaces;
using BeyondNetCode.Shell.Ddd.Extensions;
using BeyondNetCode.Shell.Ddd.Rules.Impl;
using BeyondNetCode.Shell.Ddd.Services.Impl;

namespace BeyondNetCode.Shell.Ddd
{
    /// <summary>
    /// Represents an abstract base class for entities in the domain-driven design.
    /// </summary>
    /// <typeparam name="TEntity">The type of the entity.</typeparam>
    /// <typeparam name="TProps">The type of the entity properties.</typeparam>
    public abstract class Entity<TEntity, TProps> : IEntity<TEntity, TProps> where TEntity : class
            where TProps : class, IProps
    {
        #region Members         

        /// <summary>
        /// The properties of the entity.
        /// </summary>
        private TProps _props;

        #endregion

        #region Properties 

        public IdValueObject Id { get; private set; }

        public IdValueObject SetId(string id)
        {
            return IdValueObject.Load(id);
        }

        public BrokenRulesManager BrokenRules { get;  }

        public TrackingStateManager TrackingState { get; }

        public ValidatorRuleManager<AbstractRuleValidator<TEntity>> ValidatorRules { get; }

        #endregion

        #region Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="Entity{TEntity, TProps}"/> class.
        /// </summary>
        /// <param name="props">The properties of the entity.</param>
        protected Entity(TProps props)
        {
            BrokenRules = new BrokenRulesManager();

            TrackingState = new TrackingStateManager();

            ValidatorRules = new ValidatorRuleManager<AbstractRuleValidator<TEntity>>();

            Id = IdValueObject.Create();

            _props = props;

            Validate();

            TrackingState.MarkAsNew();
        }

        #endregion

        #region Methods

        /// <summary>
        /// Gets a copy of the entity properties.
        /// </summary>
        /// <returns>A copy of the entity properties.</returns>
        public TProps GetPropsCopy()
        {
            var copyProps = _props!.Clone();

            return (TProps)copyProps;
        }

        /// <summary>
        /// Gets the properties of the entity.
        /// </summary>
        public TProps Props
        {
            get { return _props!; }
        }

        /// <summary>
        /// Sets the properties of the entity.
        /// </summary>
        /// <param name="props">The properties to set.</param>
        public void SetProps(TProps props)
        {
            _props = props;

            TrackingState.MarkAsDirty();
        }

        #endregion

        #region BusinessRules

        /// <summary>
        /// Gets a value indicating whether the entity is valid.
        /// </summary>
        /// <returns><c>true</c> if the entity is valid; otherwise, <c>false</c>.</returns>
        public bool IsValid()
        {
            Validate();

            return !BrokenRules.GetBrokenRules().Any();
        }

        /// <summary>
        /// Validates the entity.
        /// </summary>
        public void Validate()
        {
            Guard();

            // Add validators for Entity
            AddValidators();

            // Get broken rules for Entity
            BrokenRules.Add(ValidatorRules.GetBrokenRules().ToList());

            if (BrokenRules.GetBrokenRules().Any())
            {
                TrackingState.MarkAsDirty();
                return;
            }

            // Explore broken rules for properties
            var props = GetPropsCopy().GetType().GetProperties();

            var propsBrokenRules = props.GetPropertiesBrokenRules(_props);

            if (propsBrokenRules.Any())
            {
                BrokenRules.Add(propsBrokenRules);

                TrackingState.MarkAsDirty();
            }
        }

        private void Guard()
        {              
            if (!(this is TEntity))
                throw new InvalidOperationException($"Entity '{GetType().Print()}' specifies '{typeof(TEntity).Print()}' as generic argument, it should be its own type");
        }

        /// <summary>
        /// Adds the validators for the value object.
        /// </summary>
        public virtual void AddValidators()
        {

        }

        #endregion

        #region Equality

        /// <inheritdoc/>
        public override bool Equals(object? obj)
        {
            if (obj == null || !(obj is Entity<TEntity, TProps>))
                return false;

            if (ReferenceEquals(this, obj))
                return true;

            if (GetType() != obj.GetType())
                return false;

            return ReferenceEntityPropertiesEquals(obj);
        }

        private bool ReferenceEntityPropertiesEquals(object? obj)
        {
            if (obj is not Entity<TEntity, TProps> entity)
                return false;

            return Id.Equals(entity.Id);
        }

        /// <inheritdoc/>
        public override int GetHashCode()
        {
            return Id.GetHashCode();
        }

        /// <summary>
        /// Determines whether two entities are equal.
        /// </summary>
        /// <param name="left">The left entity.</param>
        /// <param name="right">The right entity.</param>
        /// <returns><c>true</c> if the entities are equal; otherwise, <c>false</c>.</returns>
        public static bool operator ==(Entity<TEntity, TProps> left, Entity<TEntity, TProps> right)
        {
            if (Equals(left, null))
                return Equals(right, null) ? true : false;
            else
                return left.Equals(right);
        }

        /// <summary>
        /// Determines whether two entities are not equal.
        /// </summary>
        /// <param name="left">The left entity.</param>
        /// <param name="right">The right entity.</param>
        /// <returns><c>true</c> if the entities are not equal; otherwise, <c>false</c>.</returns>
        public static bool operator !=(Entity<TEntity, TProps> left, Entity<TEntity, TProps> right)
        {
            return !(left == right);
        }

        #endregion

        #region TransitionStatus

        /// <summary>
        /// Finite State Machine (FSM) Pattern
        /// </summary>

        private readonly Dictionary<object, List<object>> _validTransitions = new();

        protected void DefineValidTransitions(Dictionary<object, List<object>> transitions)
        {
            ArgumentNullException.ThrowIfNull(transitions, nameof(transitions));

            _validTransitions.Clear();
            foreach (var transition in transitions)
            {
                _validTransitions[transition.Key] = transition.Value;
            }
        }

        protected bool CanTransitionTo(object currentState, object newState)
        {
            if (!_validTransitions.ContainsKey(currentState))
            {
                throw new InvalidOperationException($"No transitions defined for state {currentState}.");
            }

            return _validTransitions[currentState].Contains(newState);
        }

        #endregion
    }
}