Dynamic Field Manipulation with Go Reflection

This challenge focuses on using Go's powerful reflect package to dynamically inspect and modify the fields of a struct. You'll create a function that takes a struct and a map of field names to their new values, updating the struct's fields accordingly. This is a common requirement for tasks like configuration loading, data serialization/deserialization, and building generic data manipulation tools.

Problem Description

Your task is to implement a Go function named UpdateStructFields that accepts two arguments:

1. A pointer to an interface{} (which will hold a struct).
2. A map[string]interface{} representing the fields to update and their new values.

The function should iterate through the provided map. For each key-value pair in the map:

• It should find the corresponding field in the struct pointed to by the interface{}.
• If the field exists and its type is compatible with the new value, it should update the field's value.
• The function should handle different basic Go types (integers, strings, booleans, floats).
• If a field is not found, or if the type is incompatible, the function should return an error.

Key Requirements:

• The input struct must be mutable, hence a pointer is provided.
• Field names are case-sensitive.
• Handle basic types: int, int64, float64, string, bool.
• Return a meaningful error if a field is not found, or if a type mismatch occurs that cannot be reasonably coerced (e.g., assigning a string to an int).

Expected Behavior: The function should successfully update the fields of the given struct with values from the map. If any operation fails, an error should be returned.

Edge Cases:

• Empty input map: The function should do nothing and return nil error.
• Input is not a pointer to a struct: Return an appropriate error.
• Field types that are not explicitly handled (e.g., slices, maps, nested structs): For this challenge, you can choose to either ignore these fields or return an error. For simplicity, let's aim to return an error if an unhandled type is encountered for an update.
• Zero values: Ensure zero values (e.g., 0 for int, "" for string) are handled correctly.

Examples

Example 1:

Input:
structPtr = &struct {
    Name string
    Age  int
}{
    Name: "Alice",
    Age:  30,
}
updates = map[string]interface{}{
    "Name": "Bob",
    "Age":  31,
}

Output:
structPtr will be updated to:
{
    Name: "Bob",
    Age:  31,
}
and the function will return nil.

Explanation: The function found the "Name" and "Age" fields and updated them with the new string and integer values, respectively.

Example 2:

Input:
structPtr = &struct {
    Active bool
    Score  float64
}{
    Active: true,
    Score:  95.5,
}
updates = map[string]interface{}{
    "Active": false,
    "Score":  98.7,
}

Output:
structPtr will be updated to:
{
    Active: false,
    Score:  98.7,
}
and the function will return nil.

Explanation: The boolean and float64 fields were updated successfully.

Example 3: (Type Mismatch Error)

Input:
structPtr = &struct {
    Count int
}{
    Count: 10,
}
updates = map[string]interface{}{
    "Count": "twenty", // Attempting to assign a string to an int field
}

Output:
An error will be returned, for example: "cannot set field 'Count' with incompatible type string for int".
structPtr will remain unchanged.

Explanation: The update for "Count" failed because the provided value "twenty" (string) is not compatible with the field's type (int).

Example 4: (Field Not Found Error)

Input:
structPtr = &struct {
    ID string
}{
    ID: "abc-123",
}
updates = map[string]interface{}{
    "NonExistentField": 100,
}

Output:
An error will be returned, for example: "field 'NonExistentField' not found in struct".
structPtr will remain unchanged.

Explanation: The field "NonExistentField" does not exist in the target struct.

Constraints

• The input interface{} must be a pointer to a struct.
• Field names in the updates map must match struct field names exactly (case-sensitive).
• The function should aim to handle basic Go types as listed in the problem description.
• The solution should be implemented in Go.

Notes

• The reflect package is your primary tool here. You'll likely need reflect.ValueOf and reflect.Indirect to get a mutable reflect.Value of the struct.
• When checking types and setting values, reflect.Kind and reflect.Value.CanSet() will be crucial.
• Consider how you will handle potential type coercions (e.g., int to int64). For this challenge, simple assignments for compatible types are sufficient, and explicit error for incompatible ones.
• Remember to handle the case where the input interface{} is nil or not a pointer.