using System;

using System.Linq;

using System.Timers;

using System.Collections.Generic;

using System.Runtime.Serialization;

public class Program

{

    public static void Main()

    {

        SceneManager.Instance.Spawn(new Player());

    }

    public sealed class SceneManager

    {

        static SceneManager _instance;

        public SceneManager Instance

        {

            get { return _instance ?? (_instance = new SceneManager()); }   

        }

        List<GameEntity> _entities;

        Timer _timer;

        private SceneManager()

        {

            _entities = new List<GameEntity>();

            _timer = new Timer();

            _timer.Interval = 1000; // every one second update everything.

            _timer.Elapsed += WhenTimerElapsed;

        }

        public void Spawn(GameEntity entity)

        {

            _entities.Add(entity);  

        }

        void WhenTimerElapsed(object sender, EventArgs e)

        {

            UpdateScene();  

        }

        void UpdateScene()

        {

            foreach(var entity in _entities) { entity.Update(); }   

        }

    }

    public abstract class Component

    {

        internal static T Create<T>(GameEntity parent)

            where T : Component

        {

            T component = (T)FormatterServices.GetUninitializedObject(typeof(T));

            component.Initialize();

            component.Parent = parent;

            return component;

        }

        protected GameEntity Parent { get; private set; }

        protected abstract void Initialize();

        public static implicit operator GameEntity(Component component)

        {

            return component.Parent;    

        }

        public virtual void Update()

        {

            Console.WriteLine("ComponentUpdated");  

        }

    }

    public sealed class EnemyBehaviour

        : Component

    {

        protected override void Initialize()

        {

            if (!Parent.HasComponent<Attributes>()) 

                Parent.AddComponent<Attributes>();

        }

        void DoDamage(GameEntity entity)

        {

            if(entity.HasComponent<Mortality>())

            {

                double damage = Parent.GetComponent<Attributes>().Strength * 1.3;

                entity.GetComponent<Mortality>().DoDamage(damage);

            }

        }

    }

    public sealed class Attributes

        : Component

    {

        double _strength = 12;

        public double Strength

        {

            get { return _strength; }

            set { _strength = value; }

        }

        protected override void Initialize()

        {

            _strength = 12; 

        }

    }

    public sealed class Controller

        : Component

    {

        protected override void Initialize()

        {

            // subscribe to some event like :

            // InputManager.InputReceived += WhenInputReceived

        }

        void WhenInputReceived(/*InputData inputData*/)

        {

            // do something with input data     

        }

    }

    public sealed class Dialogue

        : Component

    {

        Dictionary<string, string> _dialogues;

        protected override void Initialize()

        {

            _dialogues = new Dictionary<string, string>();  

        }

        public string Echo(string message)

        {

            if(_dialogues.ContainsKey(message.ToLower()))

                return _dialogues[message.ToLower()];

            return "I dont know what you're talking about!";

        }

    }

    public sealed class Mortality

        : Component

    {

        double _maxHealth;

        public double MaxHealth

        {

            get { return _maxHealth; }

            set { _maxHealth = value; }

        }

        double _health;

        public double Health

        {

            get { return _health; }

            set { _health = value; }

        }

​

        protected override void Initialize()

        {

            _maxHealth = 100;

            _health = _maxHealth;

        }

        public void DoDamage(double damage)

        {

            _health -= damage;

            if(_health <= 0)

            {

                _health = 0;

                // do something because entity is dead

                // GameManager.RemoveEntity(this)

            }

        }

    }

    public abstract class GameEntity

    {

        List<Component> _components;

        public GameEntity()

        {

            _components = new List<Component>();

        }

        public T AddComponent<T>()

            where T : Component

        {

            _components.Add(Component.Create<T>(this));

            return (T)_components.Last();

        }

        public bool HasComponent<T>()

            where T : Component

        {

            return _components.OfType<T>().Count() > 0;     

        }

        public T GetComponent<T>()

            where T : Component

        {

            return _components.OfType<T>().FirstOrDefault();        

        }

        public void Update()

        {

            foreach(Component component in _components){ component.Update(); }  

        }

    }

    public class Creature // this class contains { Mortality } component

        : GameEntity

    {

        public Creature()

            : base()

        {

            AddComponent<Mortality>();

        }

    }

    public class NPC // this class contains { Mortality, Dialogue } components

        : Creature

    {

        public NPC()

            : base()

        {

            AddComponent<Dialogue>();       

        }

    }

    public class Player // this class contains { Mortality, Controller } components

        : Creature

    {

        public Player()

            : base()

        {

            AddComponent<Controller>();     

        }

    }

    public class Enemy

        : Creature

    {

        public Enemy()

            : base()

        {

            AddComponent<EnemyBehaviour>();     

        }

    }

}