using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
#if !SERVER

#endif

namespace ET
{
    [Flags]
    public enum EntityStatus: byte
    {
        None = 0,
        IsFromPool = 1,
        IsRegister = 1 << 1,
        IsComponent = 1 << 2,
        IsCreate = 1 << 3,
    }

    public partial class Entity: Object
    {
        [IgnoreDataMember]
        private static readonly Pool<HashSet<Entity>> hashSetPool = new Pool<HashSet<Entity>>();

        [IgnoreDataMember]
        private static readonly Pool<Dictionary<Type, Entity>> dictPool = new Pool<Dictionary<Type, Entity>>();

        [IgnoreDataMember]
        private static readonly Pool<Dictionary<long, Entity>> childrenPool = new Pool<Dictionary<long, Entity>>();

        [IgnoreDataMember]
        [BsonIgnore]
        public long InstanceId
        {
            get;
            set;
        }

        protected Entity()
        {
        }

        [IgnoreDataMember]
        [BsonIgnore]
        private EntityStatus status = EntityStatus.None;

        [IgnoreDataMember]
        [BsonIgnore]
        public bool IsFromPool
        {
            get => (this.status & EntityStatus.IsFromPool) == EntityStatus.IsFromPool;
            set
            {
                if (value)
                {
                    this.status |= EntityStatus.IsFromPool;
                }
                else
                {
                    this.status &= ~EntityStatus.IsFromPool;
                }
            }
        }

        [IgnoreDataMember]
        [BsonIgnore]
        public bool IsRegister
        {
            get => (this.status & EntityStatus.IsRegister) == EntityStatus.IsRegister;
            set
            {
                if (this.IsRegister == value)
                {
                    return;
                }

                if (value)
                {
                    this.status |= EntityStatus.IsRegister;
                }
                else
                {
                    this.status &= ~EntityStatus.IsRegister;
                }

                EventSystem.Instance.RegisterSystem(this, value);
            }
        }

        [IgnoreDataMember]
        [BsonIgnore]
        private bool IsComponent
        {
            get => (this.status & EntityStatus.IsComponent) == EntityStatus.IsComponent;
            set
            {
                if (value)
                {
                    this.status |= EntityStatus.IsComponent;
                }
                else
                {
                    this.status &= ~EntityStatus.IsComponent;
                }
            }
        }

        [IgnoreDataMember]
        [BsonIgnore]
        public bool IsCreate
        {
            get => (this.status & EntityStatus.IsCreate) == EntityStatus.IsCreate;
            set
            {
                if (value)
                {
                    this.status |= EntityStatus.IsCreate;
                }
                else
                {
                    this.status &= ~EntityStatus.IsCreate;
                }
            }
        }

        [IgnoreDataMember]
        [BsonIgnore]
        public bool IsDisposed => this.InstanceId == 0;

        [IgnoreDataMember]
        [BsonIgnore]
        
        #if UNITY_EDITOR && VIEWGO
        [Sirenix.Serialization.OdinSerialize]
        #endif
        protected Entity parent;

        [IgnoreDataMember]
        [BsonIgnore]
        public Entity Parent
        {
            get => this.parent;
            set
            {
                if (value == null)
                {
                    throw new Exception($"cant set parent null: {this.GetType().Name}");
                }

                if (this.parent != null) // 之前有parent
                {
                    // parent相同，不设置
                    if (this.parent.InstanceId == value.InstanceId)
                    {
                        Log.Error($"重复设置了Parent: {this.GetType().Name} parent: {this.parent.GetType().Name}");
                        return;
                    }

                    this.parent.RemoveChild(this);

                    this.parent = value;
                    this.parent.AddChild(this);

                    this.Domain = this.parent.domain;
                }
                else
                {
                    this.parent = value;
                    this.parent.AddChild(this);

                    this.IsComponent = false;

                    AfterSetParent();
                }
            }
        }

        [IgnoreDataMember]
        // 该方法只能在AddComponent中调用，其他人不允许调用
        [BsonIgnore]
        private Entity ComponentParent
        {
            set
            {
                if (this.parent != null)
                {
                    throw new Exception($"Component parent is not null: {this.GetType().Name}");
                }

                this.parent = value;

                this.IsComponent = true;

                AfterSetParent();
            }
        }

        private void AfterSetParent()
        {
            this.Domain = this.parent.domain;

#if UNITY_EDITOR && VIEWGO
            if (this.ViewGO != null && this.parent.ViewGO != null)
            {
                this.ViewGO.transform.SetParent(this.parent.ViewGO.transform, false);
            }
#endif
        }

        public T GetParent<T>() where T : Entity
        {
            return this.Parent as T;
        }

        [BsonIgnoreIfDefault]
        [BsonDefaultValue(0L)]
        [BsonElement]
        [BsonId]
#if UNITY_EDITOR && VIEWGO
        [Sirenix.Serialization.OdinSerialize]
#endif
        public long Id
        {
            get;
            set;
        }

        [IgnoreDataMember]
        [BsonIgnore]
#if UNITY_EDITOR && VIEWGO
        [Sirenix.Serialization.OdinSerialize]
#endif
        protected Entity domain;

        [IgnoreDataMember]
        [BsonIgnore]
        public Entity Domain
        {
            get => this.domain;
            set
            {
                if (value == null)
                {
                    return;
                }

                Entity preDomain = this.domain;
                this.domain = value;

                //if (!(this.domain is Scene))
                //{
                //	throw new Exception($"domain is not scene: {this.GetType().Name}");
                //}

                if (preDomain == null)
                {
                    this.InstanceId = IdGenerater.Instance.GenerateInstanceId();

                    // 反序列化出来的需要设置父子关系
                    if (!this.IsCreate)
                    {
                        if (this.componentsDB != null)
                        {
                            foreach (Entity component in this.componentsDB)
                            {
                                component.IsComponent = true;
                                this.Components.Add(component.GetType(), component);
                                component.parent = this;
                            }
                        }

                        if (this.childrenDB != null)
                        {
                            foreach (Entity child in this.childrenDB)
                            {
                                child.IsComponent = false;
                                this.Children.Add(child.Id, child);
                                child.parent = this;
                            }
                        }
                    }
                }

                // 是否注册跟parent一致
                if (this.parent != null)
                {
                    this.IsRegister = this.Parent.IsRegister;
                }

                // 递归设置孩子的Domain
                if (this.children != null)
                {
                    foreach (Entity entity in this.children.Values)
                    {
                        entity.Domain = this.domain;
                    }
                }

                if (this.components != null)
                {
                    foreach (Entity component in this.components.Values)
                    {
                        component.Domain = this.domain;
                    }
                }

                if (preDomain == null && !this.IsCreate)
                {
                    EventSystem.Instance.Deserialize(this);
                }
            }
        }

		[IgnoreDataMember]
        [BsonElement("Children")]
        [BsonIgnoreIfNull]
        private HashSet<Entity> childrenDB;

        [IgnoreDataMember]
        [BsonIgnore]
        private Dictionary<long, Entity> children;

        [IgnoreDataMember]
        [BsonIgnore]
        public Dictionary<long, Entity> Children => this.children ?? (this.children = childrenPool.Fetch());

        private void AddChild(Entity entity)
        {
            this.Children.Add(entity.Id, entity);
            this.AddChildDB(entity);
        }

        private void RemoveChild(Entity entity)
        {
            if (this.children == null)
            {
                return;
            }

            this.children.Remove(entity.Id);

            if (this.children.Count == 0)
            {
                childrenPool.Recycle(this.children);
                this.children = null;
            }

            this.RemoveChildDB(entity);
        }

        private void AddChildDB(Entity entity)
        {
            if (!(entity is ISerializeToEntity))
            {
                return;
            }

            if (this.childrenDB == null)
            {
                this.childrenDB = hashSetPool.Fetch();
            }

            this.childrenDB.Add(entity);
        }

        private void RemoveChildDB(Entity entity)
        {
            if (!(entity is ISerializeToEntity))
            {
                return;
            }

            if (this.childrenDB == null)
            {
                return;
            }

            this.childrenDB.Remove(entity);

            if (this.childrenDB.Count == 0)
            {
                if (this.IsFromPool)
                {
                    hashSetPool.Recycle(this.childrenDB);
                    this.childrenDB = null;
                }
            }
        }

        [IgnoreDataMember]
        [BsonElement("C")]
        [BsonIgnoreIfNull]
        private HashSet<Entity> componentsDB;

        [IgnoreDataMember]
        [BsonIgnore]
#if UNITY_EDITOR && VIEWGO
        [Sirenix.Serialization.OdinSerialize]
#endif
        private Dictionary<Type, Entity> components;

        [IgnoreDataMember]
        [BsonIgnore]
        public Dictionary<Type, Entity> Components => this.components ?? (this.components = dictPool.Fetch());

        public static implicit operator bool(Entity e)
        {
            return e is { IsDisposed: false };
        }
        public override void Dispose()
        {
            if (this.IsDisposed)
            {
                return;
            }

            EventSystem.Instance.Remove(this.InstanceId);
            this.InstanceId = 0;

            // 清理Component
            if (this.components != null)
            {
                foreach (KeyValuePair<Type, Entity> kv in this.components)
                {
                    kv.Value.Dispose();
                }

                this.components.Clear();
                dictPool.Recycle(this.components);
                this.components = null;

                // 从池中创建的才需要回到池中,从db中不需要回收
                if (this.componentsDB != null)
                {
                    this.componentsDB.Clear();

                    if (this.IsFromPool)
                    {
                        hashSetPool.Recycle(this.componentsDB);
                        this.componentsDB = null;
                    }
                }
            }

            // 清理Children
            if (this.children != null)
            {
                foreach (Entity child in this.children.Values)
                {
                    child.Dispose();
                }

                this.children.Clear();
                childrenPool.Recycle(this.children);
                this.children = null;

                if (this.childrenDB != null)
                {
                    this.childrenDB.Clear();
                    // 从池中创建的才需要回到池中,从db中不需要回收
                    if (this.IsFromPool)
                    {
                        hashSetPool.Recycle(this.childrenDB);
                        this.childrenDB = null;
                    }
                }
            }

            // 触发Destroy事件
            EventSystem.Instance.Destroy(this);

            this.domain = null;

            if (this.parent is { IsDisposed: false })
            {
                if (this.IsComponent)
                {
                    this.parent.RemoveComponent(this);
                }
                else
                {
                    this.parent.RemoveChild(this);
                }
            }

            this.parent = null;

            if (this.IsFromPool)
            {
                ObjectPool.Instance.Recycle(this);
            }
            else
            {
                base.Dispose();
            }

            status = EntityStatus.None;
        }

        private void AddToComponentsDB(Entity component)
        {
            if (this.componentsDB == null)
            {
                this.componentsDB = hashSetPool.Fetch();
            }

            this.componentsDB.Add(component);
        }

        private void RemoveFromComponentsDB(Entity component)
        {
            if (this.componentsDB == null)
            {
                return;
            }

            this.componentsDB.Remove(component);
            if (this.componentsDB.Count == 0 && this.IsFromPool)
            {
                hashSetPool.Recycle(this.componentsDB);
                this.componentsDB = null;
            }
        }

        private void AddToComponent(Type type, Entity component)
        {
            if (this.components == null)
            {
                this.components = dictPool.Fetch();
            }

            this.components.Add(type, component);

            if (component is ISerializeToEntity)
            {
                this.AddToComponentsDB(component);
            }
        }

        private void RemoveFromComponent(Type type, Entity component)
        {
            if (this.components == null)
            {
                return;
            }

            this.components.Remove(type);

            if (this.components.Count == 0 && this.IsFromPool)
            {
                dictPool.Recycle(this.components);
                this.components = null;
            }

            this.RemoveFromComponentsDB(component);
        }

        public K GetChild<K>(long id) where K: Entity
        {
            if (this.children == null)
            {
                return null;
            }
            this.children.TryGetValue(id, out Entity child);
            return child as K;
        }

        public Entity AddComponent(Entity component)
        {
            Type type = component.GetType();
            if (this.components != null && this.components.ContainsKey(type))
            {
                throw new Exception($"entity already has component: {type.FullName}");
            }

            component.ComponentParent = this;

            this.AddToComponent(type, component);

            return component;
        }

        public Entity AddComponent(Type type)
        {
            if (this.components != null && this.components.ContainsKey(type))
            {
                throw new Exception($"entity already has component: {type.FullName}");
            }

            Entity component = CreateWithComponentParent(type);

            this.AddToComponent(type, component);

            return component;
        }

        public K GetOrAddComponent<K>() where K : Entity, new()
        {
            K k = GetComponent<K>();
            if (k == null)
                k = AddComponent<K>();
            return k;
        }

        public K AddComponent<K>() where K : Entity, new()
        {
            Type type = typeof (K);
            if (this.components != null && this.components.ContainsKey(type))
            {
                throw new Exception($"entity already has component: {type.FullName}");
            }

            K component = CreateWithComponentParent<K>();

            this.AddToComponent(type, component);
            
            return component;
        }

        public K AddComponent<K, P1>(P1 p1) where K : Entity, new()
        {
            Type type = typeof (K);
            if (this.components != null && this.components.ContainsKey(type))
            {
                throw new Exception($"entity already has component: {type.FullName}");
            }

            K component = CreateWithComponentParent<K, P1>(p1);

            this.AddToComponent(type, component);

            return component;
        }

        public K AddComponent<K, P1, P2>(P1 p1, P2 p2) where K : Entity, new()
        {
            Type type = typeof (K);
            if (this.components != null && this.components.ContainsKey(type))
            {
                throw new Exception($"entity already has component: {type.FullName}");
            }

            K component = CreateWithComponentParent<K, P1, P2>(p1, p2);

            this.AddToComponent(type, component);

            return component;
        }

        public K AddComponent<K, P1, P2, P3>(P1 p1, P2 p2, P3 p3) where K : Entity, new()
        {
            Type type = typeof (K);
            if (this.components != null && this.components.ContainsKey(type))
            {
                throw new Exception($"entity already has component: {type.FullName}");
            }

            K component = CreateWithComponentParent<K, P1, P2, P3>(p1, p2, p3);

            this.AddToComponent(type, component);

            return component;
        }

        public void RemoveComponent<K>() where K : Entity
        {
            if (this.IsDisposed)
            {
                return;
            }

            if (this.components == null)
            {
                return;
            }

            Type type = typeof (K);
            Entity c = this.GetComponent(type);
            if (c == null)
            {
                return;
            }

            this.RemoveFromComponent(type, c);
            c.Dispose();
        }

        public void RemoveComponent(Entity component)
        {
            if (this.IsDisposed)
            {
                return;
            }

            if (this.components == null)
            {
                return;
            }

            Type type = component.GetType();
            Entity c = this.GetComponent(component.GetType());
            if (c == null)
            {
                return;
            }

            if (c.InstanceId != component.InstanceId)
            {
                return;
            }

            this.RemoveFromComponent(type, c);
            c.Dispose();
        }

        public void RemoveComponent(Type type)
        {
            if (this.IsDisposed)
            {
                return;
            }

            Entity c = this.GetComponent(type);
            if (c == null)
            {
                return;
            }

            RemoveFromComponent(type, c);
            c.Dispose();
        }

        public virtual K GetComponent<K>() where K : Entity
        {
            if (this.components == null)
            {
                return null;
            }

            Entity component;
            if (!this.components.TryGetValue(typeof (K), out component))
            {
                return default;
            }

            return (K) component;
        }

        public virtual Entity GetComponent(Type type)
        {
            if (this.components == null)
            {
                return null;
            }

            Entity component;
            if (!this.components.TryGetValue(type, out component))
            {
                return null;
            }

            return component;
        }
        public List<K> GetComponents<K>()
        {
            List<K> list = new List<K>();
            if (this.components == null)
            {
                return list;
            }
            foreach (var kv in components)
            {
                if (kv.Value is K k)
                    list.Add(k);
            }
            return list;
        }
    }
}