Reflection in Go

package main

import (
    "fmt"
    "reflect"
)

func examineType(x interface{}) {
    t := reflect.TypeOf(x)
    v := reflect.ValueOf(x)
    
    fmt.Printf("Type: %v\n", t)
    fmt.Printf("Kind: %v\n", t.Kind())
    fmt.Printf("Value: %v\n", v)
    fmt.Printf("Interface: %v\n", v.Interface())
    
    // Check properties
    fmt.Printf("Can set: %v\n", v.CanSet())
    fmt.Printf("Can addr: %v\n", v.CanAddr())
}

func main() {
    var x int = 42
    examineType(x)
    
    type Person struct {
        Name string
        Age  int
    }
    
    p := Person{"Alice", 30}
    examineType(p)
    
    // Examine pointer
    examineType(&p)
}

type User struct {
    ID       int    \`json:"id" db:"user_id"\`
    Name     string \`json:"name" db:"full_name"\`
    Email    string \`json:"email" db:"email_address"\`
    IsActive bool   \`json:"is_active" db:"active"\`
    private  string // unexported field
}

func inspectStruct(s interface{}) {
    t := reflect.TypeOf(s)
    v := reflect.ValueOf(s)
    
    if t.Kind() == reflect.Ptr {
        t = t.Elem()
        v = v.Elem()
    }
    
    if t.Kind() != reflect.Struct {
        fmt.Println("Not a struct")
        return
    }
    
    fmt.Printf("Struct: %s\n", t.Name())
    fmt.Printf("Fields: %d\n", t.NumField())
    
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        value := v.Field(i)
        
        fmt.Printf("\nField %d:\n", i)
        fmt.Printf("  Name: %s\n", field.Name)
        fmt.Printf("  Type: %s\n", field.Type)
        fmt.Printf("  Value: %v\n", value.Interface())
        fmt.Printf("  Exported: %v\n", field.IsExported())
        
        // Get tags
        if tag := field.Tag.Get("json"); tag != "" {
            fmt.Printf("  JSON tag: %s\n", tag)
        }
        if tag := field.Tag.Get("db"); tag != "" {
            fmt.Printf("  DB tag: %s\n", tag)
        }
    }
}

// Set struct fields dynamically
func setFieldByName(obj interface{}, fieldName string, value interface{}) error {
    v := reflect.ValueOf(obj)
    
    if v.Kind() != reflect.Ptr || v.Elem().Kind() != reflect.Struct {
        return fmt.Errorf("expected pointer to struct")
    }
    
    v = v.Elem()
    field := v.FieldByName(fieldName)
    
    if !field.IsValid() {
        return fmt.Errorf("field %s not found", fieldName)
    }
    
    if !field.CanSet() {
        return fmt.Errorf("field %s cannot be set", fieldName)
    }
    
    val := reflect.ValueOf(value)
    if field.Type() != val.Type() {
        return fmt.Errorf("type mismatch")
    }
    
    field.Set(val)
    return nil
}

type Calculator struct {
    value float64
}

func (c *Calculator) Add(x float64) float64 {
    c.value += x
    return c.value
}

func (c *Calculator) Multiply(x float64) float64 {
    c.value *= x
    return c.value
}

func (c Calculator) GetValue() float64 {
    return c.value
}

func callMethod(obj interface{}, methodName string, args ...interface{}) ([]reflect.Value, error) {
    v := reflect.ValueOf(obj)
    method := v.MethodByName(methodName)
    
    if !method.IsValid() {
        return nil, fmt.Errorf("method %s not found", methodName)
    }
    
    // Convert arguments to reflect.Value
    in := make([]reflect.Value, len(args))
    for i, arg := range args {
        in[i] = reflect.ValueOf(arg)
    }
    
    // Call method
    results := method.Call(in)
    return results, nil
}

// Generic function caller
func Call(fn interface{}, args ...interface{}) ([]interface{}, error) {
    v := reflect.ValueOf(fn)
    
    if v.Kind() != reflect.Func {
        return nil, fmt.Errorf("not a function")
    }
    
    t := v.Type()
    
    if len(args) != t.NumIn() {
        return nil, fmt.Errorf("wrong number of arguments")
    }
    
    in := make([]reflect.Value, len(args))
    for i, arg := range args {
        argValue := reflect.ValueOf(arg)
        argType := t.In(i)
        
        if !argValue.Type().AssignableTo(argType) {
            return nil, fmt.Errorf("argument %d type mismatch", i)
        }
        
        in[i] = argValue
    }
    
    out := v.Call(in)
    
    results := make([]interface{}, len(out))
    for i, val := range out {
        results[i] = val.Interface()
    }
    
    return results, nil
}

// Create slice dynamically
func makeSlice(elemType reflect.Type, len, cap int) interface{} {
    sliceType := reflect.SliceOf(elemType)
    slice := reflect.MakeSlice(sliceType, len, cap)
    return slice.Interface()
}

// Create map dynamically
func makeMap(keyType, valueType reflect.Type) interface{} {
    mapType := reflect.MapOf(keyType, valueType)
    m := reflect.MakeMap(mapType)
    return m.Interface()
}

// Create channel dynamically
func makeChannel(elemType reflect.Type, buffer int) interface{} {
    chanType := reflect.ChanOf(reflect.BothDir, elemType)
    ch := reflect.MakeChan(chanType, buffer)
    return ch.Interface()
}

// Deep copy using reflection
func DeepCopy(src interface{}) interface{} {
    if src == nil {
        return nil
    }
    
    original := reflect.ValueOf(src)
    cpy := reflect.New(original.Type()).Elem()
    copyRecursive(original, cpy)
    
    return cpy.Interface()
}

func copyRecursive(src, dst reflect.Value) {
    switch src.Kind() {
    case reflect.Ptr:
        if !src.IsNil() {
            dst.Set(reflect.New(src.Elem().Type()))
            copyRecursive(src.Elem(), dst.Elem())
        }
    
    case reflect.Interface:
        if !src.IsNil() {
            dst.Set(reflect.ValueOf(DeepCopy(src.Interface())))
        }
    
    case reflect.Struct:
        for i := 0; i < src.NumField(); i++ {
            if dst.Field(i).CanSet() {
                copyRecursive(src.Field(i), dst.Field(i))
            }
        }
    
    case reflect.Slice:
        if !src.IsNil() {
            dst.Set(reflect.MakeSlice(src.Type(), src.Len(), src.Cap()))
            for i := 0; i < src.Len(); i++ {
                copyRecursive(src.Index(i), dst.Index(i))
            }
        }
    
    case reflect.Map:
        if !src.IsNil() {
            dst.Set(reflect.MakeMap(src.Type()))
            for _, key := range src.MapKeys() {
                val := src.MapIndex(key)
                newVal := reflect.New(val.Type()).Elem()
                copyRecursive(val, newVal)
                dst.SetMapIndex(key, newVal)
            }
        }
    
    default:
        dst.Set(src)
    }
}

// JSON-like encoder using reflection
func Encode(v interface{}) (map[string]interface{}, error) {
    result := make(map[string]interface{})
    
    val := reflect.ValueOf(v)
    if val.Kind() == reflect.Ptr {
        val = val.Elem()
    }
    
    if val.Kind() != reflect.Struct {
        return nil, fmt.Errorf("expected struct")
    }
    
    typ := val.Type()
    
    for i := 0; i < val.NumField(); i++ {
        field := typ.Field(i)
        value := val.Field(i)
        
        if !field.IsExported() {
            continue
        }
        
        tag := field.Tag.Get("json")
        if tag == "-" {
            continue
        }
        
        name := field.Name
        if tag != "" {
            name = strings.Split(tag, ",")[0]
        }
        
        result[name] = value.Interface()
    }
    
    return result, nil
}

// Dependency injection container
type Container struct {
    services map[reflect.Type]interface{}
}

func NewContainer() *Container {
    return &Container{
        services: make(map[reflect.Type]interface{}),
    }
}

func (c *Container) Register(service interface{}) {
    t := reflect.TypeOf(service)
    c.services[t] = service
}

func (c *Container) Resolve(target interface{}) error {
    v := reflect.ValueOf(target)
    
    if v.Kind() != reflect.Ptr || v.Elem().Kind() != reflect.Struct {
        return fmt.Errorf("target must be pointer to struct")
    }
    
    v = v.Elem()
    t := v.Type()
    
    for i := 0; i < v.NumField(); i++ {
        field := v.Field(i)
        fieldType := t.Field(i)
        
        tag := fieldType.Tag.Get("inject")
        if tag != "true" {
            continue
        }
        
        service, ok := c.services[fieldType.Type]
        if !ok {
            return fmt.Errorf("service not found for %s", fieldType.Type)
        }
        
        field.Set(reflect.ValueOf(service))
    }
    
    return nil
}

// Validation using reflection
func Validate(s interface{}) []string {
    var errors []string
    
    v := reflect.ValueOf(s)
    t := reflect.TypeOf(s)
    
    if v.Kind() == reflect.Ptr {
        v = v.Elem()
        t = t.Elem()
    }
    
    for i := 0; i < v.NumField(); i++ {
        field := t.Field(i)
        value := v.Field(i)
        
        tag := field.Tag.Get("validate")
        if tag == "" {
            continue
        }
        
        rules := strings.Split(tag, ",")
        for _, rule := range rules {
            if rule == "required" && isZero(value) {
                errors = append(errors, fmt.Sprintf("%s is required", field.Name))
            }
            
            if strings.HasPrefix(rule, "min=") {
                min, _ := strconv.Atoi(strings.TrimPrefix(rule, "min="))
                if value.Kind() == reflect.String && len(value.String()) < min {
                    errors = append(errors, fmt.Sprintf("%s must be at least %d characters", field.Name, min))
                }
            }
        }
    }
    
    return errors
}

func isZero(v reflect.Value) bool {
    return v.Interface() == reflect.Zero(v.Type()).Interface()
}

// Generic JSON-like serializer using reflection
type Serializer struct {
    tagName string
    omitEmpty bool
}

func NewSerializer(tagName string) *Serializer {
    return &Serializer{tagName: tagName, omitEmpty: true}
}

func (s *Serializer) Serialize(v interface{}) (map[string]interface{}, error) {
    return s.serializeValue(reflect.ValueOf(v))
}

func (s *Serializer) serializeValue(v reflect.Value) (map[string]interface{}, error) {
    if v.Kind() == reflect.Ptr {
        if v.IsNil() {
            return nil, nil
        }
        v = v.Elem()
    }
    
    if v.Kind() != reflect.Struct {
        return nil, fmt.Errorf("expected struct, got %v", v.Kind())
    }
    
    result := make(map[string]interface{})
    t := v.Type()
    
    for i := 0; i < v.NumField(); i++ {
        field := t.Field(i)
        fieldValue := v.Field(i)
        
        if !field.IsExported() {
            continue
        }
        
        // Get field name from tag or use field name
        name := field.Name
        if tag := field.Tag.Get(s.tagName); tag != "" {
            parts := strings.Split(tag, ",")
            if parts[0] == "-" {
                continue
            }
            if parts[0] != "" {
                name = parts[0]
            }
        }
        
        // Handle different field types recursively
        switch fieldValue.Kind() {
        case reflect.Struct:
            nested, err := s.serializeValue(fieldValue)
            if err != nil {
                return nil, err
            }
            result[name] = nested
            
        case reflect.Slice, reflect.Array:
            arr := make([]interface{}, fieldValue.Len())
            for j := 0; j < fieldValue.Len(); j++ {
                elem := fieldValue.Index(j)
                if elem.Kind() == reflect.Struct {
                    nested, err := s.serializeValue(elem)
                    if err != nil {
                        return nil, err
                    }
                    arr[j] = nested
                } else {
                    arr[j] = elem.Interface()
                }
            }
            result[name] = arr
            
        default:
            result[name] = fieldValue.Interface()
        }
    }
    
    return result, nil
}