parse.go

package alog

import (
	"log/slog"
	"os"
	"strconv"
	"strings"
)

// Env settings for the package.
const (
	// EnvVerbosity is an environment variable (suffix) to use for manipulating with verbosity.
	// verbosity takes integer values like 0, 1, 2, etc.
	// It can be used with ${APP}_VERBOSITY where ${APP} is set over [Env], [SetEnv] helpers.
	EnvVerbosity = "VERBOSITY"
	// EnvSilent is an environment variable to use for manipulating with logger in general to
	// switch it off.
	EnvSilent = "SILENT"

	// FlagSilent is a full argument flag for silent option.
	FlagSilent = "--silent"
)

func flagNormalize(flag string) string {
	return strings.ToUpper(strings.ReplaceAll(flag, "-", "_"))
}

// verbosityFromEnv reads verbosity level from environment variables.
// It might resolve into:
//   - 0 (default) if environment variable wasn't found
//   - 0 (default) if variable can no be read in a integer format (e.g. keeps string)
//   - n read successfully
func verbosityFromEnv() (verbosity int, valid bool) {
	rawValue, found := os.LookupEnv(envA.Load().(envFunc)(EnvVerbosity))
	if !found {
		return 0, false
	}
	val, err := strconv.ParseInt(rawValue, 10, 64)
	if err != nil {
		return 0, false
	}
	return int(val), true
}

// ParseVerbosityInt returns verbosity in [int] form.
func ParseVerbosityInt() (verbosity int) {
	return parseVerbosity()
}

// parseVerbosity parses verbosity from cli arguments.
func parseVerbosity() (verbosity int) {
	var valid bool
	if verbosity, valid = verbosityFromEnv(); valid {
		return
	}

	for _, arg := range os.Args {
		// reads `-v=N` format, note -v 1337 format would be ignored.
		// TODO: make it happen?
		if strings.HasPrefix(arg, "-v=") {
			if _, value, found := strings.Cut(arg, "-v="); found {
				v, _ := strconv.ParseInt(value, 10, 64)
				verbosity += int(v)
			}
			continue
		}

		// Note, we read -vv..vvv format after -v=N is parsed.
		if strings.HasPrefix(arg, "-v") {
			verbosity += strings.Count(arg, "v")
		}

	}
	return
}

// ParseVerbosity parses verbosity level for the application
//
//	Emergency: -2
//	Error: -1
//	Warning: 0
//	Notice: 1
//	Info: 2
//	Debug: 3
//	Trace: 4
func ParseVerbosity() (level slog.Level) {
	lvl := parseVerbosity()
	switch lvl {
	case -2:
		return LevelEmergency
	case -1:
		return LevelError
	case 0:
		return LevelWarning
	case 1:
		return LevelNotice
	case 2:
		return LevelInfo
	case 3:
		return LevelDebug
	case 4:
		return LevelTrace
	default:
		return LevelTrace
	}
}

func parseSilentFromEnv() (silent bool, valid bool) {
	rawValue, found := os.LookupEnv(envA.Load().(envFunc)(EnvSilent))
	if !found {
		return false, false
	}
	val, err := strconv.ParseBool(rawValue)
	if err != nil {
		return false, false
	}
	return val, true
}

// ParseVerbosity from arguments
func parseSilent() (silent bool) {
	var valid bool
	if silent, valid = parseSilentFromEnv(); valid {
		return
	}

	for _, arg := range os.Args {
		// ignores --silent=false, so it can only enable silent mode.
		if strings.HasPrefix(arg, FlagSilent) {
			silent = true
			break
		}
	}
	return
}

// ParseSilent identifies if silent is set over cli arguments or environment variables.
func ParseSilent() bool {
	return parseSilent()
}