// Package gologger provides a simple logging implementation with multiple appenders and formatters.
// It supports console, file, and HTTP logging with customizable formats.
package gologger

import (
	"encoding/json"
	"fmt"
	"strings"
)

// LogFormatter is a function type that formats a LogEvent into a string.
// Example:
//
//	formatter := func(event LogEvent) string {
//	  return fmt.Sprintf("[%s] %s: %v", event.Ts.Format("2006-01-02"), event.Level, event.Data)
//	}
type LogFormatter = func(LogEvent) string

const logTemplate = "[%s] %s : %s - %s\n"

// format is the default formatter that converts a LogEvent to a string using the default template.
// It handles both simple values and formatted strings.
// Template: "[timestamp] level : category - data"
func format(logEvent LogEvent) string {
	data := logEvent.Ts.Format("2006-01-02 15:04:05")
	var msg string
	if len(logEvent.Data) > 0 {
		firstMsg := logEvent.Data[0]
		if isFormatString(firstMsg) {
			msg = fmt.Sprintf(firstMsg.(string), logEvent.Data[1:]...)
		} else {
			msg = sprint(logEvent.Data)
		}
	}

	return fmt.Sprintf(logTemplate, data, logEvent.Category, getLogLevelStr(logEvent.Level), msg)
}

func getLogLevelStr(level int) string {
	for name, slevel := range logLevelMap {
		if slevel == level {
			return strings.ToUpper(name)
		}
	}
	return "Unknown"
}

func isFormatString(f any) bool {
	s, ok := f.(string)
	if !ok {
		return false
	}
	// 检查是否包含常见格式化动词
	return strings.Contains(s, "%s") || strings.Contains(s, "%d") ||
		strings.Contains(s, "%v") || strings.Contains(s, "%f") ||
		strings.Contains(s, "%x") || strings.Contains(s, "%t") ||
		strings.Contains(s, "%c") || strings.Contains(s, "%b") ||
		strings.Contains(s, "%e") || strings.Contains(s, "%g")
}

func sprint(s []any) string {
	var b strings.Builder
	for i, v := range s {
		if i > 0 {
			b.WriteString(" ")
		}
		fmt.Fprintf(&b, "%v", v)
	}
	return b.String()
}

func jsonFormatter(logEvent LogEvent) string {
	d, err := json.Marshal(logEvent)
	if err != nil {
		return fmt.Sprintf(`{"error":"%v"}`, logEvent.Data)
	}
	return string(d)
}

func SelectFormatter(formatter string) LogFormatter {
	switch strings.ToLower(formatter) {
	case "json":
		return jsonFormatter
	case "text":
		return format
	default:
		return format
	}
}