unmarshal.go

package jsonpartial

import (
	"encoding/json"
	"fmt"
	"reflect"
)

func Unmarshal(data []byte, v any) error {
	rv := reflect.ValueOf(v)

	// Must be a pointer
	if rv.Kind() != reflect.Pointer || rv.IsNil() {
		return fmt.Errorf("jsonpartial: Unmarshal requires a non-nil pointer, got %T", v)
	}

	// Get the element type
	elem := rv.Elem()

	// Handle different types
	switch elem.Kind() {
	case reflect.Struct:
		return unmarshalStruct(data, elem)
	case reflect.Slice:
		return unmarshalSlice(data, elem)
	case reflect.Map:
		return unmarshalMap(data, elem)
	default:
		// For primitives, use standard unmarshal
		return json.Unmarshal(data, v)
	}
}

func unmarshalStruct(data []byte, rv reflect.Value) error {
	// First, unmarshal to a map to get all fields
	var rawMap map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMap); err != nil {
		return err
	}

	// Filter out marshalonly-only fields
	if err := filterStructFields(rawMap, rv.Type(), FieldTag{}); err != nil {
		return err
	}

	// Now unmarshal the filtered data to the struct
	filteredData, err := json.Marshal(rawMap)
	if err != nil {
		return err
	}

	return json.Unmarshal(filteredData, rv.Addr().Interface())
}

// filterStructFields removes marshalonly-only fields from rawMap based on struct type
func filterStructFields(rawMap map[string]json.RawMessage, rt reflect.Type, inheritedTag FieldTag) error {
	for i := 0; i < rt.NumField(); i++ {
		field := rt.Field(i)

		if !field.IsExported() {
			continue
		}

		ft, err := ParseTag(field.Tag)
		if err != nil {
			return err
		}

		// Inherit tags from parent embedded field
		if inheritedTag.HasMarshalOnly {
			ft.HasMarshalOnly = true
		}
		if inheritedTag.HasUnmarshalOnly {
			ft.HasUnmarshalOnly = true
		}

		// Get the key name
		key := ft.Name
		if key == "" {
			key = field.Name
		}

		// Handle embedded structs (anonymous fields)
		if field.Anonymous && field.Type.Kind() == reflect.Struct {
			// For embedded structs, process their fields at the same level
			if err := filterStructFields(rawMap, field.Type, ft); err != nil {
				return err
			}
			continue
		}

		// Handle nested struct fields (non-embedded)
		if field.Type.Kind() == reflect.Struct {
			if rawValue, ok := rawMap[key]; ok {
				// Recursively filter the nested struct's content
				var nestedMap map[string]json.RawMessage
				if err := json.Unmarshal(rawValue, &nestedMap); err != nil {
					return err
				}

				if err := filterStructFields(nestedMap, field.Type, FieldTag{}); err != nil {
					return err
				}

				// Update the rawMap with filtered nested data
				filteredValue, err := json.Marshal(nestedMap)
				if err != nil {
					return err
				}
				rawMap[key] = filteredValue
			}
			continue
		}

		// Handle slice fields containing structs
		if field.Type.Kind() == reflect.Slice || field.Type.Kind() == reflect.Array {
			elemType := field.Type.Elem()
			// Handle slice of structs
			if elemType.Kind() == reflect.Struct {
				if rawValue, ok := rawMap[key]; ok {
					var nestedSlice []json.RawMessage
					if err := json.Unmarshal(rawValue, &nestedSlice); err != nil {
						return err
					}

					// Filter each element
					for i, elem := range nestedSlice {
						var nestedMap map[string]json.RawMessage
						if err := json.Unmarshal(elem, &nestedMap); err != nil {
							return err
						}

						if err := filterStructFields(nestedMap, elemType, FieldTag{}); err != nil {
							return err
						}

						filteredValue, err := json.Marshal(nestedMap)
						if err != nil {
							return err
						}
						nestedSlice[i] = filteredValue
					}

					filteredValue, err := json.Marshal(nestedSlice)
					if err != nil {
						return err
					}
					rawMap[key] = filteredValue
				}
				continue
			}
			// Handle slice of pointers to structs
			if elemType.Kind() == reflect.Pointer && elemType.Elem().Kind() == reflect.Struct {
				if rawValue, ok := rawMap[key]; ok {
					var nestedSlice []json.RawMessage
					if err := json.Unmarshal(rawValue, &nestedSlice); err != nil {
						return err
					}

					// Filter each element
					for i, elem := range nestedSlice {
						if string(elem) == "null" {
							continue
						}

						var nestedMap map[string]json.RawMessage
						if err := json.Unmarshal(elem, &nestedMap); err != nil {
							return err
						}

						if err := filterStructFields(nestedMap, elemType.Elem(), FieldTag{}); err != nil {
							return err
						}

						filteredValue, err := json.Marshal(nestedMap)
						if err != nil {
							return err
						}
						nestedSlice[i] = filteredValue
					}

					filteredValue, err := json.Marshal(nestedSlice)
					if err != nil {
						return err
					}
					rawMap[key] = filteredValue
				}
				continue
			}
		}

		// Handle map fields containing structs
		if field.Type.Kind() == reflect.Map {
			elemType := field.Type.Elem()
			// Handle map with struct values
			if elemType.Kind() == reflect.Struct {
				if rawValue, ok := rawMap[key]; ok {
					var nestedMap map[string]json.RawMessage
					if err := json.Unmarshal(rawValue, &nestedMap); err != nil {
						return err
					}

					// Filter each value
					for mapKey, elem := range nestedMap {
						var elemMap map[string]json.RawMessage
						if err := json.Unmarshal(elem, &elemMap); err != nil {
							return err
						}

						if err := filterStructFields(elemMap, elemType, FieldTag{}); err != nil {
							return err
						}

						filteredValue, err := json.Marshal(elemMap)
						if err != nil {
							return err
						}
						nestedMap[mapKey] = filteredValue
					}

					filteredValue, err := json.Marshal(nestedMap)
					if err != nil {
						return err
					}
					rawMap[key] = filteredValue
				}
				continue
			}
			// Handle map with pointer to struct values
			if elemType.Kind() == reflect.Pointer && elemType.Elem().Kind() == reflect.Struct {
				if rawValue, ok := rawMap[key]; ok {
					var nestedMap map[string]json.RawMessage
					if err := json.Unmarshal(rawValue, &nestedMap); err != nil {
						return err
					}

					// Filter each value
					for mapKey, elem := range nestedMap {
						if string(elem) == "null" {
							continue
						}

						var elemMap map[string]json.RawMessage
						if err := json.Unmarshal(elem, &elemMap); err != nil {
							return err
						}

						if err := filterStructFields(elemMap, elemType.Elem(), FieldTag{}); err != nil {
							return err
						}

						filteredValue, err := json.Marshal(elemMap)
						if err != nil {
							return err
						}
						nestedMap[mapKey] = filteredValue
					}

					filteredValue, err := json.Marshal(nestedMap)
					if err != nil {
						return err
					}
					rawMap[key] = filteredValue
				}
				continue
			}
		}

		// Handle pointer fields containing structs
		if field.Type.Kind() == reflect.Pointer && field.Type.Elem().Kind() == reflect.Struct {
			if rawValue, ok := rawMap[key]; ok {
				if string(rawValue) == "null" {
					continue
				}

				var nestedMap map[string]json.RawMessage
				if err := json.Unmarshal(rawValue, &nestedMap); err != nil {
					return err
				}

				if err := filterStructFields(nestedMap, field.Type.Elem(), FieldTag{}); err != nil {
					return err
				}

				filteredValue, err := json.Marshal(nestedMap)
				if err != nil {
					return err
				}
				rawMap[key] = filteredValue
			}
			continue
		}

		// Skip fields that shouldn't be unmarshaled (marshalonly-only or ignored)
		if ft.MustBeIgnored || ft.HasMarshalOnly {
			delete(rawMap, key)
		}
	}

	return nil
}

func unmarshalSlice(data []byte, rv reflect.Value) error {
	// Unmarshal as []json.RawMessage first
	var rawSlice []json.RawMessage
	if err := json.Unmarshal(data, &rawSlice); err != nil {
		return err
	}

	// Get the element type
	elemType := rv.Type().Elem()

	// Create a new slice with the right length
	result := reflect.MakeSlice(rv.Type(), len(rawSlice), len(rawSlice))

	// Unmarshal each element
	for i, rawElem := range rawSlice {
		elem := result.Index(i)

		if elemType.Kind() == reflect.Struct {
			if err := unmarshalStruct(rawElem, elem); err != nil {
				return err
			}
		} else if elemType.Kind() == reflect.Pointer && elemType.Elem().Kind() == reflect.Struct {
			// Pointer to struct - create new instance
			newElem := reflect.New(elemType.Elem())
			if err := unmarshalStruct(rawElem, newElem.Elem()); err != nil {
				return err
			}
			elem.Set(newElem)
		} else {
			// Other types - direct unmarshal
			if err := json.Unmarshal(rawElem, elem.Addr().Interface()); err != nil {
				return err
			}
		}
	}

	rv.Set(result)
	return nil
}

func unmarshalMap(data []byte, rv reflect.Value) error {
	// Unmarshal as map[string]json.RawMessage
	var rawMap map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMap); err != nil {
		return err
	}

	// Get map type info
	mapType := rv.Type()
	keyType := mapType.Key()
	valueType := mapType.Elem()

	// Create new map
	result := reflect.MakeMap(mapType)

	// Unmarshal each value
	for keyStr, rawValue := range rawMap {
		// Parse key
		key := reflect.New(keyType).Elem()
		if err := json.Unmarshal(fmt.Appendf(nil, "%q", keyStr), key.Addr().Interface()); err != nil {
			return err
		}

		// Parse value
		value := reflect.New(valueType).Elem()

		if valueType.Kind() == reflect.Struct {
			if err := unmarshalStruct(rawValue, value); err != nil {
				return err
			}
		} else if valueType.Kind() == reflect.Pointer && valueType.Elem().Kind() == reflect.Struct {
			newElem := reflect.New(valueType.Elem())
			if err := unmarshalStruct(rawValue, newElem.Elem()); err != nil {
				return err
			}
			value.Set(newElem)
		} else {
			if err := json.Unmarshal(rawValue, value.Addr().Interface()); err != nil {
				return err
			}
		}

		result.SetMapIndex(key, value)
	}

	rv.Set(result)
	return nil
}