private Brush Convert(TimerState state)
 {
     Brush result = null;
     switch (state)
     {
         case TimerState.Ready:
             result = ReadyBrush;
             break;
         case TimerState.Sprint:
             result = SprintBrush;
             break;
         case TimerState.HomeStraight:
             result = HomeStraightBrush;
             break;
         case TimerState.Break:
             result = BreakBrush;
             break;
         case TimerState.BreakOverrun:
             result = BreanOverrunBrush;
             break;
         default:
             break;
     }
     return result;
 }

 private void buttonStart_Click(object sender, EventArgs e)
 {
     switch (this.timerState)
     {
         case TimerState.Stopped:
             this.elapsedTime = TimeSpan.FromSeconds(0);
             this.timer.Start();
             this.labelTime.Text = Config.GetTimeString(TimeSpan.FromSeconds(0));
             this.buttonStart.Text = @"Pause";
             this.timerState = TimerState.Started;
             this.buttonStop.Enabled = true;
             break;
         case TimerState.Started:
             this.timer.Stop();
             this.buttonStart.Text = @"Start";
             this.config.Save();
             this.timerState = TimerState.Paused;
             break;
         case TimerState.Paused:
             this.timer.Start();
             this.buttonStart.Text = @"Pause";
             this.timerState = TimerState.Started;
             break;
         default:
             break;
     }
 }

 public void Stop()
 {
     State = TimerState.Stopped;
     CurrentTime = TimeSpan.Zero;
     OnStopped();
     Stopped.Raise(this, EventArgs.Empty);
 }

        public Timer()
        {
            if (System.Diagnostics.Debugger.IsAttached)
            {
                m_SprintDuration = TimeSpan.FromSeconds(10);
                m_HomeStraightDuration = TimeSpan.FromSeconds(1);
                m_BreakDuration = TimeSpan.FromSeconds(5);
                m_MaxBreakDuration = TimeSpan.FromSeconds(10);
            }
            else
            {
                m_SprintDuration = TimeSpan.FromMinutes(25);
                m_HomeStraightDuration = TimeSpan.FromMinutes(1);
                m_BreakDuration = TimeSpan.FromMinutes(5);
                m_MaxBreakDuration = TimeSpan.FromMinutes(60);
            }

            m_InternalStates = new Dictionary<TimerState, ITimerState>();
            m_InternalStates.Add(TimerState.Ready, new ReadyTimerState(this));
            m_InternalStates.Add(TimerState.Sprint, new SprintTimerState(this));
            m_InternalStates.Add(TimerState.HomeStraight, new HomeStraightTimerState(this));
            m_InternalStates.Add(TimerState.Break, new BreakTimerState(this));
            m_InternalStates.Add(TimerState.BreakOverrun, new BreakOverrunTimerState(this));

            m_Timer = new DispatcherTimer() { Interval = TimeSpan.FromSeconds(1) };
            m_Timer.Tick += (s, e) => m_InternalState.HandleSecondElapsed();

            _State = TimerState.Ready;
            m_InternalState = m_InternalStates[_State];
            m_InternalState.OnEnter();
        }

 // Use this for initialization
 void Start()
 {
     actualTimeRemaining = 0f;
     minutesRemaining = 0;
     secondsRemaining = 0;
     timerState = TimerState.PAUSED;
     gameManagerScript = gameManagerObject.GetComponent<GameManager>();
 }

        public static string GetStateString(TimerState state)
        {
            var formatString = " ({0}{1})";
            var workOrBreak = state.ToString().Contains("Work") ? "work" : "break";
            var paused = state.ToString().Contains("Pause") ? " paused" : "";

            return string.Format(formatString, workOrBreak, paused);
        }

 internal static void InvokeEventHandler(EventHandler<TimerStateChangedEventArgs> handler, object sender, TimerState previousState, TimerState newState)
 {
     var snapshot = handler;
     if (snapshot != null)
     {
         snapshot.DynamicInvoke(sender, new TimerStateChangedEventArgs(previousState, newState));
     }
 }

 public Timer() {
     this.interval = 10;
     this.loop = true;
     this.showCountDown = true;
     this.onClientElapsed = "";
     this.finalSecondsBlink = false;
     this.finalSecondsThreshold = 0;
     this.timerState = TimerState.Started;
 }

        public PerformanceTimer()
        {
            timerState = TimerState.Stopped;

            if (QueryPerformanceFrequency(ref tickFreq) == false)
            {
                throw new ApplicationException("Failed to query for the performance frequency!");
            }
        }

        public void Reset()
        {
            // Stop tracking and reset time
            timer.Stop();
            TimerState = TimerState.Stopped;

            startTime = DateTime.Now;
            endTime = startTime;

            CalculateCurrentSpan(endTime, startTime);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SimpleScheduler"/> class.
        /// </summary>
        /// <param name="applicationMapPath">
        /// The application map path.
        /// </param>
        /// <param name="connection">
        /// The connection.
        /// </param>
        /// <param name="period">
        /// The period.
        /// </param>
        /// <remarks>
        /// </remarks>
        protected SimpleScheduler(string applicationMapPath, IDbConnection connection, long period)
        {
            this.localSchDB = new SchedulerDB(connection, applicationMapPath);
            this.localPeriod = period;

            this.localTimerState = new TimerState();

            var t = new Timer(this.Schedule, this.localTimerState, Timeout.Infinite, Timeout.Infinite);

            this.localTimerState.Timer = t;
        }

    // Update is called once per frame
    void Update()
    {
        if (state == TimerState.Started) {
            timeRemaining -= Time.deltaTime;
            timerLabel.text = string.Format("Time Remaining: {0}", Mathf.RoundToInt(timeRemaining));

            if (timeRemaining < 0f) {
                state = TimerState.Stopped;
                GameManager.Instance.OnOutOfTime();
            }
        }
    }

        public void Update(GameTime gameTime)
        {
            if(State!=TimerState.Running) return;

            CurrentTime += gameTime.ElapsedGameTime.TotalMilliseconds;
            if (CurrentTime >= TargetTime)
            {
                CurrentTime = 0;

                if (!Looping) State = TimerState.Finished;

                _callback();
            }
        }

 public RedditAuth(IWebAgent agent)
 {
     _uname = ConfigurationManager.AppSettings["BotUsername"];
     _pass = ConfigurationManager.AppSettings["BotPassword"];
     _clientId = ConfigurationManager.AppSettings["ClientID"];
     _clientSecret = ConfigurationManager.AppSettings["ClientSecret"];
     _redirectUri = ConfigurationManager.AppSettings["RedirectURI"];
     if ( string.IsNullOrEmpty( _uname ) ) throw new Exception( "Missing 'BotUsername' in config" );
     if ( string.IsNullOrEmpty( _pass ) ) throw new Exception( "Missing 'BotPassword' in config" );
     if ( string.IsNullOrEmpty( _clientId ) ) throw new Exception( "Missing 'ClientID' in config" );
     if ( string.IsNullOrEmpty( _clientSecret ) ) throw new Exception( "Missing 'ClientSecret' in config" );
     if ( string.IsNullOrEmpty( _redirectUri ) ) throw new Exception( "Missing 'RedirectURI' in config" );
     _webAgent = agent;
     _timerState = new TimerState();
 }

        public void ChangeState(TimerState state)
        {
            using (var session = DocumentStore.OpenSession())
            {
                session.Store(new StateChangedEvent
                {
                    Date = DateTimeOffset.Now,
                    OldState = CurrentState,
                    NewState = state
                });
                session.SaveChanges();
            }

            CurrentState = state;

            if (StateChanged != null)
            {
                StateChanged(state);
            }
        }

        public void ToggleStartStop()
        {
            // Toggle tracking
            if (TimerState == TimerState.Stopped)
            {
                // Same behavior for reset and stop
                startTime = DateTime.Now;
                timer.Start();
                TimerState = TimerState.Tracking;
            }
            else
            {
                endTime = DateTime.Now;
                timer.Stop();

                // Call event that the time was tracked
                OnTimeTracked();

                // Reset time after tracking
                Reset();
            }
        }

        public Timer(
			Guid id,
			string name,
			string description,
			TimeSpan interval,
			TimerState state,
			TimeSpan elapsedTime,
			EventHandlerCollection eventHandlerCollection = null)
        {
            name.ThrowIfNull("name");
            description.ThrowIfNull("description");
            if (interval < TimeSpan.Zero)
            {
                throw new ArgumentOutOfRangeException("interval");
            }

            _id = id;
            Name = name;
            Description = description;
            _interval = interval;
            _eventHandlerCollection = eventHandlerCollection;
            State = state;
            ElapsedTime = elapsedTime;
        }

        public void ChangeState(TimerState state)
        {
            if(state == CurrentState)
                return;

            using (var session = DocumentStore.OpenSession())
            {
                session.Store(new StateChangedEvent
                {
                    MachineName = Environment.MachineName,
                    Date = DateTimeOffset.Now,
                    OldState = CurrentState,
                    NewState = state
                });
                session.SaveChanges();
            }

            CurrentState = state;

            if (StateChanged != null)
            {
                StateChanged(state);
            }
        }

        private void TimerForm_Load(object sender, EventArgs e)
        {
            // Timer object fires once per second
            timerState = TimerState.INIT;
            t = new Timer();
            t.Interval = 1000;
            t.Tick += DecrementTimer;

            // subscribe view
            TimerChanged += UpdateView;
        }

        private void RunTimer()
        {
            // input validation
            if (!(int.TryParse(txtSec.Text, out seconds))
                || !(int.TryParse(txtMin.Text, out minutes))
                || !(int.TryParse(txtHrs.Text, out hours)))
            {
                return;
            }

            txtSec.ReadOnly = true; // while timer runs
            txtMin.ReadOnly = true;
            txtHrs.ReadOnly = true;
            timerState = TimerState.STARTED;
            DecrementTimer(this, new EventArgs()); // don't want to wait a full second before starting countdown
            t.Start();
            btnStart.Text = "Stop";
        }