using System;

using System.Collections.Generic;

using System.Threading;

public class Program

{

    public static void Main()

    {

        var trafficLight = new TrafficLight();

        trafficLight.StartWorking();

    }

}

​

public enum TrafficLightStateType

{

    Red,

    Orange,

    Green,

}

​

public interface ITrafficLightState

{

    TrafficLightStateType Type { get; }

    ITrafficLightState NextColor();

    bool CanDrive();

}

​

public class TrafficLightStateFactory

{

    private Dictionary<TrafficLightStateType, ITrafficLightState> states = new Dictionary<TrafficLightStateType, ITrafficLightState>();

​

    private static TrafficLightStateFactory _instance;

​

    public static TrafficLightStateFactory GetInstance()

    { 

        if(_instance == null)

        {

            _instance = new TrafficLightStateFactory();

        }

​

        return _instance; 

    }

​

    public ITrafficLightState GetState(TrafficLightStateType type)

    {

        if(!states.ContainsKey(type))

        {

            switch (type)

            {

                case TrafficLightStateType.Red:

                    {

                        states[type] = new TrafficLightRedState();

                        break;

                    }

                case TrafficLightStateType.Orange:

                    {

                        states[type] = new TrafficLightOrangeState();

                        break;

                    }

                case TrafficLightStateType.Green:

                    {

                        states[type] = new TrafficLightGreenState();

                        break;

                    }

            }

        };

​

        return states[type];

    }

}

​

public abstract class TrafficLightState : ITrafficLightState

{

    protected TrafficLightStateFactory trafficLightStateFactory;

​

    public TrafficLightState()

    {

        trafficLightStateFactory = TrafficLightStateFactory.GetInstance();

    }

​

    public abstract TrafficLightStateType Type { get; }

​

    public abstract bool CanDrive();

​

    public abstract ITrafficLightState NextColor();

}

​

public class TrafficLightRedState : TrafficLightState

{

    public override TrafficLightStateType Type => TrafficLightStateType.Red;

​

    public override bool CanDrive()

    {

        Console.WriteLine($"{Type} - You can't drive, please wait.");

​

        return false;

    }

​

    public override ITrafficLightState NextColor()

    {

        return trafficLightStateFactory.GetState(TrafficLightStateType.Orange);

    }

}

​

public class TrafficLightOrangeState : TrafficLightState

{

    public override TrafficLightStateType Type => TrafficLightStateType.Orange;

​

    public override bool CanDrive()

    {

        Console.WriteLine($"{Type} - Please get ready to go soon.");

​

        return false;

    }

​

    public override ITrafficLightState NextColor()

    {

        return trafficLightStateFactory.GetState(TrafficLightStateType.Green);

    }

}

​

public class TrafficLightGreenState : TrafficLightState

{

    public override TrafficLightStateType Type => TrafficLightStateType.Green;

​

    public override bool CanDrive()

    {

        Console.WriteLine($"{Type} - Go go go.");

​

        return false;

    }

​

    public override ITrafficLightState NextColor()

    {

        return trafficLightStateFactory.GetState(TrafficLightStateType.Red);

    }

}

​

public class TrafficLight

{

    private ITrafficLightState _state;

    private bool _isWorking = false;

​

    public TrafficLight()

    {

        _state = new TrafficLightRedState();

    }

​

    public void StartWorking()

    {

        _isWorking = true;

​

        while(_isWorking)

        {

            CanDrive();

​

            Thread.Sleep(1500);

​

            NextColor();

        }

    }

​

    public void StopWorking()

    {

        _isWorking = false;

    }

​

    public void NextColor()

    {

        _state = _state.NextColor();

    }

​

    public bool CanDrive()

    {

        return _state.CanDrive();

    }

}