obrimbasecli/essential/visible/service/helper/datetime/datetime.go

/*
|--------------------------------------------------------------------------
| Datetime
|--------------------------------------------------------------------------
|
| Name:
|   - datetime
|
| Purpose:
|   - Retrieve and format the current date and time from either the
|     host system clock or a trusted NTP source using framework-
|     supported format patterns.
|
| Guidelines:
|   - Validate all inputs before execution.
|   - Use framework-defined format mappings only.
|   - Return standardized response structures.
|   - Emit status and log messages for initialization, success,
|     and failure events.
|
| Examples:
|   - ObrimDatetime("local", map[string]any{"format":"yyyy-MM-dd"})
|   - ObrimDatetime("trusted", map[string]any{"format":"timestampsec"})
|
|--------------------------------------------------------------------------
*/

/*
|--------------------------------------------------------------------------
| Credit
|--------------------------------------------------------------------------
|
| Contributor:
|   - Rajon Ahmed
|   - Scionite
|
|--------------------------------------------------------------------------
*/

package datetime

import (
	"errors"
	"fmt"
	"strconv"
	"time"

	"go/module/essential/visible/service/helper/log"
	"go/module/essential/visible/service/helper/retriever"
	"go/module/essential/visible/service/helper/status"

	"github.com/beevik/ntp"
)

// Mutable Variable Purpose: Framework-supported datetime pattern mappings.
var obrimDatetimePatternMap = map[string]string{
	"yyyy-MM-dd":               "2006-01-02",
	"MMM dd, yyyy":             "Jan 02, 2006",
	"MMMM dd, yyyy":            "January 02, 2006",
	"EEE, MMM dd, yyyy":        "Mon, Jan 02, 2006",
	"EEE, MMMM dd, yyyy":       "Mon, January 02, 2006",
	"EEEE, MMM dd, yyyy":       "Monday, Jan 02, 2006",
	"EEEE, MMMM dd, yyyy":      "Monday, January 02, 2006",
	"HH:mm:ss":                 "15:04:05",
	"hh:mm:ss a":               "03:04:05 PM",
	"yyyy-MM-dd HH:mm:ss":      "2006-01-02 15:04:05",
	"yyyy-MM-dd HH:mm:ss z":    "2006-01-02 15:04:05 MST",
	"yyyy-MM-dd'T'HH:mm:ssXXX": "2006-01-02T15:04:05Z07:00",
}

// Function Name: ObrimDatetime
// Function Purpose: Retrieve and format the current date and time from a selected source using a supported format pattern.
func ObrimDatetime(datetimeType string, config map[string]any) map[string]any {
	status.ObrimStatus("INFO", "Datetime utility initialization started.")
	log.ObrimLog("INIT", "Datetime utility initialization started.")

	if err := obrimDatetimeValidate(datetimeType, config); err != nil {
		status.ObrimStatus("ERROR", err.Error())
		log.ObrimLog("ERROR", err.Error())

		switch err.Error() {
		case "INVALID_TYPE":
			return obrimDatetimeResponse(false, "FAILED_INVALID_TYPE", nil)
		case "INVALID_FORMAT":
			return obrimDatetimeResponse(false, "FAILED_INVALID_FORMAT", nil)
		default:
			return obrimDatetimeResponse(false, "FAILED_VALIDATION", nil)
		}
	}

	var currentTime time.Time
	var err error

	switch datetimeType {
	case "local":
		currentTime, err = obrimDatetimeLocal()
	case "trusted":
		currentTime, err = obrimDatetimeTrusted()
	default:
		err = errors.New("INVALID_TYPE")
	}

	if err != nil {
		status.ObrimStatus("ERROR", err.Error())
		log.ObrimLog("ERROR", err.Error())

		return obrimDatetimeResponse(false, "FAILED_DATETIME_RETRIEVAL", nil)
	}

	value, err := obrimDatetimeFormatApply(currentTime, fmt.Sprintf("%v", config["format"]))
	if err != nil {
		status.ObrimStatus("ERROR", err.Error())
		log.ObrimLog("ERROR", err.Error())

		return obrimDatetimeResponse(false, "FAILED_INVALID_FORMAT", nil)
	}

	status.ObrimStatus("SUCCESS", "Datetime retrieved successfully.")
	log.ObrimLog("SUCCESS", "Datetime retrieved successfully.")

	return obrimDatetimeResponse(
		true,
		"SUCCESS_DATETIME_RETRIEVED",
		map[string]any{
			"value": value,
		},
	)
}

// Function Name: obrimDatetimeValidate
// Function Purpose: Validate utility inputs and configuration.
func obrimDatetimeValidate(datetimeType string, config map[string]any) error {
	if datetimeType != "local" && datetimeType != "trusted" {
		return errors.New("INVALID_TYPE")
	}

	formatValue, exists := config["format"]
	if !exists {
		return errors.New("INVALID_FORMAT")
	}

	formatString := fmt.Sprintf("%v", formatValue)

	if !obrimDatetimePatternValidate(formatString) {
		return errors.New("INVALID_FORMAT")
	}

	return nil
}

// Function Name: obrimDatetimePatternValidate
// Function Purpose: Validate supported format patterns.
func obrimDatetimePatternValidate(pattern string) bool {
	if pattern == "timestampsec" || pattern == "timestampmil" {
		return true
	}

	_, exists := obrimDatetimePatternMap[pattern]
	return exists
}

// Function Name: obrimDatetimePatternResolve
// Function Purpose: Resolve supported format patterns into internal formatting layouts.
func obrimDatetimePatternResolve(pattern string) (string, error) {
	layout, exists := obrimDatetimePatternMap[pattern]
	if !exists {
		return "", errors.New("INVALID_FORMAT")
	}

	return layout, nil
}

// Function Name: obrimDatetimeFormatApply
// Function Purpose: Generate the final formatted value.
func obrimDatetimeFormatApply(currentTime time.Time, pattern string) (string, error) {
	switch pattern {
	case "timestampsec":
		return strconv.FormatInt(currentTime.Unix(), 10), nil

	case "timestampmil":
		return strconv.FormatInt(currentTime.UnixMilli(), 10), nil
	}

	layout, err := obrimDatetimePatternResolve(pattern)
	if err != nil {
		return "", err
	}

	return currentTime.Format(layout), nil
}

// Function Name: obrimDatetimeResponse
// Function Purpose: Build standardized utility response objects.
func obrimDatetimeResponse(statusValue bool, code string, payload any) map[string]any {
	return map[string]any{
		"status":  statusValue,
		"code":    code,
		"payload": payload,
	}
}

// Function Name: obrimDatetimeLocal
// Function Purpose: Retrieve current date and time from the host system clock.
func obrimDatetimeLocal() (time.Time, error) {
	_, _ = retriever.ObrimRetriever(
		"datetime",
		map[string]any{
			"source": "local",
		},
	)

	return time.Now(), nil
}

// Function Name: obrimDatetimeTrusted
// Function Purpose: Retrieve current date and time from the framework-managed NTP pool source.
func obrimDatetimeTrusted() (time.Time, error) {
	return obrimDatetimeTrustedSync()
}

// Function Name: obrimDatetimeTrustedSync
// Function Purpose: Synchronize and retrieve trusted time from the NTP source.
func obrimDatetimeTrustedSync() (time.Time, error) {
	_, _ = retriever.ObrimRetriever(
		"datetime",
		map[string]any{
			"source": "trusted",
		},
	)

	return ntp.Time("pool.ntp.org")
}