func (f *Formatter) sprintfColor(c *color.Color, format string, args ...interface{}) string {
	if f.DisabledColor || c == nil {
		return fmt.Sprintf(format, args...)
	} else {
		return c.SprintfFunc()(format, args...)
	}
}

// returns a function that will format and writes the line extracted from the logs of a given container
func write(prefix string, color *ansi.Color, timestamps bool) func(dest io.Writer, token []byte) (n int, err error) {
	return func(dest io.Writer, token []byte) (n int, err error) {
		countingWriter := countingWriter{Writer: dest}
		if color != nil {
			ansi.Output = &countingWriter
			color.Set()
		}
		_, err = countingWriter.Write([]byte(prefix))
		if err == nil {
			if !timestamps {
				// timestamps are always present in the incoming stream for
				// sorting purposes, so we strip them if the user didn't ask
				// for them
				const timestampPrefixLength = 31
				strip := timestampPrefixLength
				if string(token[0]) == "[" {
					// it seems that timestamps are wrapped in [] for events
					// streamed  in real time during a `docker logs -f`
					strip = strip + 2
				}
				token = token[strip:]
			}
			_, err = countingWriter.Write(token)
		}
		if err == nil {
			if color != nil {
				ansi.Unset()
			}
			_, err = dest.Write([]byte("\n"))
		}
		return countingWriter.written, err

	}
}

// Print the codeword contents and type to terminal. For debugging.
func (c *Codeword) Print() {

	payload := ""
	var color *color.Color = blue

	switch c.Type {

	case CodewordTypeAddress:
		payload = c.Adress()
		color = red

	case CodewordTypeMessage:
		payload = ""
		color = green

	default:
		color = blue

	}

	parity := utils.TernaryStr(c.ValidParity, "", "*")
	color.Printf("%s %s %s ", c.Type, payload, parity)
	corr := c.BitCorrections
	if corr > 0 {
		color.Printf("%d bits corrected", corr)
	}

	println("")
}

func (l *Log) format(timestamp bool, level int, format string, args []interface{}) string {
	ts := ""
	if timestamp {
		f := l.Palette.Timestamp.SprintfFunc()
		ts = f(
			"%s", time.Now().Format(l.TimeFmt),
		)
	}
	var p *color.Color
	switch level {
	case say:
		p = l.Palette.Say
	case notice:
		p = l.Palette.Notice
	case warn:
		p = l.Palette.Warn
	case shout:
		p = l.Palette.Shout
	case header:
		p = l.Palette.Header
	default:
		panic("unknown log level")
	}
	return ts + p.SprintfFunc()(format, args...)
}

func printDatagram(out *color.Color, d *protocol.Datagram) {
	re := regexp.MustCompilePOSIX("^00000")

	out.Printf("FROM: %s\n", d.From)
	out.Printf("SIZE: %d\n", len(d.Data))
	data := strings.TrimLeft(hex.Dump(d.Data), "0")
	out.Printf("DATA: 000" + re.ReplaceAllString(data, "      "))
	color.Set(color.Bold)
}

func (s *RangeHistogram) ResumeHistogram(out *color.Color) {
	out.Printf("\n %s:", s.name_)

	sortedHisto := make([]int, len(s.data_))

	minKey := 999999999
	maxKey := 0
	for key, _ := range s.data_ {
		if key < minKey {
			minKey = key
		}
		if key > maxKey {
			maxKey = key
		}
	}

	for key, val := range s.data_ {
		sortedHisto[key-minKey] = val
	}

	for k, v := range sortedHisto {
		out.Printf("\n [%d]: %d", k, v)
	}
}

func (b *Buntstift) printf(Color *color.Color, format string, a ...interface{}) (n int, err error) {
	Color.Set()
	defer b.unsetColor()
	return fmt.Fprintf(Output, format, a...)
}

// Print a thick line break (of '=' characters).
func boldLine(c *color.Color) {
	c.Set()
	defer colorUnset()
	lineBreak("=")
}

// Print a thin line break (of '-' characters).
func line(c *color.Color) {
	c.Set()
	defer colorUnset()
	lineBreak("-")
}

func Render(dst io.Writer, src eventstream.EventStream) int {
	var buildConfig event.TaskConfig

	exitStatus := 0

	for {
		ev, err := src.NextEvent()
		if err != nil {
			if err == io.EOF {
				return exitStatus
			} else {
				fmt.Fprintf(dst, "failed to parse next event: %s\n", err)
				return 255
			}
		}

		switch e := ev.(type) {
		case event.Log:
			fmt.Fprintf(dst, "%s", e.Payload)

		case event.InitializeTask:
			buildConfig = e.TaskConfig

			if buildConfig.Image != "" {
				fmt.Fprintf(dst, "\x1b[1minitializing with %s\x1b[0m\n", buildConfig.Image)
			} else {
				fmt.Fprintf(dst, "\x1b[1minitializing\x1b[0m\n")
			}

		case event.StartTask:
			argv := strings.Join(append([]string{buildConfig.Run.Path}, buildConfig.Run.Args...), " ")
			fmt.Fprintf(dst, "\x1b[1mrunning %s\x1b[0m\n", argv)

		case event.FinishTask:
			exitStatus = e.ExitStatus

		case event.Error:
			errCol := ui.ErroredColor.SprintFunc()
			fmt.Fprintf(dst, "%s\n", errCol(e.Message))

		case event.Status:
			var printColor *color.Color

			switch e.Status {
			case "started":
				continue
			case "succeeded":
				printColor = ui.SucceededColor
			case "failed":
				printColor = ui.FailedColor

				if exitStatus == 0 {
					exitStatus = 1
				}
			case "errored":
				printColor = ui.ErroredColor

				if exitStatus == 0 {
					exitStatus = 2
				}
			case "aborted":
				printColor = ui.AbortedColor

				if exitStatus == 0 {
					exitStatus = 3
				}
			default:
				fmt.Fprintf(dst, "unknown status: %s", e.Status)
				return 255
			}

			printColorFunc := printColor.SprintFunc()
			fmt.Fprintf(dst, "%s\n", printColorFunc(e.Status))

			return exitStatus
		}
	}

	return 255
}

func (s *ScalarStatistic) Resume(out *color.Color) {
	out.Printf("\n %s: %d", s.name_, s.total_)
}

func (s *RangeStatistic) ResumeRangeAv(out *color.Color) {
	out.Printf("\n %s: min=%d, max=%d av=%f", s.name_, s.min_, s.max_, float64(s.total_)/float64(s.count_))
}

func (s *RangeStatistic) ResumeRange(out *color.Color) {
	out.Printf("\n %s: min=%d, max=%d", s.name_, s.min_, s.max_)
}

func (s *ScalarStatistic) ResumeAv(out *color.Color) {
	out.Printf("\n %s av: %f", s.name_, float64(s.total_)/float64(s.count_))
}

// consolePrintln - same as print with a new line.
func consolePrintln(tag string, c *color.Color, a ...interface{}) {
	privateMutex.Lock()
	defer privateMutex.Unlock()

	switch tag {
	case "Debug":
		output := color.Output
		color.Output = stderrColoredOutput
		if isatty.IsTerminal(os.Stderr.Fd()) {
			c.Print(ProgramName() + ": <DEBUG> ")
			c.Println(a...)
		} else {
			fmt.Fprint(color.Output, ProgramName()+": <DEBUG> ")
			fmt.Fprintln(color.Output, a...)
		}
		color.Output = output
	case "Fatal":
		fallthrough
	case "Error":
		output := color.Output
		color.Output = stderrColoredOutput
		if isatty.IsTerminal(os.Stderr.Fd()) {
			c.Print(ProgramName() + ": <ERROR> ")
			c.Println(a...)
		} else {
			fmt.Fprint(color.Output, ProgramName()+": <ERROR> ")
			fmt.Fprintln(color.Output, a...)
		}
		color.Output = output
	case "Info":
		if isatty.IsTerminal(os.Stdout.Fd()) {
			c.Print(ProgramName() + ": ")
			c.Println(a...)
		} else {
			fmt.Fprint(color.Output, ProgramName()+": ")
			fmt.Fprintln(color.Output, a...)
		}
	default:
		if isatty.IsTerminal(os.Stdout.Fd()) {
			c.Println(a...)
		} else {
			fmt.Fprintln(color.Output, a...)
		}
	}
}

// consolePrintln - same as print with a new line.
func consolePrintln(tag string, c *color.Color, a ...interface{}) {
	privateMutex.Lock()
	defer privateMutex.Unlock()

	switch tag {
	case "Debug":
		// if no arguments are given do not invoke debug printer.
		if len(a) == 0 {
			return
		}
		output := color.Output
		color.Output = stderrColoredOutput
		if isatty.IsTerminal(os.Stderr.Fd()) {
			c.Print(ProgramName() + ": <DEBUG> ")
			c.Println(a...)
		} else {
			fmt.Fprint(color.Output, ProgramName()+": <DEBUG> ")
			fmt.Fprintln(color.Output, a...)
		}
		color.Output = output
	case "Fatal":
		fallthrough
	case "Error":
		// if no arguments are given do not invoke fatal and error printer.
		if len(a) == 0 {
			return
		}
		output := color.Output
		color.Output = stderrColoredOutput
		if isatty.IsTerminal(os.Stderr.Fd()) {
			c.Print(ProgramName() + ": <ERROR> ")
			c.Println(a...)
		} else {
			fmt.Fprint(color.Output, ProgramName()+": <ERROR> ")
			fmt.Fprintln(color.Output, a...)
		}
		color.Output = output
	case "Info":
		// if no arguments are given do not invoke info printer.
		if len(a) == 0 {
			return
		}
		if isatty.IsTerminal(os.Stdout.Fd()) {
			c.Print(ProgramName() + ": ")
			c.Println(a...)
		} else {
			fmt.Fprint(color.Output, ProgramName()+": ")
			fmt.Fprintln(color.Output, a...)
		}
	default:
		if isatty.IsTerminal(os.Stdout.Fd()) {
			c.Println(a...)
		} else {
			fmt.Fprintln(color.Output, a...)
		}
	}
}

// getPrefix generates the log prefix in the given color
func getPrefix(level string, color *color.Color) string {
	currentTime := time.Now().Format("15:04:05")
	toColoredString := color.SprintFunc()
	return toColoredString(fmt.Sprintf("%s[%s] ", level, currentTime))
}

func newDesc(s string, c *color.Color) desc {
	return desc{s, c.SprintFunc()}
}

func (s *RangeHistogram) ResumeHistogramUnsort(out *color.Color) {
	out.Printf("\n %s: %d", s.name_, s.total_)
	for k, v := range s.data_ {
		out.Printf("\n [%d]: %d", k, v)
	}
}