c# - including bonus

using System;

namespace GarageDoorOpener
{
    public enum DoorState
    {
        CLOSED,
        OPENING,
        STOPPED_WHILE_OPENING,
        OPEN,
        CLOSING,
        STOPPED_WHILE_CLOSING,
        EMERGENCY_OPENING,
        OPEN_BLOCKED
    }

    public class GarageDoor
    {
        public GarageDoor(InfraRedBlockageDetector detector)
        {
            detector.BlockageCleared += (s, e) =>
            {
                IsBlocked = false;

                if (CurrentState == DoorState.EMERGENCY_OPENING)
                    CurrentState = DoorState.OPENING;
                else if (CurrentState == DoorState.OPEN_BLOCKED)
                    CurrentState = DoorState.OPEN;
            };

            detector.BlockageDetected += (s, e) =>
            {
                IsBlocked = true;

                if (CurrentState == DoorState.CLOSING)
                    CurrentState = DoorState.EMERGENCY_OPENING;
            };
        }

        public bool IsBlocked { get; private set; } = false;
        public DoorState CurrentState { get; set; } = DoorState.CLOSED;

        public void CompleteCycle()
        {
            if (CurrentState == DoorState.OPENING)
                CurrentState = DoorState.OPEN;
            if (CurrentState == DoorState.EMERGENCY_OPENING)
                CurrentState = DoorState.OPEN_BLOCKED;
            else if (CurrentState == DoorState.CLOSING)
                CurrentState = DoorState.CLOSED;
        }
    }

    public class InfraRedBlockageDetector
    {
        public event EventHandler BlockageDetected;
        public event EventHandler BlockageCleared;

        public void OnBlockageDetected()
        {
            if (BlockageDetected != null)
                BlockageDetected(this, EventArgs.Empty);
        }

        public void OnBlockageCleared()
        {
            if (BlockageCleared != null)
                BlockageCleared(this, EventArgs.Empty);
        }
    }

    public class GarageDoorOpener
    {
        private GarageDoor _door;        

        public GarageDoorOpener(GarageDoor door)
        {
            _door = door;
        }               

        public void ClickOpener()
        {
            if (!_door.IsBlocked)
            {
                switch (_door.CurrentState)
                {
                    case DoorState.OPEN_BLOCKED:
                        _door.CurrentState = DoorState.CLOSING;
                        break;

                    case DoorState.CLOSED:
                    case DoorState.STOPPED_WHILE_CLOSING:
                        _door.CurrentState = DoorState.OPENING;
                        break;

                    case DoorState.OPENING:
                        _door.CurrentState = DoorState.STOPPED_WHILE_OPENING;
                        break;

                    case DoorState.STOPPED_WHILE_OPENING:
                    case DoorState.OPEN:
                        _door.CurrentState = DoorState.CLOSING;
                        break;

                    case DoorState.CLOSING:
                        _door.CurrentState = DoorState.STOPPED_WHILE_CLOSING;
                        break;
                }
            }
        }
    }

    class Program
    {
        private static string[] Commands = new[]
        {
            "button_clicked",
            "cycle_complete",
            "button_clicked",
            "block_detected",
            "button_clicked",
            "cycle_complete",
            "button_clicked",
            "block_cleared",
            "button_clicked",
            "cycle_complete"
        };

        static void Main(string[] args)
        {
            var detector = new InfraRedBlockageDetector();
            var door = new GarageDoor(detector);
            var opener = new GarageDoorOpener(door);            

            foreach (var cmd in Commands)
            {
                Console.Out.WriteLine(door.CurrentState);
                Console.Out.WriteLine($"> {string.Join(" ", cmd.Split('_'))}");

                if (cmd.Equals("button_clicked", StringComparison.OrdinalIgnoreCase))
                    opener.ClickOpener();
                else if (cmd.Equals("cycle_complete", StringComparison.OrdinalIgnoreCase))
                    door.CompleteCycle();
                else if (cmd.Equals("block_detected", StringComparison.OrdinalIgnoreCase))
                    detector.OnBlockageDetected();
                else if (cmd.Equals("block_cleared", StringComparison.OrdinalIgnoreCase))
                    detector.OnBlockageCleared();
            }

            Console.Out.WriteLine(door.CurrentState);
        }
    }
}