type User struct {
    ID        uint
    Name      string
    Password  string
    CreatedAt time.Time
    UpdatedAt time.Time
}

// BeforeCreate 创建前钩子
func (u *User) BeforeCreate(tx *gorm.DB) (err error) {
    u.CreatedAt = time.Now()
    return
}

// AfterFind 查询后钩子
func (u *User) AfterFind(tx *gorm.DB) (err error) {
    // 解密敏感数据等
    return
}

type User struct {
    ID        uint
    Username  string
    Password  string
    Email     string
    Status    int
    CreatedAt time.Time
    UpdatedAt time.Time
}

// BeforeCreate 创建前：密码加密、设置默认值
func (u *User) BeforeCreate(tx *gorm.DB) (err error) {
    // 密码加密
    if u.Password != "" {
        hashedPassword, err := bcrypt.GenerateFromPassword([]byte(u.Password), bcrypt.DefaultCost)
        if err != nil {
            return err
        }
        u.Password = string(hashedPassword)
    }
    
    // 设置默认状态
    if u.Status == 0 {
        u.Status = 1
    }
    
    return
}

// BeforeUpdate 更新前：自动更新更新时间
func (u *User) BeforeUpdate(tx *gorm.DB) (err error) {
    u.UpdatedAt = time.Now()
    
    // 如果更新了密码，重新加密
    if tx.Statement.Changed("Password") {
        hashedPassword, _ := bcrypt.GenerateFromPassword([]byte(u.Password), bcrypt.DefaultCost)
        tx.Statement.SetColumn("Password", string(hashedPassword))
    }
    
    return
}

// AfterFind 查询后：脱敏处理
func (u *User) AfterFind(tx *gorm.DB) (err error) {
    // 脱敏：隐藏部分密码
    if len(u.Password) > 4 {
        u.Password = "****"
    }
    return
}

// BeforeDelete 删除前：检查是否可以删除
func (u *User) BeforeDelete(tx *gorm.DB) (err error) {
    if u.Status == 2 {  // 假设2是管理员
        return errors.New("管理员账户不能删除")
    }
    return
}

// 跳过所有钩子
db.Session(&gorm.Session{SkipHooks: true}).Create(&user)

// 跳过特定钩子
user.BeforeCreate = nil  // 不推荐

func (u *User) BeforeCreate(tx *gorm.DB) (err error) {
    // 修改当前语句的更新内容
    tx.Statement.SetColumn("Status", 1)
    return
}

func (u *User) BeforeUpdate(tx *gorm.DB) (err error) {
    // 检查字段是否改变
    if tx.Statement.Changed("Name", "Email") {
        tx.Statement.SetColumn("UpdatedAt", time.Now())
    }
    return
}

func (u *User) AfterCreate(tx *gorm.DB) (err error) {
    // 在事务中执行其他操作
    // 如果返回错误，整个事务会回滚
    return tx.Create(&UserLog{
        UserID: u.ID,
        Action: "created",
    }).Error
}

// 注册全局回调
db.Callback().Create().Before("gorm:create").Register("my_plugin:before_create", func(db *gorm.DB) {
    // 设置创建人
    if db.Statement.Schema != nil {
        if field := db.Statement.Schema.LookUpField("CreatedBy"); field != nil {
            // 从 context 获取当前用户
            if userID := db.Statement.Context.Value("userID"); userID != nil {
                field.Set(db.Statement.ReflectValue, userID)
            }
        }
    }
})

// 创建操作的回调顺序：
// before_create -> create -> after_create

// 查看所有回调
for name, processors := range db.Callback().Create().Processors {
    fmt.Println(name)
    for _, p := range processors {
        fmt.Println("  -", p.Name)
    }
}

// 移除回调
db.Callback().Create().Remove("my_plugin:before_create")

// 替换回调
db.Callback().Create().Replace("gorm:create", func(db *gorm.DB) {
    // 自定义创建逻辑
})

// AuditLog 审计日志模型
type AuditLog struct {
    ID          uint      `gorm:"primaryKey"`
    TableName   string
    RecordID    uint
    Operation   string    // CREATE/UPDATE/DELETE
    OldData     string    // JSON
    NewData     string    // JSON
    ChangedBy   uint      // 操作用户ID
    ChangedAt   time.Time
}

// Auditable 可审计接口
type Auditable interface {
    GetID() uint
    TableName() string
}

// 注册审计回调
func RegisterAuditCallbacks(db *gorm.DB) {
    // 创建审计
    db.Callback().Create().After("gorm:create").Register("audit:create", func(db *gorm.DB) {
        audit(db, "CREATE", nil, db.Statement.ReflectValue.Interface())
    })
    
    // 更新审计
    db.Callback().Update().Before("gorm:update").Register("audit:update:before", func(db *gorm.DB) {
        // 查询旧数据
        if db.Statement.Schema != nil {
            db.Statement.Set("audit:old_data", getOldData(db))
        }
    })
    
    db.Callback().Update().After("gorm:update").Register("audit:update:after", func(db *gorm.DB) {
        oldData, _ := db.Statement.Get("audit:old_data")
        audit(db, "UPDATE", oldData, db.Statement.ReflectValue.Interface())
    })
    
    // 删除审计
    db.Callback().Delete().Before("gorm:delete").Register("audit:delete:before", func(db *gorm.DB) {
        db.Statement.Set("audit:old_data", getOldData(db))
    })
    
    db.Callback().Delete().After("gorm:delete").Register("audit:delete:after", func(db *gorm.DB) {
        oldData, _ := db.Statement.Get("audit:old_data")
        audit(db, "DELETE", oldData, nil)
    })
}

func audit(db *gorm.DB, operation string, oldData, newData interface{}) {
    userID := db.Statement.Context.Value("userID")
    if userID == nil {
        userID = uint(0)
    }
    
    oldJSON, _ := json.Marshal(oldData)
    newJSON, _ := json.Marshal(newData)
    
    log := AuditLog{
        TableName: db.Statement.Table,
        Operation: operation,
        OldData:   string(oldJSON),
        NewData:   string(newJSON),
        ChangedBy: userID.(uint),
        ChangedAt: time.Now(),
    }
    
    // 使用新会话避免触发钩子循环
    db.Session(&gorm.Session{SkipHooks: true}).Create(&log)
}

func getOldData(db *gorm.DB) interface{} {
    // 实现查询旧数据逻辑
    return nil
}

// SoftDeleteModel 扩展软删除
type SoftDeleteModel struct {
    ID        uint           `gorm:"primaryKey"`
    DeletedAt gorm.DeletedAt `gorm:"index"`
    DeletedBy uint           // 删除人
}

func (m *SoftDeleteModel) BeforeDelete(tx *gorm.DB) (err error) {
    // 记录删除人
    if userID := tx.Statement.Context.Value("userID"); userID != nil {
        tx.Statement.SetColumn("DeletedBy", userID)
    }
    return
}

// Restore 恢复软删除
func (m *SoftDeleteModel) Restore(db *gorm.DB) error {
    return db.Model(m).Unscoped().Update("deleted_at", nil).Error
}