func (tokens LogTokens) Print() {
	defer color.ResetColor()

	var defColor color.Color = color.White
	var defBright bool = true

	for _, token := range tokens {
		if token.Type >= TOKEN_DEBUG {
			defColor, defBright, _ = token.Type.getFgColor()
		}
	}

	for _, token := range tokens {
		fg, bright, specific := token.Type.getFgColor()
		if !specific {
			fg = defColor
			bright = defBright
		}

		color.Foreground(fg, bright)
		fmt.Print(token.Text)
	}

	fmt.Print("\n")
}

func init() {
	defer ct.ResetColor()
	//	WriteOutLevel(OUT_LEVEL_WARNING)
	//	WriteOut("#####################################\n  Chandra Application")
	//	WriteOut("\n#####################################\n")
	//	WriteOutLevel(OUT_LEVEL_RESET)
}

// outputColorStack is use when -logcolor is enabled.
// colored stack printing is allowed to be inefficient because it's a local development feature.
func outputColorStack(stacks []byte, s severity) {
	r := bytes.NewReader(stacks)
	scanner := bufio.NewScanner(r)
	for scanner.Scan() {
		l := scanner.Bytes()
		if len(l) > 0 && l[0] == "\t"[0] {
			addroffset := bytes.LastIndex(l, []byte(" "))
			linumoffset := bytes.LastIndex(l, []byte(":"))
			if addroffset == -1 || linumoffset == -1 {
				os.Stderr.Write(l)
				goto eol
			}
			srcpath := l[0:linumoffset]
			hlstart := 0
			hlstacksrc.Lock()
			if hlstacksrc.v != nil {
				for _, v := range hlstacksrc.v {
					offs := bytes.Index(srcpath, v)
					if offs > hlstart {
						hlstart = offs
					}
				}
			}
			hlstacksrc.Unlock()
			if hlstart > 0 {
				os.Stderr.Write(srcpath[:hlstart])
				ct.Foreground(ct.Blue, true)
				os.Stderr.Write(srcpath[hlstart:])
				ct.ResetColor()
			} else {
				os.Stderr.Write(srcpath)
			}
			os.Stderr.WriteString(":")
			printColor(s)
			os.Stderr.Write(l[linumoffset+1 : addroffset])
			ct.ResetColor()
			os.Stderr.Write(l[addroffset:])
		} else {
			os.Stderr.Write(l)
		}
	eol:
		os.Stderr.WriteString("\n")
	}
	if err := scanner.Err(); err != nil {
		fmt.Fprintln(os.Stderr, "reading standard input:", err)
	}
}

func WriteOut(s string, ars ...interface{}) {
	if len(ars) > 0 {
		fmt.Printf(s, ars)
	} else {
		fmt.Print(s)
	}
	ct.ResetColor()
}

// Write out a single coloured line
func (of *OutletFactory) WriteLine(left, right string, leftC, rightC ct.Color, isError bool) {
	of.Lock()
	defer of.Unlock()

	ct.ChangeColor(leftC, true, ct.None, false)
	formatter := fmt.Sprintf("%%-%ds | ", of.Padding)
	fmt.Printf(formatter, left)

	if isError {
		ct.ChangeColor(ct.Red, true, ct.None, true)
	} else {
		ct.ResetColor()
	}
	fmt.Println(right)
	if isError {
		ct.ResetColor()
	}
}

func (e *BigcommerceAppLogEvent) PrintLine(index int) {
	fmt.Printf("[%d]  ", index)
	fmt.Printf("%s  ", e.SyslogTime.Format("2006-01-02 15:04:05"))
	ct.ChangeColor(ct.Yellow, false, ct.None, false)
	fmt.Print("bigcommerce-app  ")
	ct.ChangeColor(ct.Cyan, false, ct.None, false)
	fmt.Printf("%s-%d  ", e.LogLevel, e.StoreContext.StoreId)
	ct.ResetColor()
	fmt.Printf("%s\n", e.Content)
}

func (e *GenericLogEvent) PrintLine(index int) {
	fmt.Printf("[%d]  ", index)
	fmt.Print(e.SyslogTime.Format("2006-01-02 15:04:05") + "  ")
	ct.ChangeColor(ct.Yellow, false, ct.None, false)
	fmt.Print("generic  ")
	ct.ChangeColor(ct.Cyan, false, ct.None, false)
	fmt.Printf("%s  ", e.Name)
	ct.ResetColor()
	fmt.Printf("%s\n", e.Content)
}

func (e *ProcessLogEvent) PrintLine(index int) {
	fmt.Printf("[%d]  ", index)
	fmt.Print(e.SyslogTime.Format("2006-01-02 15:04:05") + "  ")
	ct.ChangeColor(ct.Yellow, false, ct.None, false)
	fmt.Print("process  ")
	ct.ChangeColor(ct.Cyan, false, ct.None, false)
	fmt.Printf("%s-%d  ", e.Name, e.ProcessId)
	ct.ResetColor()
	fmt.Printf("%s\n", e.Content)
}

func (e *PhpStackTraceLogEvent) PrintLine(index int) {
	fmt.Printf("[%d]  ", index)
	fmt.Print(e.SyslogTime.Format("2006-01-02 15:04:05") + "  ")
	ct.ChangeColor(ct.Yellow, false, ct.None, false)
	fmt.Print("php-stack-trace  ")
	ct.ChangeColor(ct.Cyan, false, ct.None, false)
	fmt.Printf("%d-%s-%d  ", e.Number, e.File, e.Line)
	ct.ResetColor()
	fmt.Printf("%s\n", e.Method)
}

func WriteOutLevel(l string) {
	switch l {
	case OUT_LEVEL_WARNING:
		ct.ChangeColor(ct.Yellow, true, ct.None, false)
	case OUT_LEVEL_ERROR:
		ct.ChangeColor(ct.Red, true, ct.None, false)
	case OUT_LEVEL_INFO:
		ct.ChangeColor(ct.Cyan, true, ct.None, false)
	default:
		ct.ResetColor()
	}
}

func print(timeFormat string, le *logEntry) {
	var level string
	switch le.level {
	case Info:
		level = "INFO    "
		ct.Foreground(ct.Cyan, false)
	case Warning:
		level = "WARNING "
		ct.Foreground(ct.Yellow, false)
	case Error:
		level = "ERROR   "
		ct.Foreground(ct.Red, false)
	case Critical:
		level = "CRITICAL"
		ct.ChangeColor(ct.Black, false, ct.Red, false)
	case Fatal:
		level = "FATAL   "
		ct.ResetColor()
	}
	fmt.Println(le.time.Format(timeFormat), level, le.message)
	ct.ResetColor()
}

func (e *NginxErrorLogEvent) PrintLine(index int) {
	fmt.Printf("[%d]  ", index)

	if e.LogLevel == "error" {
		fmt.Print(e.SyslogTime.Format("2006-01-02 15:04:05") + "  ")
		ct.ChangeColor(ct.Yellow, false, ct.Red, false)
		fmt.Print("nginx-error  ")
		ct.ChangeColor(ct.Cyan, false, ct.Red, false)
		fmt.Printf("%s  ", e.LogLevel)
		ct.ChangeColor(ct.None, false, ct.Red, false)
		fmt.Printf("%s %s\n", e.Request.Uri, e.Content)
		ct.ResetColor()
	} else {
		fmt.Print(e.SyslogTime.Format("2006-01-02 15:04:05") + "  ")
		ct.ChangeColor(ct.Yellow, false, ct.None, false)
		fmt.Print("nginx-error  ")
		ct.ChangeColor(ct.Cyan, false, ct.None, false)
		fmt.Printf("%s  ", e.LogLevel)
		ct.ResetColor()
		fmt.Printf("%s %s\n", e.Request.Uri, e.Content)
	}
}

func (cl *coloredLogger) ScenarioStart(scenarioHeading string) {
	msg := formatScenario(scenarioHeading)
	Log.Info(msg)

	indentedText := indent(msg, scenarioIndentation)
	if level == logging.INFO {
		cl.headingText.WriteString(indentedText + spaces(4))
		cl.writeToConsole(cl.headingText.String(), ct.None, false)
	} else {
		ct.Foreground(ct.Yellow, false)
		ConsoleWrite(indentedText)
		ct.ResetColor()
	}
}

// A simple function to print message with colors.
func ColoredPrint(thecolor color.Color, bold bool, values ...interface{}) {

	// change the color of the terminal
	color.ChangeColor(
		thecolor,
		bold,
		None,
		false,
	)

	// print
	fmt.Print(values...)

	// reset the color
	color.ResetColor()
}

func TestGetConsoleColor(t *testing.T) {
	for b := uint32(0); b < 6; b++ {
		for g := uint32(0); g < 6; g++ {
			for r := uint32(0); r < 6; r++ {
				m, l, h, j, k := GetConsoleColor(r*0x33/4, g*0x33/4, b*0x33/4)
				ct.ChangeColor(l, h, j, k)
				c := clist64[m : m+1]
				c = c + c + c + c
				if k {
					fmt.Printf("%s%x", c, (j-1)<<1)
				} else {
					fmt.Printf("%s%x", c, (j - 1))
				}
				ct.ResetColor()
				fmt.Printf("#%02x%02x%02x ", r*0x33, g*0x33, b*0x33)
			}
			fmt.Print("\n")
		}
	}
}

// 将图片渲染到文字(有颜色版)
func ShowColor(iw io.Writer, img image.Image, console Console) {
	// Lanczos3缩放图片到控制台屏幕大小
	w := console.ScreenW - 1 // 标宽 换行符竟然也算一个?
	s := img.Bounds().Size()
	// 标高 = 结果高 * 宽高比 = (原高 / 原宽 * 标宽) * 宽高比
	h := uint(float64(s.Y) / float64(s.X) * float64(w) * console.Ratio())
	m := resize.Resize(w, h, img, resize.Bicubic)
	for y := 0; y < int(h); y++ {
		for x := (0); x < int(w); x++ {
			r, g, b, a := m.At(x, y).RGBA()
			r, g, b, a = r>>10, g>>10, b>>10, a>>10 // 转换到6位色 0~63
			r, g, b = r*a/63, g*a/63, b*a/63        // Alpha混合
			m, fg, fgl, bg, bgl := GetConsoleColor(r, g, b)
			ct.ChangeColor(fg, fgl, bg, bgl)
			// cindex := (r + g + b) / 3
			io.WriteString(iw, clist64[m:m+1])
		}
		io.WriteString(iw, "\n")
	}
	ct.ResetColor()
}

func (t *textLogger) Write(entry Entry) {
	if t.ttyOutput {
		ct.ChangeColor(entry.Level.Color, entry.Level.Bright, ct.None, false)
	}
	text := strings.TrimSpace(entry.Message)
	if entry.Level.Level >= WarnLevel.Level {
		text = fmt.Sprintf("[%s from %s]\n", entry.ID, entry.Origin) + text
	}
	if strings.Contains(text, "\n") { // separate multiline comments with newlines
		if !t.lastNewline {
			fmt.Fprintln(t.out) // separate from previous one-line log msg
		}
		text = text + "\n"
		t.lastNewline = true
	} else {
		t.lastNewline = false
	}
	fmt.Fprintln(t.out, entry.Level.Prefix+strings.Replace(text, "\n", "\n       ", -1))
	if t.ttyOutput {
		ct.ResetColor()
	}
}

func (e *PhpLogEvent) PrintFull() {
	fmt.Printf("\n---------- PHP LOG EVENT ----------\n")

	writer := new(tabwriter.Writer)
	writer.Init(os.Stdout, 0, 8, 2, ' ', 0)

	fmt.Fprintf(
		writer,
		"SyslogTime:\t%s\n",
		e.SyslogTime.Format("2006-01-02 15:04:05"),
	)

	fmt.Fprintf(writer, "LogLevel:\t%s\n", e.LogLevel)
	fmt.Fprintf(writer, "Content:\t%s\n", e.Content)
	fmt.Fprintf(writer, "File:\t%s\n", e.File)
	fmt.Fprintf(writer, "Line:\t%d\n", e.Line)

	writer.Flush()

	ct.ChangeColor(ct.White, true, ct.None, false)
	fmt.Print("\nStack trace\n")
	ct.ResetColor()

	for _, phpStackTraceLogEvent := range e.StackTraceEvents {
		fmt.Fprintf(
			writer,
			"%d.\t%s\t%s\t%d\n",
			phpStackTraceLogEvent.Number,
			phpStackTraceLogEvent.Method,
			phpStackTraceLogEvent.File,
			phpStackTraceLogEvent.Line,
		)
	}

	writer.Flush()

	fmt.Printf("\n---------- PHP LOG EVENT ----------\n")
}

func Error(format string, a ...interface{}) {
	defer color.ResetColor()

	color.Foreground(color.Red, true)
	fmt.Println(fmt.Sprintf(format, a...))
}

func (c *coloredConsole) displayMessage(msg string, color ct.Color) {
	ct.Foreground(color, false)
	defer ct.ResetColor()
	fmt.Fprint(c.writer, msg)
	c.writer.Print()
}