public static IOutputRepository Get(OutputType type)
        {
            switch (type)
            {
                case OutputType.Csv:
                    return CsvOutputRepository.Instance;

                case OutputType.Json:
                    return JsonOutputRepository.Instance;

                case OutputType.Txt:
                    return TxtOutputRepository.Instance;

                case OutputType.Xml:
                    return XmlOutputRepository.Instance;

                case OutputType.Dot:
                    return DotOutputRepository.Instance;

                case OutputType.None:
                    return NoneOutputRepository.Instance;

                case OutputType.Markdown:
                    return MarkdownOutputRepository.Instance;

                case OutputType.Html:
                    return HtmlOutputRepository.Instance;
            }

            return JsonOutputRepository.Instance;
        }

 public static string GetOuputExtension(OutputType outputType)
 {
     if (outputType == OutputType.Library)
         return ".dll";
     else
         return ".exe";
 }

        public void ActivateMonitors_ActivateById(OutputType output)
        {
            int idMonitorToDelete = AddMonitor(externalMonitor, output);
            monitorsToDelete.Add(idMonitorToDelete);

            externalMonitor.ActivateMonitors(idMonitorToDelete,output);
        }

        public void ActivateMonitors_ActivateByTag(OutputType output)
        {
            int idMonitorToDelete = AddMonitor(externalMonitor, output);
            monitorsToDelete.Add(idMonitorToDelete);

            externalMonitor.ActivateMonitors(tag:tagNew,output:output);
        }

 /// <summary>
 /// Authentication by apiKey, secretKey (optional) and authToken (optional)
 /// </summary>
 /// <param name="apiKey">ApiKey of user</param>
 /// <param name="secretKey">SecretKey. If null, it will be get by ApiKey</param>
 /// <param name="authToken">AuthToken. If null, it will be get by ApiKey and SecretKey</param>
 public Authentication(string apiKey, string secretKey = null, string authToken = null, OutputType? output=null)
 {
     OutputGlobal = GetOutput(output);
     this.apiKey = apiKey;
     this.secretKey = string.IsNullOrEmpty(secretKey) ? GetSecretKey() : secretKey;
     this.authToken = string.IsNullOrEmpty(authToken) ? GetAuthToken() : authToken;
 }

        public static int AddMonitor(ExternalMonitor externalMonitor, OutputType output,bool dnsWithParams=false)
        {
            string testName = "test ping ololo: ololo;" + Common.GenerateRandomString(5);
             string tag = tagNew;
            int[] locationsIds = new int[] { 4, 11 };
            ExternalMonitor.TestType testType = ExternalMonitor.TestType.ping;
            if (dnsWithParams)
                testType = ExternalMonitor.TestType.dns;

            var testparams = new Dictionary<string, string>();
            if (dnsWithParams)
            {
                //testparams.Add("test1", "fffgfygfhgf");
                //testparams.Add("test2", "bbb");
                //testparams.Add("test3", "dddd");
                //testparams.Add("test4", "ffff");
                //testparams.Add("test5", "ffff");

                testparams.Add("server", "google.com");
                testparams.Add("expip", "209.85.148.113");
                testparams.Add("expauth", "A");
            }

            var result = externalMonitor.AddMonitor(
                testType,
                testName,
                url,
                ExternalMonitor.CheckInterval.five,
                tag,
                output: output,
                locationIds: locationsIds,
                testParams: testparams);
            return result.testId;
        }

		public OutputWatcher(OutputType type)
		{
			timer = new Timer();
			this._OutputType=type;
			timer.Enabled = true;
			timer.Interval = 100;
			if (_OutputType == OutputType.Console)
			{
				System.Console.SetOut(writer);
				System.Console.SetError(writer);
			} else if (_OutputType == OutputType.Debug) {
				//TODO
			} else {
				throw new ArgumentException("Cannot Find " + _OutputType.ToString() + "!");
			}
			timer.Tick += delegate(object sender, EventArgs e) { 
				if (Document.Text != writer.ToString())
				{
					Document.Text = writer.ToString();
					changed = true;
				}
			};
			
			Document = new Alsing.SourceCode.SyntaxDocument();
			changed = true;
		}

 /// <summary>
 /// Gets apiKey, secretKey and authToken
 /// </summary>
 /// <param name="userName">Name of user</param>
 /// <param name="password">Password of user</param>
 /// <param name="output">Set global output (or use exists - JSON by default)</param>
 public void Authenticate(string userName, string password,OutputType? output=null)
 {
     OutputGlobal = GetOutput(output);
     apiKey = GetApiKey(userName, password, OutputGlobal);
     secretKey = GetSecretKey();
     authToken = GetAuthToken();
 }

        public OutputWindow(Note note, OutputType outputType)
        {
            Note = note;
            OutputType = outputType;

            InitializeComponent();
        }

 public Arguments()
 {
     Authentication = new Authentication();
     OverrideConfig = new Config();
     Output = OutputType.Json;
     UpdateAssemblyInfoFileName = new HashSet<string>();
 }

 public virtual RestResponse GetMonitorInfo(int monitorId, OutputType? output = null)
 {
     var parameters = new Dictionary<string, object>();
     parameters.Add(Params.monitorId, monitorId);
     RestResponse resp = MakeGetRequest(GetAction(MonitorAction.getMonitorInfo), parameters, output: output);
     return resp;
 }

        public Player(List<Player> players, OutputType outputType)
        {
            writer = new Output(outputType);
            writer.Write("Enter the name of the player: ");
            this.name = Console.ReadLine().Trim();

            writer.Write("Enter the piece you want to use: ");
            this.piece = new Piece(Console.ReadLine().Trim());
            while (players.Select(p => p).Where(x => string.Compare(x.Piece.Symbol, this.piece.Symbol) == 0).Count() >= 1)
            {
                writer.Write("That piece has already been taken.\nChoose a different piece: ");
                this.piece = new Piece(Console.ReadLine().Trim());
            }

            writer.Write("Is this player HUMAN or AI: ");
            do
            {
                var playerType = Console.ReadLine().Trim();
                PlayerType humanOrNot;
                if (Enum.TryParse<PlayerType>(playerType.ToUpper(), out humanOrNot))
                {
                    this.playerType = humanOrNot;
                    break;
                }
                writer.Write("Enter a valid Player Type: [human] or [AI]: ");
                continue;
            } while (true);

            this.order = -1;
        }

 public RestResponse GetAgentInfo(int agentId, OutputType output)
 {
     var parameters = new Dictionary<String, Object>();
     parameters.Add("agentId", agentId);
     parameters.Add("output", output);
     return MakeGetRequest(CustomUserAgentAction.agentInfo, parameters);
 }

 private bool GetSetting(OutputType outputType, OutputLevel outputLevel, bool defaultValue)
 {
     var settingName = string.Format("{0}{1}", outputType, outputLevel);
     var data = System.Configuration.ConfigurationManager.AppSettings[settingName];
     bool result;
     return bool.TryParse(data, out result) ? result : defaultValue;
 }

 /// <summary>
 /// Send benchmark output to the console..
 /// </summary>
 /// <param name="messageFormat">The message format.</param>
 /// <returns><see cref="Benchmark"/> instance for chaining.</returns>
 public Benchmark ToConsole(string messageFormat)
 {
     this.currentMessageFormat = messageFormat;
     this.currentOutputType = OutputType.Console;
     this.timer.Reset();
     this.timer.Start();
     return this;
 }

 public virtual RestResponse ActivateMonitors(int[] monitorIds, string tag, OutputType? output = null, Validation? validation = null)
 {
     var parameters = new Dictionary<string, object>();
     AddIfNotNull(parameters, Params.monitorIds, string.Join(",", monitorIds));
     AddIfNotNull(parameters, Params.tag, tag);
     RestResponse resp = MakePostRequest(GetAction(MonitorAction.activateMonitors), parameters, output: output, validation: validation);
     return resp;
 }

 // Default options
 public ProgramOptions()
 {
     outputName = null;
     outtype = OutputType.Text;
     useGPbased = true;
     enableListing = false;
     useAT = true;
 }

 internal void RenderMessage(string msg, OutputType typ)
 {
     var output = Output.OutputManager.GenerateMessage(msg);
     SetOutput(output);
     Style = GetStyle(typ);
     if ((output as Control) != null)
         (output as Control).Foreground = Foreground;
 }

 public async void Write(string text, OutputType type)
 {
     await RichTextBlock.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
     {
         Paragraph.Inlines.Add(new Run { Text = text, Foreground = new SolidColorBrush(GetColor(type)) });
         ScrollToEnd();
     });
 }

 private Logger(string name, Level level, OutputType outType, ProgressOutputType progressOutType, Node node)
 {
     mName = name;
     mInheritedLevel = level;
     mInheritedOutputType = outType;
     mInheritedProgressOutputType = progressOutType;
     mNode = node;
 }