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 {
	value := retriever.ObrimRetriever(
		"json",
		map[string]any{
			"resource": obrimLogMetadataResource,
			"path":     obrimLogMetadataPath,
		},
	)

	switch softwareName := value.(type) {
	case string:
		return strings.TrimSpace(softwareName)

	default:
		return ""
	}
}

// obrimLogDirectoryResolveLinux resolves Linux log directories.
func obrimLogDirectoryResolveLinux(softwareName string) string {
	// Mutable XDG state directory environment value.
	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 local application data directory environment value.
	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,
	)
}