using System;

using System.Collections.Generic;

​

namespace Example3

{

    public interface IRepository

    {

        void Add(Dictionary<string, string> data);

    }

​

    public sealed class FakeUserRepository : IRepository

    {

        private readonly List<Dictionary<string, string>> _repo = new List<Dictionary<string, string>>();

        public void Add(Dictionary<string, string> data)

        {

            Console.WriteLine($"User {data["name"]} {data["surname"]} added into the repository");

            _repo.Add(data);

        }

        public List<Dictionary<string,string>> Data => _repo;

    }

​

    public interface IQueue

    {

        IEnumerable<ICommand> Consume();

    }

​

    public sealed class FakeUserQueue : IQueue

    {

        private readonly List<ICommand> _queue = new List<ICommand>();

        public void Push(ICommand command)

        {

            _queue.Add(command);

        }

        public IEnumerable<ICommand> Consume()

        {

            // return ((IEnumerable<ICommand>) _queue).GetEnumerator();

            foreach (ICommand command in _queue)

            {

                yield return command;

            }

        }

    }

​

    public interface ICommandBus

    {

        ICommandBus Route(string command);

​

        void To(ICommandHandler handler);

        void Run();

    }

    public sealed class FakeCommandBus : ICommandBus

    {

        private string _tmpCommand = "";

        private readonly Dictionary<string, ICommandHandler> _routes = new Dictionary<string, ICommandHandler>();

        private readonly IQueue _queue;

​

        public FakeCommandBus(IQueue queue)

        {

            _queue = queue;

        }

​

        public ICommandBus Route(string command)

        {

            _tmpCommand = command;

​

            return this;

        }

​

        public void To(ICommandHandler handler)

        {

            if (string.IsNullOrEmpty(_tmpCommand))

            {

                throw new ArgumentException("In order to use 'To' method, first you have to define a command with 'Route' method.");

            }

            _routes.Add(_tmpCommand, handler);

            _tmpCommand = "";

        }

​

        public void Run()

        {

            //_routes.ToList().ForEach(route => Console.WriteLine(route));

            foreach (var item in _queue.Consume())

            {

                //_routes[item.GetType().Name].Handle<Command>(item);

                var command = _routes[item.GetType().Name];

                var method = command.GetType().GetMethod("Handle");

​

                if (method != null)

                {

                    method.Invoke(command, new object[] { item });

                }

            }

        }

    }

​

    public interface ICommand {}

​

    public abstract class Command : ICommand

    {

        protected Command(Dictionary<string, string> payload)

        {

            Payload = payload;

        }

​

        protected Dictionary<string, string> Payload { get; }

    }

    public sealed class RegisterUser : Command

    {

        public RegisterUser(string name, string surname)

            : base(new Dictionary<string, string>{{"name", name}, {"surname", surname}})

        {

        }

        public string Name => base.Payload["name"];

        public string Surname => base.Payload["surname"];

    }

    public interface ICommandHandler {}

​

    public abstract class CommandHandlerBase<T> : ICommandHandler

        where T: Command

    {

        protected CommandHandlerBase(IRepository repository)

        {

            Repository = repository;

        }

        protected IRepository Repository { get; }

​

        public abstract void Handle(T command);

    }

​

    public sealed class RegisterUserHandlerBase : CommandHandlerBase<RegisterUser>

    {

        public RegisterUserHandlerBase(IRepository repository) : base(repository) {}

        public override void Handle(RegisterUser command)

        {

            Console.WriteLine(command.GetType().Name + " Executed.");

            base.Repository.Add(new Dictionary<string, string>

            {

                {"name", command.Name}, {"surname", command.Surname}

            });

        }

    }

​

​

    class Program3

    {

        static void Main(string[] args)

        {

            var user1 = new RegisterUser(

                name: "Panagiotis",

                surname: "Kosmidis"

            );

            var user2 = new RegisterUser(

                name: "Alexander",

                surname: "Romanenko"

            );

            var fakeUserQueue = new FakeUserQueue();

            var fakeUserRepo = new FakeUserRepository();

            var fakeCommandBus = new FakeCommandBus(fakeUserQueue);

            fakeCommandBus

                .Route("RegisterUser")

                .To(new RegisterUserHandlerBase(fakeUserRepo))

            ;

​

            fakeUserQueue.Push(user1);

            fakeUserQueue.Push(user2);

            fakeCommandBus.Run();

            Console.WriteLine("Users in Repository:");

            for (int i = 0; i < fakeUserRepo.Data.Count; i++)

            {

                Console.WriteLine($"{i + 1} - {fakeUserRepo.Data[i]["name"]} {fakeUserRepo.Data[i]["surname"]}");

            }

        }

    }

}