console.go

package console

import (
	"encoding/json"
	"fmt"
	"reflect"
	"strconv"
	"strings"
	"time"
)

const (
	Reset  = "\033[0m"
	Red    = "\033[31m"
	Green  = "\033[32m"
	Yellow = "\033[33m"
	Blue   = "\033[34m"
	Purple = "\033[35m"
	Cyan   = "\033[36m"
	Gray   = "\033[37m"
	Bold   = "\033[1m"
)

func Log(data interface{}) {
	switch v := data.(type) {
	case nil:
		fmt.Printf("%s%snull%s\n", Gray, Bold, Reset)
	case string:
		fmt.Printf("%s\"%s\"%s\n", Green, v, Reset)
	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
		fmt.Printf("%s%v%s\n", Blue, v, Reset)
	case float32, float64:
		fmt.Printf("%s%v%s\n", Blue, v, Reset)
	case bool:
		if v {
			fmt.Printf("%s%strue%s\n", Yellow, Bold, Reset)
		} else {
			fmt.Printf("%s%sfalse%s\n", Yellow, Bold, Reset)
		}
	case time.Time:
		fmt.Printf("%s%s%s\n", Purple, v.Format("2006-01-02 15:04:05"), Reset)
	default:
		jsonBytes, err := json.MarshalIndent(v, "", "  ")
		if err != nil {
			fmt.Printf("%sError formatting data: %v%s\n", Red, err, Reset)
			return
		}

		output := string(jsonBytes)
		output = colorizeJSON(output)
		fmt.Println(output)
	}
}

func Table(data interface{}) {
	v := reflect.ValueOf(data)
	if v.Kind() != reflect.Slice {
		fmt.Printf("%sError: Table() requires a slice%s\n", Red, Reset)
		return
	}

	if v.Len() == 0 {
		fmt.Printf("%sEmpty slice%s\n", Gray, Reset)
		return
	}

	firstElem := v.Index(0)
	if firstElem.Kind() != reflect.Struct {
		printSimpleTable(v)
		return
	}

	printStructTable(v)
}

func Info(message interface{}) {
	timestamp := time.Now().Format("15:04:05")
	fmt.Printf("%s[%s]%s %sINFO%s %v\n",
		Gray, timestamp, Reset,
		Cyan, Reset, message)
}

func Warn(message interface{}) {
	timestamp := time.Now().Format("15:04:05")
	fmt.Printf("%s[%s]%s %s%sWARN%s %v\n",
		Gray, timestamp, Reset,
		Yellow, Bold, Reset, message)
}

func Error(message interface{}) {
	timestamp := time.Now().Format("15:04:05")
	fmt.Printf("%s[%s]%s %s%sERROR%s %v\n",
		Gray, timestamp, Reset,
		Red, Bold, Reset, message)
}

func Success(message interface{}) {
	timestamp := time.Now().Format("15:04:05")
	fmt.Printf("%s[%s]%s %s%sSUCCESS%s %v\n",
		Gray, timestamp, Reset,
		Green, Bold, Reset, message)
}

func Debug(label string, data interface{}) {
	timestamp := time.Now().Format("15:04:05.000")
	fmt.Printf("%s[%s]%s %s%sDEBUG%s %s%s:%s\n",
		Gray, timestamp, Reset,
		Purple, Bold, Reset,
		Bold, label, Reset)
	Log(data)
	fmt.Println()
}

func colorizeJSON(jsonStr string) string {
	lines := strings.Split(jsonStr, "\n")
	var colorized []string

	for _, line := range lines {
		trimmed := strings.TrimSpace(line)

		if strings.HasPrefix(trimmed, "\"") && strings.Contains(trimmed, ":") {
			parts := strings.SplitN(trimmed, ":", 2)
			if len(parts) == 2 {
				key := strings.TrimSpace(parts[0])
				value := strings.TrimSpace(parts[1])
				value = strings.TrimSuffix(value, ",")
				comma := ""
				if strings.HasSuffix(strings.TrimSpace(parts[1]), ",") {
					comma = ","
				}

				colorized = append(colorized, fmt.Sprintf("%s  %s%s%s: %s%s%s",
					strings.Repeat(" ", len(line)-len(trimmed)),
					Cyan, key, Reset,
					getValueColor(value), value, Reset)+comma)
				continue
			}
		}

		colorized = append(colorized, line)
	}

	return strings.Join(colorized, "\n")
}

func getValueColor(value string) string {
	value = strings.TrimSpace(value)
	if value == "null" {
		return Gray + Bold
	}
	if value == "true" || value == "false" {
		return Yellow + Bold
	}
	if strings.HasPrefix(value, "\"") && strings.HasSuffix(value, "\"") {
		return Green
	}
	if _, err := strconv.ParseFloat(value, 64); err == nil {
		return Blue
	}
	return Reset
}

func printSimpleTable(v reflect.Value) {
	fmt.Printf("%s┌─────┬─────────┐%s\n", Gray, Reset)
	fmt.Printf("%s│%s %s%sIdx%s %s│%s %s%sValue%s   %s│%s\n",
		Gray, Reset, Bold, Cyan, Reset, Gray, Reset, Bold, Cyan, Reset, Gray, Reset)
	fmt.Printf("%s├─────┼─────────┤%s\n", Gray, Reset)

	for i := 0; i < v.Len(); i++ {
		elem := v.Index(i)
		fmt.Printf("%s│%s %s%-3d%s %s│%s %-7v %s│%s\n",
			Gray, Reset, Blue, i, Reset, Gray, Reset, elem.Interface(), Gray, Reset)
	}

	fmt.Printf("%s└─────┴─────────┘%s\n", Gray, Reset)
}

func printStructTable(v reflect.Value) {
	firstElem := v.Index(0)
	elemType := firstElem.Type()

	var fieldNames []string
	for i := 0; i < elemType.NumField(); i++ {
		fieldNames = append(fieldNames, elemType.Field(i).Name)
	}

	colWidths := make([]int, len(fieldNames))
	for i, name := range fieldNames {
		colWidths[i] = len(name)
	}

	var rows [][]string
	for i := 0; i < v.Len(); i++ {
		elem := v.Index(i)
		var row []string
		for j := 0; j < elem.NumField(); j++ {
			fieldValue := elem.Field(j).Interface()
			valueStr := fmt.Sprintf("%v", fieldValue)
			row = append(row, valueStr)
			if len(valueStr) > colWidths[j] {
				colWidths[j] = len(valueStr)
			}
		}
		rows = append(rows, row)
	}

	printTableSeparator(colWidths, "┌", "┬", "┐")
	printTableRow(fieldNames, colWidths, true)
	printTableSeparator(colWidths, "├", "┼", "┤")

	for _, row := range rows {
		printTableRow(row, colWidths, false)
	}

	printTableSeparator(colWidths, "└", "┴", "┘")
}

func printTableSeparator(colWidths []int, left, middle, right string) {
	fmt.Printf("%s%s", Gray, left)
	for i, width := range colWidths {
		fmt.Print(strings.Repeat("─", width+2))
		if i < len(colWidths)-1 {
			fmt.Print(middle)
		}
	}
	fmt.Printf("%s%s\n", right, Reset)
}

func printTableRow(row []string, colWidths []int, isHeader bool) {
	fmt.Printf("%s│%s", Gray, Reset)
	for i, cell := range row {
		color := Reset
		if isHeader {
			color = Bold + Cyan
		}
		fmt.Printf(" %s%-*s%s ", color, colWidths[i], cell, Reset)
		fmt.Printf("%s│%s", Gray, Reset)
	}
	fmt.Println()
}