func (p *Policy) CheckNotMatch(e *event.Event) bool {
	for k, m := range p.r_not_match {
		if m.MatchString(e.Get(k)) {
			return false
		}
	}
	return true
}

// check if any of p's matches are satisfied by the event
func (p *Policy) CheckMatch(e *event.Event) bool {
	for k, m := range p.r_match {
		// if the element does not match the regex pattern, the event does not fully match
		if !m.MatchString(e.Get(k)) {
			return false
		}
	}
	return true
}

func (c *Condition) DoOnTracker(e *event.Event, dot func(*eventTracker)) {
	// c.Lock()
	et, ok := c.eventTrackers[e.IndexName()]
	if !ok {
		et = c.newTracker()
		c.eventTrackers[e.IndexName()] = et
	}
	dot(et)
	// c.Unlock()
}

func (t *Tracker) trackEvent(e *event.Event) {

	// don't track internal events
	if len(e.Get(INTERNAL_TAG_NAME)) != 0 {
		return
	}
	t.total.inc()
	t.updateCounts(e)
	t.updateTimes(e)

}

func (c *Condition) getTracker(e *event.Event) *eventTracker {
	if c.eventTrackers == nil {
		c.eventTrackers = make(map[string]*eventTracker)
	}
	et, ok := c.eventTrackers[e.IndexName()]
	if !ok {
		et = c.newTracker()
		c.eventTrackers[e.IndexName()] = et
	}

	return et
}

// Run the given event though the pipeline
func (p *Pipeline) processEvent(e *event.Event) {

	// update to current state
	e.SetState(event.StatePipeline)

	// track stas for this event
	p.tracker.TrackEvent(e)

	// process this event on every policy
	var pol *escalation.Policy
	for _, pol = range p.policies {
		pol.PassEvent(e)
	}
}

// Run the given event though the pipeline
func (p *Pipeline) Process(e *event.Event) {
	if p.globalPolicy != nil {
		if !p.globalPolicy.CheckMatch(e) || !p.globalPolicy.CheckNotMatch(e) {
			return
		}
	}

	// track stas for this event
	p.tracker.TrackEvent(e)

	// process this event on every policy
	var pol *alarm.Policy
	for _, pol = range p.policies {
		e.WaitInc()
		pol.Process(e, func(in *event.Incident) {
			p.ProcessIncident(in)
		})
	}

}

// start the policy listening for events
func (p *Policy) start() {
	go func() {
		var e *event.Event
		for {
			select {
			case toResolve := <-p.resolve:
				var c *Condition

				// fetch the condition that created this incident
				if toResolve.Status == event.CRITICAL {
					c = p.Crit
				} else if toResolve.Status == event.WARNING {
					c = p.Warn
				}

				if c != nil {
					t := c.getTracker(&toResolve.Event)
					t.refresh()
				}
			case <-p.stop:
				logrus.Info("Stopping policy", p.Name)

				// cleanup the policy. Sometimes they hangaround.
				p.clean()

				// stop this policy from being stopped again
				p.stop = nil

				// catch resolve's that could be sent to this policy
				res := p.resolve
				p.resolve = nil

				go func() {
					for {
						select {
						case <-res:
							logrus.Info("Attempted to resolve an incident on a policy that no longer exists")

						case <-time.After(1 * time.Minute):
							return
						}
					}

				}()
				return
			case e = <-p.in:
				e.SetState(event.StatePolicy)

				// process the event if it matches the policy

				if p.Matches(e) {

					// check critical
					if shouldAlert, status := p.ActionCrit(e); shouldAlert {
						incident := event.NewIncident(p.Name, status, e)
						incident.SetResolve(p.resolve)

						// send send it off to the next hop
						p.next.PassIncident(incident)

						// check warning
					} else if shouldAlert, status := p.ActionWarn(e); shouldAlert {
						incident := event.NewIncident(p.Name, status, e)
						incident.SetResolve(p.resolve)

						// send it off to the next hop
						p.next.PassIncident(incident)
					} else {
						e.SetState(event.StateComplete)
					}
				}

			}
		}
	}()
}

// generate an index name by using group-by statements
func (g grouper) genIndexName(e *event.Event) string {
	return e.IndexName()

}