github.com/angryronald/go-kit@v0.0.0-20240505173814-ff2bd9c79dbf/generic/repository/memcached/generic.utils.go

package memcached

import (
	"errors"
	"fmt"
	"reflect"
	"strings"

	"github.com/angryronald/go-kit/cast"
	"github.com/angryronald/go-kit/generic/repository"
)

func checkRelationalOperation(prev bool, current bool, relationalOperation repository.RelationalOperation) (bool, error) {
	switch relationalOperation {
	case repository.AND:
		return prev && current, nil

	case repository.OR:
		return prev || current, nil

	default:
		return false, repository.ErrNotImplement
	}
}

func checkConditionalOperation(expected interface{}, actual interface{}, conditionalOperations repository.ConditionalOperation) (bool, error) {
	switch conditionalOperations {
	case repository.EQUAL_WITH:
		return expected == actual, nil

	case repository.GREATER_THAN:
		return actual.(int) > expected.(int), nil

	case repository.GREATER_THAN_EQUAL:
		return actual.(int) >= expected.(int), nil

	case repository.LESS_THAN:
		return actual.(int) < expected.(int), nil

	case repository.LESS_THAN_EQUAL:
		return actual.(int) <= expected.(int), nil

	case repository.LIKE:
		if expected.(string)[0] == '%' && expected.(string)[len(expected.(string))-1] != '%' {
			return strings.HasSuffix(actual.(string), expected.(string)[1:]), nil
		}
		if expected.(string)[0] != '%' && expected.(string)[len(expected.(string))-1] == '%' {
			return strings.HasPrefix(actual.(string), expected.(string)[:len(expected.(string))-1]), nil
		}
		return strings.Contains(actual.(string), expected.(string)[1:len(expected.(string))-1]), nil

	case repository.ILIKE:
		expected = strings.ToLower(expected.(string))
		actual = strings.ToLower(actual.(string))
		if expected.(string)[0] == '%' && expected.(string)[len(expected.(string))-1] != '%' {
			return strings.HasSuffix(actual.(string), expected.(string)[1:]), nil
		}
		if expected.(string)[0] != '%' && expected.(string)[len(expected.(string))-1] == '%' {
			return strings.HasPrefix(actual.(string), expected.(string)[:len(expected.(string))-1]), nil
		}
		return strings.Contains(actual.(string), expected.(string)[1:len(expected.(string))-1]), nil
	case repository.IS:
		return false, repository.ErrNotImplement

	case repository.NOT:
		return false, repository.ErrNotImplement

	case repository.IS_NOT:
		return false, repository.ErrNotImplement

	case repository.IN:
		return false, repository.ErrNotImplement

	default:
		return false, repository.ErrNotImplement
	}
}

func extractObjectAndCheckConditions(object interface{}, params map[string]interface{}, conditionalOperations []repository.ConditionalOperation, relationalOperations []repository.RelationalOperation) (bool, error) {
	var result bool
	var prevResult bool
	var isPrevResultNotSet bool = true
	var err error
	index := 0

	if repository.IsMapStringInterface(object) {
		objectInMap, ok := object.(map[string]interface{})
		if !ok {
			return false, fmt.Errorf("input is not a map[string]interface{}")
		}

		for k, paramValue := range params {
			var foundValue interface{}
			isFound := false
			for propertyName, propertyValue := range objectInMap {
				if strings.ToUpper(propertyName) == k {
					foundValue = propertyValue
					isFound = true
				}
			}
			if !isFound {
				return false, repository.ErrNotFound
			}
			if result, err = checkConditionalOperation(paramValue, foundValue, conditionalOperations[index]); err != nil {
				return false, err
			}

			if isPrevResultNotSet {
				prevResult = result
				isPrevResultNotSet = false
			} else {
				if prevResult, err = checkRelationalOperation(prevResult, result, relationalOperations[index-1]); err != nil {
					return false, err
				}
			}
			index++
		}

		return prevResult, nil
	}

	t := reflect.TypeOf(object)
	v := reflect.ValueOf(object)

	// Iterate through the struct fields
	index = 0
	isPrevResultNotSet = true
	for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)
		value := v.Field(i).Interface()

		for k, paramValue := range params {
			if strings.EqualFold(field.Name, k) && value == paramValue {
				if result, err = checkConditionalOperation(paramValue, value, conditionalOperations[index]); err != nil {
					return false, err
				}

				if isPrevResultNotSet {
					prevResult = result
					isPrevResultNotSet = false
				} else {
					if prevResult, err = checkRelationalOperation(prevResult, result, relationalOperations[index-1]); err != nil {
						return false, err
					}
				}
				index++
			}
		}
	}

	return prevResult, nil
}

// CreateStructPointerSlice creates a slice of struct pointers with the same type as the input struct.
// func CreateStructPointerSlice(inputStruct interface{}, numElements int) interface{} {
// 	// Check if the input is already a slice
// 	if reflect.TypeOf(inputStruct).Kind() == reflect.Slice {
// 		return inputStruct
// 	}

// 	// Get the type of the input struct.
// 	structType := reflect.TypeOf(inputStruct)

// 	// Create a new slice with the same type as a pointer to the input struct.
// 	sliceType := reflect.SliceOf(reflect.PtrTo(structType))
// 	newSlice := reflect.MakeSlice(sliceType, numElements, numElements)

// 	// Create instances of the input struct and store them as pointers in the slice.
// 	for i := 0; i < numElements; i++ {
// 		structPtr := reflect.New(structType).Elem()
// 		newSlice.Index(i).Set(structPtr.Addr())
// 	}

// 	return newSlice.Interface()
// }

// CreateStructPointerSlice creates a slice of struct pointers with the same type as the input struct.
func CreateStructPointerSlice(inputStruct interface{}, numElements int) interface{} {
	// Get the type of the input struct.
	structType := reflect.TypeOf(inputStruct)

	// Create a new slice with the same type as a pointer to the input struct.
	sliceType := reflect.SliceOf(reflect.PtrTo(structType))
	newSlice := reflect.MakeSlice(sliceType, numElements, numElements)

	// Create instances of the input struct and store them as pointers in the slice.
	for i := 0; i < numElements; i++ {
		structPtr := reflect.New(structType).Elem()
		newSlice.Index(i).Set(structPtr.Addr())
	}

	return newSlice.Interface()
}

// CreateNewStructObject takes a struct pointer as a parameter and returns a new object of the same struct type.
func CreateNewStructObject(inputStruct interface{}) interface{} {
	// Get the concrete type of the inputStruct
	structType := reflect.TypeOf(inputStruct)

	// Create a new instance of the struct type.
	newStruct := reflect.New(structType).Elem()

	// Copy the values from inputStruct to copiedStruct
	newStruct.Set(reflect.ValueOf(inputStruct))

	// Return the new object as an interface{}.
	return newStruct.Interface()
}

func findItemByID(collection interface{}, data interface{}) (int, error) {
	resultInArray := cast.StructPointerArrayToInterfacePointerArray(collection)
	for i, singleResult := range resultInArray {
		sourceID, err := repository.GetStructPropertyAsString(singleResult, defaultIDPropertyName)
		if err != nil {
			return -1, err
		}

		targetID, err := repository.GetStructPropertyAsString(data, defaultIDPropertyName)
		if err != nil {
			return -1, err
		}

		if sourceID == targetID {
			return i, nil
		}
	}

	return -1, repository.ErrNotFound
}

func UpdateCollection(collection interface{}, data interface{}) ([]interface{}, error) {
	index, err := findItemByID(collection, data)
	if err != nil {
		return nil, err
	}

	resultInArray := cast.StructPointerArrayToInterfacePointerArray(collection)
	resultInArray[index] = data
	return resultInArray, nil
}

func DeleteCollection(collection interface{}, data interface{}) ([]interface{}, error) {
	index, err := findItemByID(collection, data)
	if err != nil {
		return nil, err
	}

	resultInArray := cast.StructPointerArrayToInterfacePointerArray(collection)
	return append(resultInArray[:index], resultInArray[index+1:]...), nil
}

// // CreateStructPointerSlice takes an interface{} and returns a slice of struct pointers
// func CreateStructPointerSlice(input interface{}) interface{} {
// 	inputType := reflect.TypeOf(input)

// 	// Check if the input is a slice
// 	if inputType.Kind() == reflect.Slice {
// 		sliceType := inputType.Elem()
// 		// Check if the slice's element type is a struct
// 		if sliceType.Kind() == reflect.Struct {
// 			// Create a slice of struct pointers
// 			slicePtrType := reflect.SliceOf(reflect.PtrTo(sliceType))
// 			slicePtr := reflect.New(slicePtrType).Elem()
// 			// Loop through the elements of the input slice and convert them to pointers
// 			for i := 0; i < reflect.ValueOf(input).Len(); i++ {
// 				elem := reflect.ValueOf(input).Index(i)
// 				ptr := reflect.New(sliceType)
// 				ptr.Elem().Set(elem)
// 				slicePtr = reflect.Append(slicePtr, ptr)
// 			}
// 			return slicePtr.Interface()
// 		}
// 	}

// 	// Check if the input is a single struct
// 	if inputType.Kind() == reflect.Struct {
// 		// Create a slice with a single struct pointer
// 		slicePtrType := reflect.SliceOf(reflect.PtrTo(inputType))
// 		slicePtr := reflect.New(slicePtrType).Elem()
// 		ptr := reflect.New(inputType)
// 		ptr.Elem().Set(reflect.ValueOf(input))
// 		slicePtr = reflect.Append(slicePtr, ptr)
// 		return slicePtr.Interface()
// 	}

// 	// Return nil if the input is not a valid type
// 	return nil
// }

// // AreStructsEqual compares two struct objects for equality.
// func AreStructsEqual(a, b interface{}) bool {
// 	valA := reflect.ValueOf(a)
// 	valB := reflect.ValueOf(b)

// 	// Check if both values are of struct type.
// 	if valA.Kind() != reflect.Struct || valB.Kind() != reflect.Struct {
// 		return false
// 	}

// 	// Get the number of fields in each struct.
// 	numFieldsA := valA.NumField()
// 	numFieldsB := valB.NumField()

// 	// If the number of fields is different, the structs are not equal.
// 	if numFieldsA != numFieldsB {
// 		return false
// 	}

// 	// Compare each field.
// 	for i := 0; i < numFieldsA; i++ {
// 		fieldA := valA.Field(i)
// 		fieldB := valB.Field(i)

// 		// Compare field values.
// 		if !reflect.DeepEqual(fieldA.Interface(), fieldB.Interface()) {
// 			return false
// 		}
// 	}

// 	// All fields are equal, so the structs are equal.
// 	return true
// }

func AreStructsEqual(struct1, struct2 interface{}) bool {
	val1 := reflect.Indirect(reflect.ValueOf(struct1))
	val2 := reflect.Indirect(reflect.ValueOf(struct2))

	if val1.Kind() != val2.Kind() {
		return false
	}

	if val1.Type() != val2.Type() {
		return false
	}

	return reflect.DeepEqual(val1.Interface(), val2.Interface())
}

// GetPropertyNameToUpperCaseMapping returns a map of property names in upper case for the given struct.
func GetPropertyNameToUpperCaseMapping(obj interface{}) (map[string]string, error) {
	objValue := reflect.ValueOf(obj)
	if objValue.Kind() != reflect.Struct {
		return nil, errors.New("input must be a struct")
	}

	mapping := make(map[string]string)
	objType := objValue.Type()

	for i := 0; i < objValue.NumField(); i++ {
		field := objType.Field(i)
		fieldName := field.Name
		upperCaseFieldName := strings.ToUpper(fieldName)
		mapping[fieldName] = upperCaseFieldName
	}

	return mapping, nil
}