package ui

import (
	"fmt"
	"os"
	"runtime"
	"strings"
)

const (
	// Reset ...
	Reset = "\x1b[0m"
	// Bright ...
	Bright = "\x1b[1m"
	// Dim ...
	Dim = "\x1b[2m"
	// Underscore ...
	Underscore = "\x1b[4m"
	// Blink ...
	Blink = "\x1b[5m"
	// Reverse ...
	Reverse = "\x1b[7m"
	// Hidden ...
	Hidden = "\x1b[8m"
)

const (
	// FgBlack - Black foreground
	FgBlack = "\x1b[30m"
	// FgRed - Red foreground
	FgRed = "\x1b[91m"
	// FgGreen - Green foreground
	FgGreen = "\x1b[92m"
	// FgYellow - Yellow foreground
	FgYellow = "\x1b[93m"
	// FgBlue - Blue foreground
	FgBlue = "\x1b[94m"
	// FgMagenta - Magenta foreground
	FgMagenta = "\x1b[95m"
	// FgCyan - Cyan foreground
	FgCyan = "\x1b[96m"
	// FgWhite - White foreground
	FgWhite = "\x1b[97m"
	// FgOrange - Orange foreground
	FgOrange = "\x1b[33m"
)

const (
	// BgBlack - Black background
	BgBlack = "\x1b[40m"
	// BgRed - Red background
	BgRed = "\x1b[41m"
	// BgGreen - Green background
	BgGreen = "\x1b[42m"
	// BgYellow - Yellow background
	BgYellow = "\x1b[43m"
	// BgBlue - Blue background
	BgBlue = "\x1b[44m"
	// BgMagenta - Magenta background
	BgMagenta = "\x1b[45m"
	// BgCyan - Cyan background
	BgCyan = "\x1b[46m"
	// BgWhite - White background
	BgWhite = "\x1b[47m"
)

// Color ...
type Color struct {
	nocolor bool
}

// NewColor ...
func NewColor(nocolor bool) *Color {
	return &Color{nocolor}
}

// color ...
func (c *Color) color(color string, msg ...interface{}) {
	if !c.nocolor && colorterm() {
		fmt.Print(color)
		msg = append(msg, Reset)
	}
	fmt.Print(msg...)
}

// colorln ...
func (c *Color) colorln(color string, msg ...interface{}) {
	if !c.nocolor && colorterm() {
		fmt.Print(color)
		msg = append(msg, Reset)
	}
	fmt.Println(msg...)
}

// colorf ...
func (c *Color) colorf(color, format string, i ...interface{}) {
	if !c.nocolor && colorterm() {
		fmt.Print(color)
		format += Reset
	}
	fmt.Printf(format, i...)
}

// scolorf ...
func (c *Color) scolorf(color, format string, i ...interface{}) string {
	if !c.nocolor && colorterm() {
		format = color + format
		format += Reset
	}
	return fmt.Sprintf(format, i...)
}

// colorterm
func colorterm() (supportscolor bool) {
	term := os.Getenv("TERM")
	supportscolor = true // going to assume yes
	if len(term) > 0 {
		if !(strings.Contains(term, "xterm-color") || strings.Contains(term, "256color")) {
			supportscolor = false
		}
	}
	if runtime.GOOS == "windows" {
		supportscolor = false
	}
	return
}

// Black ...
func (c *Color) Black(msg ...interface{}) {
	c.color(FgBlack, msg...)
}

// Blackln ...
func (c *Color) Blackln(msg ...interface{}) {
	c.colorln(FgBlack, msg...)
}

// Blackf ...
func (c *Color) Blackf(format string, i ...interface{}) {
	c.colorf(FgBlack, format, i...)
}

// Sblackf ...
func (c *Color) Sblackf(format string, i ...interface{}) {
	c.scolorf(FgBlack, format, i...)
}

// Red ...
func (c *Color) Red(msg ...interface{}) {
	c.color(FgRed, msg...)
}

// Redln ...
func (c *Color) Redln(msg ...interface{}) {
	c.colorln(FgRed, msg...)
}

// Redf ...
func (c *Color) Redf(format string, i ...interface{}) {
	c.colorf(FgRed, format, i...)
}

// Sredf ...
func (c *Color) Sredf(format string, i ...interface{}) string {
	return c.scolorf(FgRed, format, i...)
}

// Green ...
func (c *Color) Green(msg ...interface{}) {
	c.color(FgGreen, msg...)
}

// Greenln ...
func (c *Color) Greenln(msg ...interface{}) {
	c.colorln(FgGreen, msg...)
}

// Greenf ...
func (c *Color) Greenf(format string, i ...interface{}) {
	c.colorf(FgGreen, format, i...)
}

// Sgreenf ...
func (c *Color) Sgreenf(format string, i ...interface{}) string {
	return c.scolorf(FgGreen, format, i...)
}

// Yellow ...
func (c *Color) Yellow(msg ...interface{}) {
	c.color(FgYellow, msg...)
}

// Yellowln ...
func (c *Color) Yellowln(msg ...interface{}) {
	c.colorln(FgYellow, msg...)
}

// Yellowf ...
func (c *Color) Yellowf(format string, i ...interface{}) {
	c.colorf(FgYellow, format, i...)
}

// Syellowf ...
func (c *Color) Syellowf(format string, i ...interface{}) string {
	return c.scolorf(FgYellow, format, i...)
}

// Blue ...
func (c *Color) Blue(msg ...interface{}) {
	c.color(FgBlue, msg...)
}

// Blueln ...
func (c *Color) Blueln(msg ...interface{}) {
	c.colorln(FgBlue, msg...)
}

// Bluef ...
func (c *Color) Bluef(format string, i ...interface{}) {
	c.colorf(FgBlue, format, i...)
}

// Sbluef ...
func (c *Color) Sbluef(format string, i ...interface{}) string {
	return c.scolorf(FgBlue, format, i...)
}

// Magenta ...
func (c *Color) Magenta(msg ...interface{}) {
	c.color(FgMagenta, msg...)
}

// Magentaln ...
func (c *Color) Magentaln(msg ...interface{}) {
	c.colorln(FgMagenta, msg...)
}

// Magentaf ...
func (c *Color) Magentaf(format string, i ...interface{}) {
	c.colorf(FgMagenta, format, i...)
}

// Smagentaf ...
func (c *Color) Smagentaf(format string, i ...interface{}) string {
	return c.scolorf(FgMagenta, format, i...)
}

// Cyan ...
func (c *Color) Cyan(msg ...interface{}) {
	c.color(FgCyan, msg...)
}

// Cyanln ...
func (c *Color) Cyanln(msg ...interface{}) {
	c.colorln(FgCyan, msg...)
}

// Cyanf ...
func (c *Color) Cyanf(format string, i ...interface{}) {
	c.colorf(FgCyan, format, i...)
}

// Scyanf ...
func (c *Color) Scyanf(format string, i ...interface{}) string {
	return c.scolorf(FgCyan, format, i...)
}

// Orange ...
func (c *Color) Orange(msg ...interface{}) {
	c.color(FgOrange, msg...)
}

// Orangeln ...
func (c *Color) Orangeln(msg ...interface{}) {
	c.colorln(FgOrange, msg...)
}

// Orangef ...
func (c *Color) Orangef(format string, i ...interface{}) {
	c.colorf(FgOrange, format, i...)
}

// Sorangef ...
func (c *Color) Sorangef(format string, i ...interface{}) string {
	return c.scolorf(FgOrange, format, i...)
}

// White ...
func (c *Color) White(msg ...interface{}) {
	c.color(FgWhite, msg...)
}

// Whiteln ...
func (c *Color) Whiteln(msg ...interface{}) {
	c.colorln(FgWhite, msg...)
}

// Whitef ...
func (c *Color) Whitef(format string, i ...interface{}) {
	c.colorf(FgWhite, format, i...)
}

// Swhitef ...
func (c *Color) Swhitef(format string, i ...interface{}) string {
	return c.scolorf(FgWhite, format, i...)
}