五、复杂查询、Protobuf 与代码生成

-- INNER JOIN（内连接）：只返回两表匹配的行
SELECT * FROM user u
INNER JOIN order o ON u.id = o.user_id;

-- LEFT JOIN（左连接）：返回左表所有行，右表不匹配的为 NULL
SELECT * FROM user u
LEFT JOIN order o ON u.id = o.user_id;

-- RIGHT JOIN（右连接）：返回右表所有行，左表不匹配的为 NULL
SELECT * FROM user u
RIGHT JOIN order o ON u.id = o.user_id;

-- USING 语法：当两表列名相同时可以用 USING
SELECT * FROM user u
INNER JOIN order o USING (user_id);

// Beego 的 QueryBuilder JOIN
qb, _ := orm.NewQueryBuilder("mysql")
qb.Select("u.name", "o.id").
   From("user", "u").
   InnerJoin("order", "o").On("u.id = o.user_id").
   Where("u.age > ?", 18)
sql := qb.String()

// GORM 的 Preload
// 本质上是一个 JOIN 查询，把相关数据都查出来并组装成结构体
db.Preload("Orders").Find(&users)
// 会生成类似：SELECT * FROM users JOIN orders ON ...

// table.go 文件

// TableReference 是 FROM 子句的抽象接口
// 它有三种实现：
//   1. Table：普通的表
//   2. Join：JOIN 查询
//   3. Subquery：子查询
type TableReference interface {
    // tableReference 是一个标记方法
    // 只有实现了此接口的类型才能用于 FROM 子句
    tableReference()
}

// ========== Table 普通表 ==========
// Table 代表一个普通的表
// 它也是 JOIN 查询的起点

type Table struct {
    // name 表名
    name  string
    // alias 表别名（AS）
    // 例如：FROM user u 中的 u
    alias string
}

// TableOf 创建一个 Table 实例
// 用法：orm.TableOf("user") 或 orm.TableOf("user", "u")
func TableOf(name string, alias ...string) *Table {
    t := &Table{name: name}
    if len(alias) > 0 {
        t.alias = alias[0]
    }
    return t
}

// tableReference 实现 TableReference 接口
func (t *Table) tableReference() {}

// As 设置表别名
// 返回新对象，支持链式调用
func (t *Table) As(alias string) *Table {
    return &Table{
        name:  t.name,
        alias: alias,
    }
}

// join.go 文件

// Join 代表一个 JOIN 查询
// JOIN 可以进一步 JOIN，形成嵌套
type Join struct {
    // typ JOIN 类型："INNER"、"LEFT"、"RIGHT"
    typ    string
    // table 被连接的表
    table  TableReference
    // using USING 子句的列名列表（和 cond 互斥）
    using  []string
    // cond ON 子句的条件表达式（和 using 互斥）
    cond   Expression
    // left JOIN 的左操作数（用于嵌套 JOIN）
    left   TableReference
}

// tableReference 实现 TableReference 接口
// 这样 Join 本身也可以作为 FROM 的输入
func (j *Join) tableReference() {}

// ========== JoinBuilder ==========
// JoinBuilder 用于构建 JOIN 子句
// 设计理念与 OnDuplicateKeyBuilder 一致

type JoinBuilder struct {
    // typ JOIN 类型
    typ   string
    // table 被连接的表
    table TableReference
}

// Join 创建一个 JoinBuilder
// 用法：orm.Join(orm.TableOf("order", "o"))
func Join(table TableReference) *JoinBuilder {
    return &JoinBuilder{
        typ:   "INNER",  // 默认 INNER JOIN
        table: table,
    }
}

// LeftJoin 创建一个 LEFT JOIN
func LeftJoin(table TableReference) *JoinBuilder {
    return &JoinBuilder{
        typ:   "LEFT",
        table: table,
    }
}

// RightJoin 创建一个 RIGHT JOIN
func RightJoin(table TableReference) *JoinBuilder {
    return &JoinBuilder{
        typ:   "RIGHT",
        table: table,
    }
}

// On 是终结方法，使用 ON 条件
// 返回 Join，不能再调用 Using
// 这种设计可以避免用户同时调用 On 和 Using
func (j *JoinBuilder) On(cond Expression) *Join {
    return &Join{
        typ:   j.typ,
        table: j.table,
        cond:  cond,
    }
}

// Using 是终结方法，使用 USING 列名
// 返回 Join，不能再调用 On
func (j *JoinBuilder) Using(cols ...string) *Join {
    return &Join{
        typ:   j.typ,
        table: j.table,
        using: cols,
    }
}

// join.go 文件（续）

// Join 在当前 Join 的基础上继续 INNER JOIN
// 支持链式调用，形成嵌套 JOIN
func (j *Join) Join(table TableReference) *JoinBuilder {
    return &JoinBuilder{
        typ:   "INNER",
        // 注意：当前 Join 作为左操作数
        table: table,
    }
}

func (j *Join) LeftJoin(table TableReference) *JoinBuilder {
    return &JoinBuilder{
        typ:   "LEFT",
        table: table,
    }
}

func (j *Join) RightJoin(table TableReference) *JoinBuilder {
    return &JoinBuilder{
        typ:   "RIGHT",
        table: table,
    }
}

// 使用示例：嵌套 JOIN
// SELECT * FROM user u
// INNER JOIN order o ON u.id = o.user_id
// LEFT JOIN item i ON o.id = i.order_id

query := orm.NewSelector[User](db).
    From(orm.TableOf("user", "u")).
    Join(orm.TableOf("order", "o")).
        On(orm.C("u.Id").EQ(orm.C("o.UserId"))).
    LeftJoin(orm.TableOf("item", "i")).
        On(orm.C("o.Id").EQ(orm.C("i.OrderId")))

// selector.go 文件

// Selector 是 SELECT 语句的构造器
type Selector[T any] struct {
    core
    session Session

    // table FROM 子句
    // 从原来的 string 改为 TableReference
    // 这样可以支持 JOIN 和子查询
    table TableReference

    // selects 指定的列
    selects []Selectable

    // where WHERE 条件
    where   []Expression

    // ... 其它字段
}

// From 指定 FROM 子句
// 参数从 string 改为 TableReference
// 兼容旧用法：orm.TableOf("user") 传给 From
func (s *Selector[T]) From(table TableReference) *Selector[T] {
    s.table = table
    return s
}

// buildFrom 构建 FROM 子句
func (s *Selector[T]) buildFrom(sb *strings.Builder) error {
    // 使用类型断言判断是哪种 TableReference
    switch t := s.table.(type) {
    case nil:
        // 用户没有调用 From 方法
        // 使用模型默认的表名
        sb.WriteString(s.model.TableName)
    case *Table:
        // 普通表
        s.buildTable(sb, t)
    case *Join:
        // JOIN 查询
        if err := s.buildJoin(sb, t); err != nil {
            return err
        }
    }
    return nil
}

// buildTable 构建表引用
func (s *Selector[T]) buildTable(sb *strings.Builder, t *Table) {
    sb.WriteString(t.name)
    if t.alias != "" {
        sb.WriteString(" AS ")
        sb.WriteString(t.alias)
    }
}

// buildJoin 构建 JOIN 子句（支持嵌套）
func (s *Selector[T]) buildJoin(sb *strings.Builder, j *Join) error {
    // 1. 先构建左操作数（可能是 Table 或 Join）
    switch left := j.left.(type) {
    case *Table:
        s.buildTable(sb, left)
    case *Join:
        // 递归构建嵌套 JOIN
        if err := s.buildJoin(sb, left); err != nil {
            return err
        }
    }

    // 2. 构建 JOIN 类型和右表
    switch j.typ {
    case "INNER":
        sb.WriteString(" JOIN ")
    case "LEFT":
        sb.WriteString(" LEFT JOIN ")
    case "RIGHT":
        sb.WriteString(" RIGHT JOIN ")
    }

    // 3. 构建右表
    switch right := j.table.(type) {
    case *Table:
        s.buildTable(sb, right)
    case *Join:
        // 子 JOIN 需要括号包裹
        sb.WriteString("(")
        if err := s.buildJoin(sb, right); err != nil {
            return err
        }
        sb.WriteString(")")
    }

    // 4. 构建条件（ON 或 USING，互斥）
    if len(j.using) > 0 {
        sb.WriteString(" USING(")
        for i, col := range j.using {
            if i > 0 {
                sb.WriteString(", ")
            }
            sb.WriteString(col)
        }
        sb.WriteString(")")
    } else if j.cond != nil {
        sb.WriteString(" ON ")
        // 构建条件表达式
        if err := s.buildExpr(sb, j.cond); err != nil {
            return err
        }
    }

    return nil
}

// selector.go 文件（续）

// buildColumn 构建列引用，支持表前缀
func (s *Selector[T]) buildColumn(sb *strings.Builder, c Column, withAlias bool) error {
    // 1. 如果用户指定了表前缀（owner）
    //    例如 orm.C("u.Id") 中的 "u"
    if c.owner != "" {
        // 在 JOIN 场景下，需要验证 owner 是否是某个表的别名
        // 这里简化处理，直接输出
        sb.WriteString(c.owner)
        sb.WriteString(".")
    }

    // 2. 查找列名
    if fd, ok := s.model.FieldMapByGoName[c.name]; ok {
        // 找到了字段，输出列名
        sb.WriteString(fd.ColName)
    } else {
        // 没找到，可能是用户写的原始列名
        sb.WriteString(c.name)
    }

    // 3. 输出别名（如果有）
    if withAlias && c.alias != "" {
        sb.WriteString(" AS ")
        sb.WriteString(c.alias)
    }
    return nil
}

// Column 结构体增加 owner 字段
type Column struct {
    name  string  // 字段名
    alias string  // 别名
    owner string  // 表前缀（owner），如 "u.Id" 中的 "u"
}

// C 支持 owner 的列构造
// 用法：
//   orm.C("Id")         → 输出 id
//   orm.C("u", "Id")    → 输出 u.id
func C(owner string, name ...string) Column {
    if len(name) > 0 {
        return Column{owner: owner, name: name[0]}
    }
    return Column{name: owner}
}

// validateColumn 校验列是否有效
func (s *Selector[T]) validateColumn(c Column) error {
    if c.owner != "" {
        // 用户指定了表前缀
        // 需要检查该表是否有此列
        // 这里需要从 TableReference 中找到对应的表元数据
        // 简化处理：如果 JOIN 涉及多个表，需要查找所有表
        // 实际实现会更复杂
        return nil
    }
    // 没有指定表，走老逻辑
    _, ok := s.model.FieldMapByGoName[c.name]
    if !ok {
        return errs.NewErrUnknownField(c.name)
    }
    return nil
}

// subquery.go 文件

// Subquery 代表一个子查询
type Subquery struct {
    // selector 子查询的 Selector
    selector *Selector[any]
    // alias 子查询的别名
    alias    string
}

// tableReference 实现 TableReference 接口
func (s *Subquery) tableReference() {}

// SubqueryOf 创建一个子查询
// 用法：orm.SubqueryOf(selector, "sub")
func SubqueryOf(selector *Selector[any], alias string) *Subquery {
    return &Subquery{
        selector: selector,
        alias:    alias,
    }
}

// As 设置子查询别名
func (s *Subquery) As(alias string) *Subquery {
    return &Subquery{
        selector: s.selector,
        alias:    alias,
    }
}

// 使用示例：子查询作为 FROM

// SELECT * FROM (
//     SELECT id, name FROM user WHERE age > 18
// ) AS sub WHERE sub.id > 100

subQuery := orm.NewSelector[User](db).
    Select(orm.C("Id"), orm.C("Name")).
    From(orm.TableOf("user")).
    Where(orm.C("Age").GT(18))

result, err := orm.NewSelector[User](db).
    From(orm.SubqueryOf(subQuery, "sub")).
    Where(orm.C("sub.Id").GT(100)).
    GetMulti(ctx)

// 普通结构体：可以用 Tag 指定列名
type User struct {
    Name string `orm:"column=user_name"`
}

// user.proto
message User {
    string name = 1;  // Protobuf 生成代码时不会加 orm tag
}

// protoc 自动生成的代码（无法修改）
type User struct {
    // 只有 protobuf 的 tag，没有 orm 的 tag
    Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}

// 原本生成的代码
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`

// 修改插件后生成的代码
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty" orm:"column=user_name"`

// 以下是 protobuf Go 插件源码中修改的核心逻辑（简化版）

// 原始代码（google/protobuf-go 内部）
func (g *generator) generateField(field *descriptor.FieldDescriptorProto) {
    // ... 原始逻辑 ...
    // 生成 json tag
    tag := fmt.Sprintf(`protobuf:"%s" json:"%s,omitempty"`,
        protobufTag, jsonName)
    g.P(field.GoName, " ", field.GoType, " `", tag, "`")
}

// 修改后的代码
func (g *generator) generateField(field *descriptor.FieldDescriptorProto) {
    // ... 原始逻辑 ...

    // 生成 json tag
    tag := fmt.Sprintf(`protobuf:"%s" json:"%s,omitempty"`,
        protobufTag, jsonName)

    // ===== 新增：添加 orm tag =====
    // 将字段名转为下划线命名作为列名
    ormColName := underscoreName(field.GoName)
    tag = tag + fmt.Sprintf(` orm:"column=%s"`, ormColName)
    // ==============================

    g.P(field.GoName, " ", field.GoType, " `", tag, "`")
}

// 自定义 field option
import "orm/options.proto";

message User {
    // 希望通过 option 指定列名
    string name = 1 [(orm.column) = "user_name"];
}

// 当前的写法：用户需要手写字段名字符串
// 容易写错，没有编译期检查
users, err := orm.NewSelector[User](db).
    Where(orm.C("FirstName").EQ("大明")).  // "FirstName" 是字符串，写错了编译器不会报错
    Get(ctx)

// 期望的写法：通过代码生成，提供类型安全的常量和方法
users, err := orm.NewSelector[User](db).
    Where(UserColumns.FirstName.EQ("大明")).  // 编译器能检查 FirstName 是否存在
    Get(ctx)

// ================================
// 原始模型文件：model/user.go
// ================================
package model

type User struct {
    Id        int64
    FirstName string
    LastName  string
    Age       int
}

// ================================
// 代码生成的文件：model/user_gen.go
// ================================
// 注意：这个文件是自动生成的，不要手动修改

package model

import "orm"

// UserColumns 包含 User 的所有字段常量
// 使用常量避免手写字符串，提供编译期检查
var UserColumns = struct {
    Id        orm.Column
    FirstName orm.Column
    LastName  orm.Column
    Age       orm.Column
}{
    Id:        orm.Column{name: "Id"},
    FirstName: orm.Column{name: "FirstName"},
    LastName:  orm.Column{name: "LastName"},
    Age:       orm.Column{name: "Age"},
}

// UserPredicates 提供 User 的 Predicate 快捷构造方法
var UserPredicates = struct {
    Id        func(val any) orm.Predicate
    FirstName func(val any) orm.Predicate
    LastName  func(val any) orm.Predicate
    Age       func(val any) orm.Predicate
}{
    Id:        func(val any) orm.Predicate { return orm.C("Id").EQ(val) },
    FirstName: func(val any) orm.Predicate { return orm.C("FirstName").EQ(val) },
    LastName:  func(val any) orm.Predicate { return orm.C("LastName").EQ(val) },
    Age:       func(val any) orm.Predicate { return orm.C("Age").EQ(val) },
}

// 使用生成的辅助方法
// 比手写字符串更安全、更方便

// 使用列常量
users, err := orm.NewSelector[User](db).
    Where(UserColumns.FirstName.EQ("大明")).
    Get(ctx)

// 使用 Predicate 辅助方法
users, err = orm.NewSelector[User](db).
    Where(UserPredicates.Age(28)).
    Get(ctx)

// 组合使用
users, err = orm.NewSelector[User](db).
    Where(UserPredicates.FirstName("大明").
        And(UserPredicates.Age(28))).
    Get(ctx)

// ast_gen.go 文件

package main

import (
    "fmt"
    "go/ast"
    "go/parser"
    "go/token"
)

func main() {
    // ========== 步骤 1：创建 FileSet ==========
    // FileSet 用于记录源代码的位置信息
    // 每个 AST 节点都关联一个位置，FileSet 管理这些位置
    fset := token.NewFileSet()

    // ========== 步骤 2：解析源文件 ==========
    // parser.ParseFile 将 Go 源文件解析为 AST
    // 参数：
    //   fset: 位置信息管理器
    //   filename: 文件路径（可以为空）
    //   src: 源代码内容
    //   mode: 解析模式（控制解析的详细程度）
    f, err := parser.ParseFile(fset, "user.go", nil, parser.ParseComments)
    if err != nil {
        panic(err)
    }

    // ========== 步骤 3：实现 ast.Visitor 接口 ==========
    // Visitor 用于遍历 AST 树
    visitor := &structVisitor{}

    // ========== 步骤 4：遍历 AST ==========
    // ast.Walk 从根节点开始遍历整棵 AST 树
    ast.Walk(visitor, f)
}

// structVisitor 实现了 ast.Visitor 接口
// 用于遍历 AST 并查找结构体定义
type structVisitor struct {
    // 记录找到的结构体信息
    structs []structInfo
}

// structInfo 存储解析到的结构体信息
type structInfo struct {
    Name   string       // 结构体名
    Fields []fieldInfo  // 字段列表
}

// fieldInfo 存储字段信息
type fieldInfo struct {
    Name string  // 字段名
    Type string  // 字段类型
}

// Visit 实现 ast.Visitor 接口
// 每遍历到一个 AST 节点都会调用此方法
// 返回值：如果返回非 nil，则继续遍历子节点；返回 nil 则跳过子节点
func (v *structVisitor) Visit(node ast.Node) ast.Visitor {
    // node 可能为 nil（遍历结束时）
    if node == nil {
        return nil
    }

    // 使用类型断言判断节点类型
    switch n := node.(type) {
    case *ast.TypeSpec:
        // TypeSpec 代表类型声明（type xxx ...）
        // 检查是否是结构体
        if structType, ok := n.Type.(*ast.StructType); ok {
            info := structInfo{
                Name: n.Name.Name,  // 结构体名
            }
            // 遍历结构体的字段
            for _, field := range structType.Fields.List {
                // 一个 field 可能对应多个名字（如 Name, Email string）
                for _, name := range field.Names {
                    info.Fields = append(info.Fields, fieldInfo{
                        Name: name.Name,
                        // 获取类型名（简化处理）
                        Type: fmt.Sprintf("%v", field.Type),
                    })
                }
            }
            v.structs = append(v.structs, info)
        }
    }

    // 返回自身，继续遍历子节点
    return v
}

// ast.Visitor 接口定义
type Visitor interface {
    // Visit 方法接收一个 Node
    // 返回值也是一个 Visitor——用于进一步遍历子节点
    // 如果返回 nil，则不再遍历子节点
    Visit(node Node) (w Visitor)
}

// ast.Walk 的简化实现
func Walk(v Visitor, node Node) {
    if node == nil {
        return
    }

    // 调用 Visitor 的 Visit 方法
    // 如果返回的 Visitor 不为 nil，则继续遍历子节点
    if v = v.Visit(node); v == nil {
        return  // 返回 nil，停止遍历子节点
    }

    // 根据节点类型，遍历所有子节点
    switch n := node.(type) {
    case *ast.File:
        // 遍历文件中的所有声明
        for _, decl := range n.Decls {
            Walk(v, decl)
        }
    case *ast.GenDecl:
        // 遍历通用声明（type、var、const、import）
        for _, spec := range n.Specs {
            Walk(v, spec)
        }
    case *ast.TypeSpec:
        // 遍历类型声明的类型部分
        Walk(v, n.Type)
    case *ast.StructType:
        // 遍历结构体的字段
        for _, field := range n.Fields.List {
            Walk(v, field)
        }
    // ... 还有几十种节点类型
    }

    // 遍历完毕，调用 Visit(nil) 通知 Visitor
    v.Visit(nil)
}

// GenDecl 代表通用声明
// 通过 Tok 字段判断具体是什么声明：
//   token.TYPE    → 类型声明 (type)
//   token.VAR     → 变量声明 (var)
//   token.CONST   → 常量声明 (const)
//   token.IMPORT  → 导入声明 (import)

type GenDecl struct {
    Doc  *ast.CommentGroup  // 文档注释
    TokPos token.Pos         // 关键字位置
    Tok   token.Token        // 关键字：type、var、const、import
    Lparen token.Pos         // 左括号位置（如果有的话）
    Specs []ast.Spec         // 具体声明内容
    Rparen token.Pos         // 右括号位置
}

// FuncDecl 代表方法/函数声明
type FuncDecl struct {
    Doc  *ast.CommentGroup   // 文档注释
    Recv *ast.FieldList      // 接收器（只有方法有，普通函数为 nil）
    Name *ast.Ident          // 方法名
    Type *ast.FuncType       // 方法签名（包含泛型参数、参数、返回值）
    Body *ast.BlockStmt      // 方法体
}

// StructType 代表一个结构体声明
type StructType struct {
    Struct token.Pos    // struct 关键字位置
    Fields *ast.FieldList  // 字段列表
    // 注意：Fields 里面找不到定义在该结构体上的方法
    // 方法声明在 ast.File 的 Decls 里（作为 FuncDecl）
}

// ast.FieldList 是字段列表
type FieldList struct {
    Opening token.Pos  // 左括号位置
    List    []*Field   // 字段列表
    Closing token.Pos  // 右括号位置
}

// ast.Field 代表一个字段
type Field struct {
    Doc     *ast.CommentGroup  // 文档注释
    Names   []*Ident           // 字段名（可能多个，如 Name, Email string）
    Type    Expr               // 字段类型
    Tag     *BasicLit          // Tag（标签）
    Comment *ast.CommentGroup  // 行注释
}

// gen/main.go 文件

package main

import (
    "bytes"
    "fmt"
    "go/ast"
    "go/parser"
    "go/token"
    "os"
    "strings"
    "text/template"
)

// ========== 数据结构 ==========

// StructInfo 存储解析到的结构体信息
type StructInfo struct {
    Package string      // 包名
    Name    string      // 结构体名
    Fields  []FieldInfo // 字段列表
}

// FieldInfo 存储字段信息
type FieldInfo struct {
    Name string  // 字段名（Go 字段名）
    Type string  // 字段类型
}

// ========== AST 解析器 ==========

// Parser 解析 Go 源文件，提取结构体信息
type Parser struct {
    structs []StructInfo
    pkgName string
}

// ParseFile 解析指定的 Go 源文件
func (p *Parser) ParseFile(filename string) error {
    // 1. 创建 FileSet
    fset := token.NewFileSet()

    // 2. 解析源文件
    f, err := parser.ParseFile(fset, filename, nil, parser.ParseComments)
    if err != nil {
        return err
    }

    // 3. 记录包名
    p.pkgName = f.Name.Name

    // 4. 遍历 AST
    ast.Inspect(f, func(node ast.Node) bool {
        // ast.Inspect 是 ast.Walk 的简化版
        // 返回 true 继续遍历子节点，返回 false 跳过

        // 查找类型声明
        typeSpec, ok := node.(*ast.TypeSpec)
        if !ok {
            return true
        }

        // 检查是否是结构体
        structType, ok := typeSpec.Type.(*ast.StructType)
        if !ok {
            return true
        }

        // 提取结构体信息
        info := StructInfo{
            Package: p.pkgName,
            Name:    typeSpec.Name.Name,
        }

        // 遍历字段
        for _, field := range structType.Fields.List {
            // 跳过非导出字段
            for _, name := range field.Names {
                if !name.IsExported() {
                    continue
                }
                info.Fields = append(info.Fields, FieldInfo{
                    Name: name.Name,
                    Type: exprToString(field.Type),
                })
            }
        }

        p.structs = append(p.structs, info)
        return true
    })

    return nil
}

// exprToString 将 AST 表达式转为类型字符串
// 例如：*ast.Ident → "string"，*ast.SelectorExpr → "time.Time"
func exprToString(expr ast.Expr) string {
    switch t := expr.(type) {
    case *ast.Ident:
        // 简单类型，如 string、int
        return t.Name
    case *ast.SelectorExpr:
        // 包名.类型，如 time.Time
        return exprToString(t.X) + "." + t.Sel.Name
    case *ast.StarExpr:
        // 指针类型，如 *string
        return "*" + exprToString(t.X)
    default:
        return fmt.Sprintf("%v", expr)
    }
}

// ========== 代码生成 ==========

// 生成模板
const genTemplate = `// Code generated by ORM gen. DO NOT EDIT.

package {{.Package}}

import "orm"

{{range .Structs}}
// {{.Name}}Columns 包含 {{.Name}} 的所有字段常量
var {{.Name}}Columns = struct {
{{range .Fields}}    {{.Name}} orm.Column
{{end}}}{
{{range .Fields}}    {{.Name}}: orm.Column{name: "{{.Name}}"},
{{end}}}

// {{.Name}}Predicates 提供 {{.Name}} 的 Predicate 快捷构造方法
var {{.Name}}Predicates = struct {
{{range .Fields}}    {{.Name}} func(val any) orm.Predicate
{{end}}}{
{{range .Fields}}    {{.Name}}: func(val any) orm.Predicate { return orm.C("{{.Name}}").EQ(val) },
{{end}}}
{{end}}
`

// GenConfig 代码生成配置
type GenConfig struct {
    InputFile  string  // 输入文件路径（模型文件）
    OutputFile string  // 输出文件路径（生成文件）
}

// Generate 执行代码生成
func Generate(config GenConfig) error {
    // 1. 解析源文件
    p := &Parser{}
    if err := p.ParseFile(config.InputFile); err != nil {
        return err
    }

    // 2. 准备模板数据
    data := struct {
        Package string
        Structs []StructInfo
    }{
        Package: p.pkgName,
        Structs: p.structs,
    }

    // 3. 解析模板
    tmpl, err := template.New("gen").Parse(genTemplate)
    if err != nil {
        return err
    }

    // 4. 执行模板渲染
    var buf bytes.Buffer
    if err := tmpl.Execute(&buf, data); err != nil {
        return err
    }

    // 5. 写入输出文件
    return os.WriteFile(config.OutputFile, buf.Bytes(), 0644)
}

func main() {
    // 执行代码生成
    err := Generate(GenConfig{
        InputFile:  "model/user.go",
        OutputFile: "model/user_gen.go",
    })
    if err != nil {
        fmt.Printf("代码生成失败: %v\n", err)
        os.Exit(1)
    }
    fmt.Println("代码生成成功！")
}