// GoF: Command

using System;

using System.Collections.Generic;

using System.Linq;

​

public class Employee

{

    public int Id { get; private set; }

    public string Name { get; private set; }

    public Employee(int id, string name)

    {

        Id = id;

        Name = name;

    }

}

​

public class Manager: Employee

{

    public List<Employee> Employees { get; }    

    public Manager(int id, string name) : base(id, name) 

    {

        Employees = new();

    }   

}

​

// Receiver (interface)

public interface IManagerEmployeeRepository

{

    void AddEmployee(int managerId, Employee employee);

    void RemoveEmployee(int managerId, Employee employee);

    bool HasEmployee(int managerId, Employee employee);

    void Dump();

}

​

// Receiver (implementation)

public class ManagerEmployeeRepository: IManagerEmployeeRepository

{

    private List<Manager> _managers = new() 

    {

        new Manager(101, "Serge"),

        new Manager(102, "Betty")

    };

    public void AddEmployee(int managerId, Employee employee)

    {

        _managers.FirstOrDefault(m => m.Id == managerId).Employees.Add(employee);

    }

    public void RemoveEmployee(int managerId, Employee employee) 

    {

        _managers.FirstOrDefault(m => m.Id == managerId).Employees.Remove(employee);

    }

    public bool HasEmployee(int managerId, Employee employee)

    {

        return _managers.FirstOrDefault(m => m.Id == managerId)?.Employees.Any(e => e.Id == employee.Id) ?? false;

    }

    public void Dump()

    {   

        foreach(var manager in _managers) 

        {

            Console.WriteLine($"Manager {manager.Name}:");

            foreach(var employee in manager.Employees)

            {

                Console.WriteLine($"\tEmployee {employee.Name}");

            }

        }

    }

}

​

// Command

public interface ICommand

{

    bool CanExecute();

    void Execute();

    void Undo();

}

​

// Concrete command

public class AddEmployeeToManagerCommand: ICommand

{

    private int _managerId;

    private Employee _employee;

    private IManagerEmployeeRepository _repository;

​

    public AddEmployeeToManagerCommand(int managerId, Employee employee, IManagerEmployeeRepository repository) 

    {

        _managerId = managerId;

        _employee = employee;

        _repository = repository;

    }

    public bool CanExecute()

    {

        if(_employee == null) return false;

        if(_repository.HasEmployee(_managerId, _employee)) return false;

        return true;

    }

    public void Execute()

    {

        if(_employee == null) return;

        _repository.AddEmployee(_managerId, _employee);

    }

    public void Undo()

    {

        if(_employee == null) return;

        _repository.RemoveEmployee(_managerId, _employee);

    }

}

​

// Invoker

public class CommandManager

{

    private Stack<ICommand> _commands = new();

    public void Invoke(ICommand command)

    {

        if(command != null && command.CanExecute())

        {

            Console.WriteLine("Exec");

            command.Execute();

            _commands.Push(command);

        }

    }

    public void Undo()

    {

        if(_commands.Any())

        {

            _commands.Pop()?.Undo();

        }

    }

    public void UndoAll()

    {

        while(_commands.Any())

        {   

            _commands.Pop()?.Undo();

        }

    }

}

public class Program

{

    public static void Main()

    {

        CommandManager cmdMng = new();

        ManagerEmployeeRepository repository = new();

        Console.WriteLine("Initial:");

        repository.Dump();

        // Adding Tom to Serge

        cmdMng.Invoke(new AddEmployeeToManagerCommand(101, new Employee(201, "Tom"), repository));

        // Adding Mark to Betty

        cmdMng.Invoke(new AddEmployeeToManagerCommand(102, new Employee(202, "Mark"), repository));

        // Adding Alice to Serge

        cmdMng.Invoke(new AddEmployeeToManagerCommand(101, new Employee(203, "Alice"), repository));        

        Console.WriteLine("\nAdded 3 employees:");

        repository.Dump();

        // Another attempt to add Mark to Betty

        cmdMng.Invoke(new AddEmployeeToManagerCommand(102, new Employee(202, "Mark"), repository));     

        Console.WriteLine("\nAdded Mark the 2nd time:");

        repository.Dump();

        // Undo last command:

        cmdMng.Undo();      

        Console.WriteLine("\nUndid the last command:");

        repository.Dump();

        // UndoAll last command:

        cmdMng.UndoAll();       

        Console.WriteLine("\nUndid the all commands:");

        repository.Dump();      

    }

}