func (f *InfoFilter) Filter(msg *gol.LogMessage) bool {
	if s, err := msg.Severity(); err != nil {
		// no severity
		return true
	} else {
		return s < severity.Warning
	}
}

// Filter performs a filter check on the given message.
// Returns whether or not a given message should be filtered.
func (f Severity) Filter(msg *gol.LogMessage) bool {

	if s, err := msg.Severity(); err != nil {
		// no severity
		return true
	} else {
		return s > f.minimum
	}
}

// Format formats the log message.
func (f Text) Format(msg *gol.LogMessage) (string, error) {
	lmsg := msg.FieldLength()
	buffer := make([]string, lmsg, lmsg)

	i := 0
	for k, v := range *msg {
		buffer[i] = fmt.Sprintf("%s=%s", k, v)
		i += 1
	}

	return fmt.Sprintf("%s\n", strings.Join(buffer, " ")), nil
}

func (s *MessageTestSuite) TestTimestamp() {
	var msg *gol.LogMessage

	msg = &gol.LogMessage{"key": "value"}
	v, err := msg.Timestamp()
	assert.Equal(s.T(), fmt.Errorf("Message does not contain field timestamp"), err)
	assert.Nil(s.T(), v)

	msg = gol.NewInfo("key", "value")
	v, err = msg.Timestamp()
	assert.Nil(s.T(), err)
	assert.True(s.T(), v.Before(time.Now()))
}

// Filter performs a filter check on the given message.
// Returns whether or not a given message should be filtered.
func (f Threshold) Filter(msg *gol.LogMessage) bool {
	var start *time.Time
	var stop *time.Time
	var err error

	if start, err = msg.Start(); err != nil {
		return true
	}
	if stop, err = msg.Stop(); err != nil {
		return true
	}

	return stop.Sub(*start) >= f.threshold
}

func (s *MessageTestSuite) TestGet() {
	msg := gol.LogMessage{
		"key": "value",
	}

	assert.Equal(s.T(), msg["key"], "value")

	v, err := msg.Get("key")
	assert.Equal(s.T(), "value", v)
	assert.Nil(s.T(), err)

	v, err = msg.Get("unknown")
	assert.Nil(s.T(), v)
	assert.Equal(s.T(), fmt.Errorf("Message does not contain field unknown"), err)
}

// Format formats the log message.
func (f Custom) Format(msg *gol.LogMessage) (string, error) {
	lmsg := msg.FieldLength()
	buffer := make([]string, lmsg, lmsg)

	i := 0
	for k, v := range *msg {
		if k != fields.Severity && k != fields.Timestamp {
			buffer[i] = fmt.Sprintf("%s:'%s'", k, v)
			i += 1
		}
	}

	t, _ := msg.Timestamp()

	if severity, err := msg.Severity(); err != nil {
		return fmt.Sprintf("%s UNKNOWN %s\n", t.String(), strings.Join(buffer, " ")), nil
	} else {
		switch severity >= field_severity.Error {
		case true:
			return fmt.Sprintf("%s %s %s\n", t.String(), color.RedString("%s", severity), strings.Join(buffer, " ")), nil
		default:
			return fmt.Sprintf("%s %s %s\n", t.String(), severity, strings.Join(buffer, " ")), nil
		}
	}
}

// Send process log message.
func (l *Logger) Send(m *gol.LogMessage) (err error) {
	if m == nil {
		return
	}
	if l.Formatter() == nil {
		return fmt.Errorf("log formatter is nil")
	}

	var msg string
	if msg, err = l.Formatter().Format(m); err != nil {
		return
	}

	var lvl severity.Type
	if lvl, err = m.Severity(); err != nil {
		return
	}

	switch lvl {
	case severity.Emergency:
		return l.writer.Emerg(msg)
	case severity.Alert:
		return l.writer.Alert(msg)
	case severity.Critical:
		return l.writer.Crit(msg)
	case severity.Error:
		return l.writer.Err(msg)
	case severity.Warning:
		return l.writer.Warning(msg)
	case severity.Notice:
		return l.writer.Notice(msg)
	case severity.Info:
		return l.writer.Info(msg)
	case severity.Debug:
		return l.writer.Debug(msg)
	default:
		return l.writer.Info(msg)
	}
}

func (s *MessageTestSuite) TestGetSetStop() {
	msg := gol.LogMessage{
		"key": "value",
	}

	v, err := msg.Stop()
	assert.Equal(s.T(), &time.Time{}, v)
	assert.Equal(s.T(), fmt.Errorf("Message does not contain field stop"), err)

	stop := time.Now()
	msg.SetStop(&stop)

	v, err = msg.Stop()
	assert.Equal(s.T(), &stop, v)
	assert.Nil(s.T(), err)
}

func (s *MessageTestSuite) TestGetSetSeverity() {
	msg := gol.LogMessage{
		"key": "value",
	}

	v, err := msg.Severity()
	assert.Equal(s.T(), severity.Type(-1), v)
	assert.Equal(s.T(), fmt.Errorf("Message does not contain field severity"), err)

	lvl := severity.Type(severity.Emergency)
	msg.SetSeverity(lvl)

	v, err = msg.Severity()
	assert.Equal(s.T(), lvl, v)
	assert.Nil(s.T(), err)
}

func (s *MessageTestSuite) TestFieldLength() {
	msg := gol.LogMessage{
		"key": "value",
	}
	assert.Equal(s.T(), 1, msg.FieldLength())
}