obrimbaseapi/essential/visible/service/helper/log/log.go

package log

import (
	"fmt"
	"os"
	"path/filepath"
	"runtime"
	"strings"
	"time"

	"go/module/essential/visible/service/helper/retriever"
)

const (
	obrimLogMetadataResource = "software/metadata"
	obrimLogMetadataPath     = "software.lower"
	obrimLogFileExtension    = ".log"
)

// ObrimLog writes a structured log entry.
func ObrimLog(label string, message string) {
	softwareName := obrimLogSoftwareNameResolve()
	if softwareName == "" {
		return
	}

	timestamp := obrimLogTimestampGenerate()
	entry := obrimLogEntryBuild(timestamp, label, message)

	directoryPath := obrimLogDirectoryResolve(softwareName)
	if directoryPath == "" {
		return
	}

	filePath := obrimLogFileResolve(directoryPath, softwareName)

	if err := obrimLogFileEnsure(directoryPath, filePath); err != nil {
		return
	}

	_ = obrimLogWrite(filePath, entry)
}

// obrimLogTimestampGenerate generates deterministic timestamps.
func obrimLogTimestampGenerate() string {
	return time.Now().UTC().Format(time.RFC3339)
}

// obrimLogEntryBuild constructs formatted log entries.
func obrimLogEntryBuild(
	timestamp string,
	label string,
	message string,
) string {
	return fmt.Sprintf(
		"[%s] [%s] %s\n",
		timestamp,
		strings.TrimSpace(label),
		strings.TrimSpace(message),
	)
}

// obrimLogDirectoryResolve resolves platform-specific log directory paths.
func obrimLogDirectoryResolve(softwareName string) string {
	switch runtime.GOOS {
	case "linux":
		return obrimLogDirectoryResolveLinux(softwareName)

	case "windows":
		return obrimLogDirectoryResolveWindows(softwareName)

	case "darwin":
		return obrimLogDirectoryResolveMacOS(softwareName)

	default:
		return ""
	}
}

// obrimLogFileResolve resolves platform-specific log file paths.
func obrimLogFileResolve(
	directoryPath string,
	softwareName string,
) string {
	return filepath.Join(
		directoryPath,
		softwareName+obrimLogFileExtension,
	)
}

// obrimLogFileEnsure creates and verifies required log directories and files.
func obrimLogFileEnsure(
	directoryPath string,
	filePath string,
) error {
	if err := os.MkdirAll(directoryPath, 0o755); err != nil {
		return err
	}

	file, err := os.OpenFile(
		filePath,
		os.O_CREATE,
		0o644,
	)
	if err != nil {
		return err
	}

	return file.Close()
}

// obrimLogWrite persists log entries to the filesystem.
func obrimLogWrite(
	filePath string,
	entry string,
) error {
	file, err := os.OpenFile(
		filePath,
		os.O_APPEND|os.O_CREATE|os.O_WRONLY,
		0o644,
	)
	if err != nil {
		return err
	}

	defer file.Close()

	_, err = file.WriteString(entry)

	return err
}

// obrimLogSoftwareNameResolve retrieves the software name from metadata resources.
func obrimLogSoftwareNameResolve() string {
	response := retriever.ObrimRetriever(
		"json",
		map[string]any{
			"resource": obrimLogMetadataResource,
			"path":     obrimLogMetadataPath,
		},
	)

	status, ok := response["status"].(bool)
	if !ok || !status {
		return ""
	}

	payload, ok := response["payload"].(map[string]any)
	if !ok {
		return ""
	}

	softwareName, ok := payload["data"].(string)
	if !ok {
		return ""
	}

	return strings.TrimSpace(softwareName)
}

// obrimLogDirectoryResolveLinux resolves Linux log directories.
func obrimLogDirectoryResolveLinux(
	softwareName string,
) string {
	// Mutable XDG state home environment variable.
	xdgStateHome := strings.TrimSpace(
		os.Getenv("XDG_STATE_HOME"),
	)

	if xdgStateHome != "" {
		return filepath.Join(
			xdgStateHome,
			"."+softwareName,
			"logs",
		)
	}

	homeDirectory, err := os.UserHomeDir()
	if err != nil {
		return ""
	}

	return filepath.Join(
		homeDirectory,
		".local",
		"state",
		"."+softwareName,
		"logs",
	)
}

// obrimLogDirectoryResolveWindows resolves Windows log directories.
func obrimLogDirectoryResolveWindows(
	softwareName string,
) string {
	// Mutable LOCALAPPDATA environment variable.
	localAppData := strings.TrimSpace(
		os.Getenv("LOCALAPPDATA"),
	)

	if localAppData == "" {
		return ""
	}

	return filepath.Join(
		localAppData,
		softwareName,
		"Logs",
	)
}

// obrimLogDirectoryResolveMacOS resolves macOS log directories.
func obrimLogDirectoryResolveMacOS(
	softwareName string,
) string {
	homeDirectory, err := os.UserHomeDir()
	if err != nil {
		return ""
	}

	return filepath.Join(
		homeDirectory,
		"Library",
		"Logs",
		"."+softwareName,
	)
}