package main

import (
    "fmt"
    "math"
    "reflect"
)

// approxEqual 判断两个浮点数是否接近
func approxEqual(a, b, epsilon float64) bool {
    return math.Abs(a-b) < epsilon
}

// deepCompare 使用反射进行深度比较，可忽略指定字段
func deepCompare(x, y interface{}, opts ...CompareOption) bool {
    opt := defaultOptions()
    for _, o := range opts {
        o(opt)
    }

    vx := reflect.ValueOf(x)
    vy := reflect.ValueOf(y)

    if !vx.IsValid() && !vy.IsValid() {
        return true
    }
    if !vx.IsValid() || !vy.IsValid() {
        return false
    }

    // 解引用指针
    if vx.Kind() == reflect.Ptr {
        if !vx.IsNil() {
            vx = vx.Elem()
        } else {
            return vy.IsNil()
        }
    }
    if vy.Kind() == reflect.Ptr {
        if !vy.IsNil() {
            vy = vy.Elem()
        } else {
            return vx.IsNil()
        }
    }

    return compareValue(vx, vy, opt)
}

type CompareOptions struct {
    skipTags map[string]bool
    floatEpsilon float64
}

type CompareOption func(*CompareOptions)

func WithSkipTag(tag string) CompareOption {
    return func(o *CompareOptions) {
        o.skipTags[tag] = true
    }
}

func WithFloatPrecision(eps float64) CompareOption {
    return func(o *CompareOptions) {
        o.floatEpsilon = eps
    }
}

func defaultOptions() *CompareOptions {
    return &CompareOptions{
        skipTags:     make(map[string]bool),
        floatEpsilon: 1e-9,
    }
}

func compareValue(vx, vy reflect.Value, opt *CompareOptions) bool {
    if vx.Type() != vy.Type() {
        return false
    }

    switch vx.Kind() {
    case reflect.Struct:
        for i := 0; i < vx.NumField(); i++ {
            field := vx.Type().Field(i)
            if opt.skipTags[field.Name] {
                continue
            }
            // 检查 cmp tag
            if tag := field.Tag.Get("cmp"); tag == "-" {
                continue
            }
            if !compareValue(vx.Field(i), vy.Field(i), opt) {
                return false
            }
        }
        return true

    case reflect.Slice:
        if vx.Len() != vy.Len() {
            return false
        }
        for i := 0; i < vx.Len(); i++ {
            if !compareValue(vx.Index(i), vy.Index(i), opt) {
                return false
            }
        }
        return true

    case reflect.Map:
        if vx.Len() != vy.Len() {
            return false
        }
        for _, k := range vx.MapKeys() {
            v1 := vx.MapIndex(k)
            v2 := vy.MapIndex(k)
            if !v2.IsValid() || !compareValue(v1, v2, opt) {
                return false
            }
        }
        return true

    case reflect.Float32, reflect.Float64:
        f1 := vx.Float()
        f2 := vy.Float()
        return approxEqual(f1, f2, opt.floatEpsilon)

    default:
        return reflect.DeepEqual(vx.Interface(), vy.Interface())
    }
}

type User struct {
    ID       int    `cmp:"-"`
    Name     string
    Email    string `cmp:"-"`
    Age      float64
    Metadata map[string]interface{}
}

func main() {
    u1 := User{
        ID:    1,
        Name:  "Alice",
        Email: "a@example.com",
        Age:   30.000000001,
        Metadata: map[string]interface{}{
            "tags": []string{"user", "vip"},
        },
    }

    u2 := User{
        ID:    2,
        Name:  "Alice",
        Email: "alice@new.com",
        Age:   30.0,
        Metadata: map[string]interface{}{
            "tags": []string{"user", "vip"},
        },
    }

    equal := deepCompare(u1, u2,
        WithSkipTag("ID"),
        WithFloatPrecision(1e-6),
    )

    fmt.Println("结构体内容基本一致:", equal) // 输出 true
}