/*
|--------------------------------------------------------------------------
| Manifest
|--------------------------------------------------------------------------
|
| Name:
|   - Marker
|
| Purpose:
|   - Provide a unified utility for generating unique markers through
|     time-based, random, and encoded generation strategies.
|
| Guideline:
|   - Use ObrimMarker as the single entry point.
|   - Validate marker type before processing.
|   - Maintain standardized response structures.
|   - Use isolated workflows for each marker type.
|   - Support future marker extensions without modifying existing workflows.
|
| Example:
|   - ObrimMarker("time", map[string]any{})
|   - ObrimMarker("random", map[string]any{"length":16})
|   - ObrimMarker("encoded", map[string]any{"data":"example"})
|
|--------------------------------------------------------------------------
*/

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

package marker

import (
	"crypto/rand"
	"crypto/sha256"
	"encoding/base64"
	"encoding/binary"
	"fmt"
	"math"
	"strings"
	"time"

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

const (
	obrimMarkerTypeTime    = "time"
	obrimMarkerTypeRandom  = "random"
	obrimMarkerTypeEncoded = "encoded"

	obrimMarkerDefaultEpoch  int64 = 0
	obrimMarkerDefaultLength       = 16

	obrimMarkerDefaultCharset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
)

// ObrimMarker routes marker generation requests and returns a standardized marker response.
func ObrimMarker(markerType string, config map[string]any) map[string]any {
	log.ObrimLog("INIT", "Marker utility initialized.")
	status.ObrimStatus("INFO", "Processing marker generation request.")

	if !obrimMarkerValidateType(markerType) {
		log.ObrimLog("ERROR", "Unsupported marker type.")
		status.ObrimStatus("ERROR", "Unsupported marker type.")

		return obrimMarkerBuildResponse(
			false,
			"FAILED_UNSUPPORTED_TYPE",
			nil,
		)
	}

	response := obrimMarkerRoute(markerType, config)

	if statusValue, ok := response["status"].(bool); ok && statusValue {
		log.ObrimLog("SUCCESS", "Marker generated successfully.")
		status.ObrimStatus("SUCCESS", "Marker generated successfully.")
	} else {
		log.ObrimLog("ERROR", "Marker generation failed.")
		status.ObrimStatus("ERROR", "Marker generation failed.")
	}

	return response
}

// obrimMarkerValidateType validates supported marker generation types.
func obrimMarkerValidateType(markerType string) bool {
	switch markerType {
	case obrimMarkerTypeTime,
		obrimMarkerTypeRandom,
		obrimMarkerTypeEncoded:
		return true
	default:
		return false
	}
}

// obrimMarkerRoute routes execution to the selected marker generation workflow.
func obrimMarkerRoute(markerType string, config map[string]any) map[string]any {
	switch markerType {
	case obrimMarkerTypeTime:
		return obrimMarkerTime(config)

	case obrimMarkerTypeRandom:
		return obrimMarkerRandom(config)

	case obrimMarkerTypeEncoded:
		return obrimMarkerEncoded(config)

	default:
		return obrimMarkerBuildResponse(
			false,
			"FAILED_UNSUPPORTED_TYPE",
			nil,
		)
	}
}

// obrimMarkerBuildResponse builds standardized success and error responses.
func obrimMarkerBuildResponse(
	statusValue bool,
	code string,
	payload any,
) map[string]any {
	return map[string]any{
		"status":  statusValue,
		"code":    code,
		"payload": payload,
	}
}

// obrimMarkerTime generates time-based unique markers.
func obrimMarkerTime(config map[string]any) map[string]any {
	if err := obrimMarkerValidateTime(config); err != nil {
		return obrimMarkerBuildResponse(
			false,
			"FAILED_VALIDATION",
			nil,
		)
	}

	// Mutable variable storing effective epoch.
	var epoch int64 = obrimMarkerDefaultEpoch

	if value, ok := config["epoch"]; ok {
		switch typed := value.(type) {
		case int64:
			epoch = typed
		case int:
			epoch = int64(typed)
		case float64:
			epoch = int64(typed)
		}
	}

	// Mutable variable storing instance identifier.
	var instance string

	if value, ok := config["instance"].(string); ok {
		instance = value
	}

	marker, err := obrimMarkerTimeGenerate(epoch, instance)
	if err != nil {
		return obrimMarkerBuildResponse(
			false,
			"FAILED_GENERATION",
			nil,
		)
	}

	payload := map[string]any{
		"marker":   marker,
		"epoch":    epoch,
		"instance": instance,
	}

	return obrimMarkerBuildResponse(
		true,
		"SUCCESS_TIME_GENERATED",
		payload,
	)
}

// obrimMarkerValidateTime validates time marker configuration parameters.
func obrimMarkerValidateTime(config map[string]any) error {
	if value, ok := config["epoch"]; ok {
		switch typed := value.(type) {
		case int64:
			if typed < 0 {
				return fmt.Errorf("invalid epoch")
			}
		case int:
			if typed < 0 {
				return fmt.Errorf("invalid epoch")
			}
		case float64:
			if typed < 0 {
				return fmt.Errorf("invalid epoch")
			}
		default:
			return fmt.Errorf("invalid epoch type")
		}
	}

	if value, ok := config["instance"]; ok {
		instance, valid := value.(string)
		if !valid || strings.TrimSpace(instance) == "" {
			return fmt.Errorf("invalid instance")
		}
	}

	return nil
}

// obrimMarkerTimeGenerate produces the final time-based marker value.
func obrimMarkerTimeGenerate(epoch int64, instance string) (string, error) {
	// Mutable variable storing current timestamp.
	var currentTimestamp int64 = time.Now().UnixMilli()

	// Mutable variable storing relative timestamp.
	var relativeTimestamp int64 = currentTimestamp - epoch

	if relativeTimestamp < 0 {
		return "", fmt.Errorf("invalid timestamp")
	}

	source := fmt.Sprintf("%d:%s", relativeTimestamp, instance)

	hash := sha256.Sum256([]byte(source))

	return strings.ToUpper(base64.RawURLEncoding.EncodeToString(hash[:])), nil
}

// obrimMarkerRandom generates random collision-resistant markers.
func obrimMarkerRandom(config map[string]any) map[string]any {
	if err := obrimMarkerValidateRandom(config); err != nil {
		return obrimMarkerBuildResponse(
			false,
			"FAILED_VALIDATION",
			nil,
		)
	}

	// Mutable variable storing desired length.
	var length int = obrimMarkerDefaultLength

	if value, ok := config["length"]; ok {
		switch typed := value.(type) {
		case int:
			length = typed
		case int64:
			length = int(typed)
		case float64:
			length = int(typed)
		}
	}

	// Mutable variable storing charset.
	var charset string = obrimMarkerDefaultCharset

	if value, ok := config["charset"].(string); ok {
		charset = value
	}

	marker, err := obrimMarkerRandomGenerate(length, charset)
	if err != nil {
		return obrimMarkerBuildResponse(
			false,
			"FAILED_GENERATION",
			nil,
		)
	}

	payload := map[string]any{
		"marker":  marker,
		"length":  length,
		"charset": charset,
	}

	return obrimMarkerBuildResponse(
		true,
		"SUCCESS_RANDOM_GENERATED",
		payload,
	)
}

// obrimMarkerValidateRandom validates random marker configuration parameters.
func obrimMarkerValidateRandom(config map[string]any) error {
	if value, ok := config["length"]; ok {
		switch typed := value.(type) {
		case int:
			if typed <= 0 {
				return fmt.Errorf("invalid length")
			}
		case int64:
			if typed <= 0 {
				return fmt.Errorf("invalid length")
			}
		case float64:
			if typed <= 0 {
				return fmt.Errorf("invalid length")
			}
		default:
			return fmt.Errorf("invalid length type")
		}
	}

	if value, ok := config["charset"]; ok {
		charset, valid := value.(string)

		if !valid || len(charset) == 0 {
			return fmt.Errorf("invalid charset")
		}
	}

	return nil
}

// obrimMarkerRandomGenerate produces the final random marker value.
func obrimMarkerRandomGenerate(length int, charset string) (string, error) {
	// Mutable variable storing generated marker bytes.
	var markerBuilder strings.Builder

	charsetLength := len(charset)

	for index := 0; index < length; index++ {
		randomIndex, err := obrimMarkerRandomIndex(charsetLength)
		if err != nil {
			return "", err
		}

		markerBuilder.WriteByte(charset[randomIndex])
	}

	return markerBuilder.String(), nil
}

// obrimMarkerRandomIndex generates a secure random index.
func obrimMarkerRandomIndex(limit int) (int, error) {
	randomBytes := make([]byte, 8)

	if _, err := rand.Read(randomBytes); err != nil {
		return 0, err
	}

	randomValue := binary.BigEndian.Uint64(randomBytes)

	return int(randomValue % uint64(limit)), nil
}

// obrimMarkerEncoded generates deterministic encoded markers.
func obrimMarkerEncoded(config map[string]any) map[string]any {
	if err := obrimMarkerValidateEncoded(config); err != nil {
		return obrimMarkerBuildResponse(
			false,
			"FAILED_VALIDATION",
			nil,
		)
	}

	source := config["data"].(string)

	// Mutable variable storing desired length.
	var length int = obrimMarkerDefaultLength

	if value, ok := config["length"]; ok {
		switch typed := value.(type) {
		case int:
			length = typed
		case int64:
			length = int(typed)
		case float64:
			length = int(typed)
		}
	}

	// Mutable variable storing charset.
	var charset string = obrimMarkerDefaultCharset

	if value, ok := config["charset"].(string); ok {
		charset = value
	}

	// Mutable variable storing optional salt.
	var salt string

	if value, ok := config["salt"].(string); ok {
		salt = value
	}

	marker, err := obrimMarkerEncodedGenerate(
		source,
		length,
		charset,
		salt,
	)

	if err != nil {
		return obrimMarkerBuildResponse(
			false,
			"FAILED_GENERATION",
			nil,
		)
	}

	payload := map[string]any{
		"marker": marker,
		"source": source,
		"length": length,
	}

	return obrimMarkerBuildResponse(
		true,
		"SUCCESS_ENCODED_GENERATED",
		payload,
	)
}

// obrimMarkerValidateEncoded validates encoded marker configuration parameters.
func obrimMarkerValidateEncoded(config map[string]any) error {
	data, ok := config["data"].(string)

	if !ok || strings.TrimSpace(data) == "" {
		return fmt.Errorf("invalid data")
	}

	if value, ok := config["length"]; ok {
		switch typed := value.(type) {
		case int:
			if typed <= 0 {
				return fmt.Errorf("invalid length")
			}
		case int64:
			if typed <= 0 {
				return fmt.Errorf("invalid length")
			}
		case float64:
			if typed <= 0 {
				return fmt.Errorf("invalid length")
			}
		default:
			return fmt.Errorf("invalid length type")
		}
	}

	if value, ok := config["charset"]; ok {
		charset, valid := value.(string)

		if !valid || len(charset) == 0 {
			return fmt.Errorf("invalid charset")
		}
	}

	return nil
}

// obrimMarkerEncodedGenerate produces the final encoded marker value.
func obrimMarkerEncodedGenerate(
	source string,
	length int,
	charset string,
	salt string,
) (string, error) {
	hash := sha256.Sum256([]byte(source + salt))

	charsetLength := len(charset)

	if charsetLength == 0 {
		return "", fmt.Errorf("invalid charset")
	}

	// Mutable variable storing generated marker bytes.
	var markerBuilder strings.Builder

	for _, value := range hash {
		index := int(math.Abs(float64(value))) % charsetLength
		markerBuilder.WriteByte(charset[index])

		if markerBuilder.Len() >= length {
			break
		}
	}

	for markerBuilder.Len() < length {
		markerBuilder.WriteByte(charset[0])
	}

	return markerBuilder.String(), nil
}