package codegen

import (
	"bytes"
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"text/template"

	codegenModel "sundynix-go/model/codegen"

	"github.com/glebarez/sqlite"
	"gorm.io/driver/mysql"
	"gorm.io/driver/postgres"
	"gorm.io/gorm"
)

type CodegenService struct{}

var CodegenServiceApp = new(CodegenService)

// ----------------------------------------
// 模板：model 实体（继承 global.BaseModel）
// ----------------------------------------

const modelTmpl = `package {{.PackageName}}

import "sundynix-go/global"
{{if .HasTimeField}}import "time"
{{end}}
// {{.Feature.Name}} {{.Feature.Comment}}
type {{.Feature.Name}} struct {
	global.BaseModel
{{- range .Feature.Fields}}
	{{.Name}} {{.Type}} ` + "`" + `gorm:"column:{{.ColumnName}}{{if .GormTag}};{{.GormTag}}{{end}}" json:"{{.JsonTag}}"` + "`" + ` // {{.Comment}}
{{- end}}
{{- range .Feature.Relations}}
{{- if eq .Type "OneToOne"}}
	{{.FieldName}} *{{.TargetFeature}} ` + "`" + `gorm:"foreignKey:{{.ForeignKey}}" json:"{{lowerFirst .FieldName}}"` + "`" + `
{{- else if eq .Type "OneToMany"}}
	{{.FieldName}} []{{.TargetFeature}} ` + "`" + `gorm:"foreignKey:{{.ForeignKey}}" json:"{{lowerFirst .FieldName}}"` + "`" + `
{{- else if eq .Type "ManyToMany"}}
	{{.FieldName}} []{{.TargetFeature}} ` + "`" + `gorm:"many2many:{{.JoinTable}};" json:"{{lowerFirst .FieldName}}"` + "`" + `
{{- end}}
{{- end}}
}

func ({{.Feature.Name}}) TableName() string {
	return "{{.Feature.TableName}}"
}
`

// ----------------------------------------
// 模板：request 结构体（每个模块一个文件，包含所有实体的请求结构体）
// ----------------------------------------

const requestTmpl = `package request
{{range .Features}}
// ---- {{.Comment}} ----

// Save{{.Name}}Req 新增{{.Comment}}请求
type Save{{.Name}}Req struct {
{{- range .Fields}}
	{{.Name}} {{.Type}} ` + "`" + `json:"{{.JsonTag}}" form:"{{.JsonTag}}"{{if .Required}} binding:"required"{{end}}` + "`" + ` // {{.Comment}}
{{- end}}
}

// Update{{.Name}}Req 更新{{.Comment}}请求
type Update{{.Name}}Req struct {
	Id   string ` + "`" + `json:"id" binding:"required"` + "`" + ` // ID
{{- range .Fields}}
	{{.Name}} {{.Type}} ` + "`" + `json:"{{.JsonTag}}" form:"{{.JsonTag}}"` + "`" + ` // {{.Comment}}
{{- end}}
}

// List{{.Name}}Req 分页查询{{.Comment}}请求
type List{{.Name}}Req struct {
	Current  int    ` + "`" + `json:"current" form:"current"` + "`" + `   // 页码
	PageSize int    ` + "`" + `json:"pageSize" form:"pageSize"` + "`" + ` // 每页大小
	Keyword  string ` + "`" + `json:"keyword" form:"keyword"` + "`" + `   // 关键字搜索
}
{{end}}`

// ----------------------------------------
// 模板：service 层（使用 request 包的结构体）
// ----------------------------------------

const serviceTmpl = `package {{.PackageName}}

import (
	"sundynix-go/global"
	model "sundynix-go/model/{{.PackageName}}"
	req "sundynix-go/model/{{.PackageName}}/request"
)

type {{.Feature.Name}}Service struct{}

var {{.Feature.Name}}ServiceApp = new({{.Feature.Name}}Service)

func (s *{{.Feature.Name}}Service) Save(r req.Save{{.Feature.Name}}Req) error {
	data := model.{{.Feature.Name}}{
{{- range .Feature.Fields}}
		{{.Name}}: r.{{.Name}},
{{- end}}
	}
	return global.DB.Create(&data).Error
}

func (s *{{.Feature.Name}}Service) Update(r req.Update{{.Feature.Name}}Req) error {
	updates := map[string]any{
{{- range .Feature.Fields}}
		"{{.ColumnName}}": r.{{.Name}},
{{- end}}
	}
	return global.DB.Model(&model.{{.Feature.Name}}{}).Where("id = ?", r.Id).Updates(updates).Error
}

func (s *{{.Feature.Name}}Service) Delete(ids []string) error {
	return global.DB.Where("id IN ?", ids).Delete(&model.{{.Feature.Name}}{}).Error
}

func (s *{{.Feature.Name}}Service) Detail(id string) (data *model.{{.Feature.Name}}, err error) {
	var record model.{{.Feature.Name}}
	err = global.DB.Where("id = ?", id).First(&record).Error
	return &record, err
}

func (s *{{.Feature.Name}}Service) List(r req.List{{.Feature.Name}}Req) (list []model.{{.Feature.Name}}, total int64, err error) {
	if r.PageSize <= 0 {
		r.PageSize = 10
	}
	if r.Current <= 0 {
		r.Current = 1
	}
	db := global.DB.Model(&model.{{.Feature.Name}}{})
	if r.Keyword != "" {
		db = db.Where("id LIKE ?", "%"+r.Keyword+"%")
	}
	if err = db.Count(&total).Error; err != nil {
		return
	}
	err = db.Limit(r.PageSize).Offset(r.PageSize * (r.Current - 1)).Find(&list).Error
	return
}
`

// ----------------------------------------
// 模板：service enter.go
// ----------------------------------------

const serviceEnterTmpl = `package {{.PackageName}}

type ServiceGroup struct {
{{- range .Features}}
	{{.Name}}Service
{{- end}}
}
`

// ----------------------------------------
// 模板：api handler 层（使用 request 包的结构体）
// ----------------------------------------

const apiTmpl = `package {{.PackageName}}

import (
	"sundynix-go/global"
	"sundynix-go/model/commom/response"
	req "sundynix-go/model/{{.PackageName}}/request"
	"sundynix-go/service"

	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
)

type {{.Feature.Name}}Api struct{}

var {{.LowerName}}Service = service.ServiceGroupApp.{{.PascalModuleName}}ServiceGroup.{{.Feature.Name}}Service

// Save
// @Tags {{.Feature.Comment}}管理
// @Summary 新增{{.Feature.Comment}}
// @Security BasicAuth
// @accept json
// @Produce json
// @Param data body req.Save{{.Feature.Name}}Req true "新增{{.Feature.Comment}}参数"
// @Success 200 {object} response.Response "新增成功"
// @Router /{{.RouterPrefix}}/save [post]
func (a *{{.Feature.Name}}Api) Save(c *gin.Context) {
	var r req.Save{{.Feature.Name}}Req
	if err := c.ShouldBindJSON(&r); err != nil {
		response.FailWithMsg("参数错误:"+err.Error(), c)
		return
	}
	if err := {{.LowerName}}Service.Save(r); err != nil {
		global.Logger.Error("新增{{.Feature.Comment}}失败!", zap.Error(err))
		response.FailWithMsg(err.Error(), c)
		return
	}
	response.OkWithMsg("新增成功", c)
}

// Update
// @Tags {{.Feature.Comment}}管理
// @Summary 更新{{.Feature.Comment}}
// @Security BasicAuth
// @accept json
// @Produce json
// @Param data body req.Update{{.Feature.Name}}Req true "更新{{.Feature.Comment}}参数"
// @Success 200 {object} response.Response "更新成功"
// @Router /{{.RouterPrefix}}/update [post]
func (a *{{.Feature.Name}}Api) Update(c *gin.Context) {
	var r req.Update{{.Feature.Name}}Req
	if err := c.ShouldBindJSON(&r); err != nil {
		response.FailWithMsg("参数错误:"+err.Error(), c)
		return
	}
	if err := {{.LowerName}}Service.Update(r); err != nil {
		global.Logger.Error("更新{{.Feature.Comment}}失败!", zap.Error(err))
		response.FailWithMsg(err.Error(), c)
		return
	}
	response.OkWithMsg("更新成功", c)
}

// Delete
// @Tags {{.Feature.Comment}}管理
// @Summary 删除{{.Feature.Comment}}（支持批量）
// @Security BasicAuth
// @accept json
// @Produce json
// @Param data body object{ids=[]string} true "id列表"
// @Success 200 {object} response.Response "删除成功"
// @Router /{{.RouterPrefix}}/delete [post]
func (a *{{.Feature.Name}}Api) Delete(c *gin.Context) {
	var req struct {
		Ids []string ` + "`" + `json:"ids" binding:"required,min=1"` + "`" + `
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		response.FailWithMsg("参数错误:"+err.Error(), c)
		return
	}
	if err := {{.LowerName}}Service.Delete(req.Ids); err != nil {
		global.Logger.Error("删除{{.Feature.Comment}}失败!", zap.Error(err))
		response.FailWithMsg(err.Error(), c)
		return
	}
	response.OkWithMsg("删除成功", c)
}

// Detail
// @Tags {{.Feature.Comment}}管理
// @Summary 获取{{.Feature.Comment}}详情
// @Security BasicAuth
// @Produce json
// @Param id query string true "ID"
// @Success 200 {object} response.Response "获取详情成功"
// @Router /{{.RouterPrefix}}/detail [get]
func (a *{{.Feature.Name}}Api) Detail(c *gin.Context) {
	id := c.Query("id")
	data, err := {{.LowerName}}Service.Detail(id)
	if err != nil {
		global.Logger.Error("获取{{.Feature.Comment}}详情失败!", zap.Error(err))
		response.FailWithMsg(err.Error(), c)
		return
	}
	response.OkWithData(data, c)
}

// List
// @Tags {{.Feature.Comment}}管理
// @Summary 分页获取{{.Feature.Comment}}列表
// @Security BasicAuth
// @accept json
// @Produce json
// @Param data body req.List{{.Feature.Name}}Req true "分页参数"
// @Success 200 {object} response.Response{data=response.PageResult} "获取列表成功"
// @Router /{{.RouterPrefix}}/list [post]
func (a *{{.Feature.Name}}Api) List(c *gin.Context) {
	var r req.List{{.Feature.Name}}Req
	if err := c.ShouldBindJSON(&r); err != nil {
		response.FailWithMsg("参数错误:"+err.Error(), c)
		return
	}
	list, total, err := {{.LowerName}}Service.List(r)
	if err != nil {
		global.Logger.Error("获取{{.Feature.Comment}}列表失败!", zap.Error(err))
		response.FailWithMsg(err.Error(), c)
		return
	}
	response.OkWithData(response.PageResult{
		List:     list,
		Total:    total,
		Page:     r.Current,
		PageSize: r.PageSize,
	}, c)
}
`

// ----------------------------------------
// 模板：api enter.go
// ----------------------------------------

const apiEnterTmpl = `package {{.PackageName}}

type ApiGroup struct {
{{- range .Features}}
	{{.Name}}Api
{{- end}}
}
`

// ----------------------------------------
// 模板：router
// ----------------------------------------

const routerTmpl = `package {{.PackageName}}

import "github.com/gin-gonic/gin"

type {{.Feature.Name}}Router struct{}

func (r *{{.Feature.Name}}Router) Init{{.Feature.Name}}Router(Router *gin.RouterGroup) {
	{{.LowerName}}Router := Router.Group("{{.RouterGroup}}")
	{
		{{.LowerName}}Router.POST("save", {{.LowerName}}Api.Save)
		{{.LowerName}}Router.POST("update", {{.LowerName}}Api.Update)
		{{.LowerName}}Router.POST("delete", {{.LowerName}}Api.Delete)
		{{.LowerName}}Router.GET("detail", {{.LowerName}}Api.Detail)
		{{.LowerName}}Router.POST("list", {{.LowerName}}Api.List)
	}
}
`

// ----------------------------------------
// 模板：router enter.go
// ----------------------------------------

const routerEnterTmpl = `package {{.PackageName}}

import v1 "sundynix-go/api/v1"

type RouterGroup struct {
{{- range .Features}}
	{{.Name}}Router
{{- end}}
}

var (
{{- range .Features}}
	{{lowerFirst .Name}}Api = v1.ApiGroupApp.{{.PascalModuleName}}ApiGroup.{{.Name}}Api
{{- end}}
)
`

// ----------------------------------------
// 前端模板：TypeScript 类型定义
// ----------------------------------------

const feTsTypeTmpl = `// {{.Module.Name}} 模块类型定义（自动生成，请勿手动修改）
import type { BaseModel } from '@/types'
{{range .Features}}
// ---- {{.Comment}} ----

/** {{.Comment}}实体 */
export interface {{.Name}} extends BaseModel {
{{- range .Fields}}
  {{.JsonTag}}: {{goTypeToTs .Type}} // {{.Comment}}
{{- end}}
}

/** 新增{{.Comment}}请求 */
export interface Save{{.Name}}Req {
{{- range .Fields}}
  {{.JsonTag}}{{if not .Required}}?{{end}}: {{goTypeToTs .Type}} // {{.Comment}}
{{- end}}
}

/** 更新{{.Comment}}请求 */
export interface Update{{.Name}}Req {
  id: string
{{- range .Fields}}
  {{.JsonTag}}?: {{goTypeToTs .Type}} // {{.Comment}}
{{- end}}
}

/** 分页查询{{.Comment}}请求 */
export interface List{{.Name}}Req {
  current?: number
  pageSize?: number
  keyword?: string
}
{{end}}`

// ----------------------------------------
// 前端模板：API service (Axios)
// ----------------------------------------

const feApiTmpl = `import { get, post } from '@/lib/request'
import type {
  {{.Feature.Name}},
  Save{{.Feature.Name}}Req,
  Update{{.Feature.Name}}Req,
  List{{.Feature.Name}}Req,
} from '@/types/{{.Module.PackageName}}'
import type { PageResult } from '@/types'

const BASE = '/{{.Module.PackageName}}/{{.SnakeName}}'

export const {{lowerFirst .Feature.Name}}Api = {
  save: (data: Save{{.Feature.Name}}Req) =>
    post<void>(` + "`" + `${BASE}/save` + "`" + `, data),

  update: (data: Update{{.Feature.Name}}Req) =>
    post<void>(` + "`" + `${BASE}/update` + "`" + `, data),

  delete: (ids: string[]) =>
    post<void>(` + "`" + `${BASE}/delete` + "`" + `, { ids }),

  detail: (id: string) =>
    get<{{.Feature.Name}}>(` + "`" + `${BASE}/detail` + "`" + `, { id }),

  list: (params: List{{.Feature.Name}}Req) =>
    post<PageResult<{{.Feature.Name}}>>(` + "`" + `${BASE}/list` + "`" + `, params),
}
`

// ----------------------------------------
// 前端模板：React 管理页面
// ----------------------------------------

const fePageTmpl = `import { useState, useEffect } from 'react'
import { {{lowerFirst .Feature.Name}}Api } from '@/api/{{.Module.PackageName}}/{{.SnakeName}}'
import type { {{.Feature.Name}}, List{{.Feature.Name}}Req } from '@/types/{{.Module.PackageName}}'
import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'
import { Card, CardContent } from '@/components/ui/card'
import { toast } from 'sonner'
import { Plus, Pencil, Trash2, Search, RefreshCw } from 'lucide-react'

export default function {{.Feature.Name}}Page() {
  const [list, setList] = useState<{{.Feature.Name}}[]>([])
  const [total, setTotal] = useState(0)
  const [loading, setLoading] = useState(false)
  const [params, setParams] = useState<List{{.Feature.Name}}Req>({ current: 1, pageSize: 10, keyword: '' })

  const load = async () => {
    setLoading(true)
    try {
      const res = await {{lowerFirst .Feature.Name}}Api.list(params)
      setList(res.list)
      setTotal(res.total)
    } catch {}
    finally { setLoading(false) }
  }

  useEffect(() => { load() }, [params.current])

  const handleDelete = async (id: string) => {
    if (!confirm('确认删除？')) return
    try {
      await {{lowerFirst .Feature.Name}}Api.delete([id])
      toast.success('删除成功')
      load()
    } catch {}
  }

  const totalPages = Math.ceil(total / (params.pageSize ?? 10))

  return (
    <div className="space-y-4">
      <div className="flex items-center justify-between">
        <div>
          <h2 className="text-xl font-semibold">{{.Feature.Comment}}管理</h2>
          <p className="text-sm text-muted-foreground">共 {total} 条记录</p>
        </div>
        <Button size="sm" className="gap-1"><Plus className="h-4 w-4" /> 新增</Button>
      </div>

      <Card>
        <CardContent className="pt-4">
          <div className="flex gap-2">
            <Input
              placeholder="关键字搜索"
              value={params.keyword}
              onChange={e => setParams(p => ({ ...p, keyword: e.target.value, current: 1 }))}
              className="max-w-60"
            />
            <Button variant="outline" size="sm" onClick={load}><Search className="h-4 w-4 mr-1" />搜索</Button>
            <Button variant="ghost" size="sm" onClick={() => setParams(p => ({ ...p, keyword: '', current: 1 }))}>
              <RefreshCw className="h-4 w-4" />
            </Button>
          </div>
        </CardContent>
      </Card>

      <Card>
        <CardContent className="p-0">
          <table className="w-full text-sm">
            <thead className="border-b bg-muted/40">
              <tr>
                {{- range .Feature.Fields}}{{if .Comment}}
                <th className="px-4 py-3 text-left font-medium text-muted-foreground">{{.Comment}}</th>
                {{- end}}{{end}}
                <th className="px-4 py-3 text-left font-medium text-muted-foreground">创建时间</th>
                <th className="px-4 py-3 text-left font-medium text-muted-foreground">操作</th>
              </tr>
            </thead>
            <tbody>
              {loading ? (
                <tr><td colSpan={ {{- .ColCount -}} } className="py-12 text-center text-muted-foreground">加载中…</td></tr>
              ) : list.length === 0 ? (
                <tr><td colSpan={ {{- .ColCount -}} } className="py-12 text-center text-muted-foreground">暂无数据</td></tr>
              ) : list.map(item => (
                <tr key={item.id} className="border-b last:border-b-0 hover:bg-muted/30 transition-colors">
                  {{- range .Feature.Fields}}{{if .JsonTag}}<td className="px-4 py-3">{String(item.{{.JsonTag}} ?? '—')}</td>{{end}}{{end}}
                  <td className="px-4 py-3 text-xs text-muted-foreground">{new Date(item.createdAt).toLocaleString()}</td>
                  <td className="px-4 py-3">
                    <div className="flex items-center gap-1">
                      <Button variant="ghost" size="icon" className="h-7 w-7"><Pencil className="h-3.5 w-3.5" /></Button>
                      <Button variant="ghost" size="icon" className="h-7 w-7 text-destructive" onClick={() => handleDelete(item.id)}>
                        <Trash2 className="h-3.5 w-3.5" />
                      </Button>
                    </div>
                  </td>
                </tr>
              ))}
            </tbody>
          </table>

          {totalPages > 1 && (
            <div className="flex items-center justify-between border-t px-4 py-3">
              <span className="text-xs text-muted-foreground">第 {params.current} / {totalPages} 页</span>
              <div className="flex gap-1">
                <Button variant="outline" size="sm" disabled={(params.current ?? 1) <= 1}
                  onClick={() => setParams(p => ({ ...p, current: (p.current ?? 1) - 1 }))}>上一页</Button>
                <Button variant="outline" size="sm" disabled={(params.current ?? 1) >= totalPages}
                  onClick={() => setParams(p => ({ ...p, current: (p.current ?? 1) + 1 }))}>下一页</Button>
              </div>
            </div>
          )}
        </CardContent>
      </Card>
    </div>
  )
}
`

// ----------------------------------------
// 辅助函数
// ----------------------------------------

func lowerFirst(s string) string {
	if s == "" {
		return s
	}
	return strings.ToLower(s[:1]) + s[1:]
}

func hasTimeField(feature codegenModel.Feature) bool {
	for _, f := range feature.Fields {
		if f.Type == "time.Time" {
			return true
		}
	}
	return false
}

// goTypeToTs 将 Go 类型映射为 TypeScript 类型
func goTypeToTs(goType string) string {
	switch goType {
	case "int", "int8", "int16", "int32", "int64",
		"uint", "uint8", "uint16", "uint32", "uint64",
		"float32", "float64":
		return "number"
	case "bool":
		return "boolean"
	case "time.Time":
		return "string"
	default:
		return "string"
	}
}

// ----------------------------------------
// TestConnection 测试数据库连接
// ----------------------------------------

func (s *CodegenService) TestConnection(cfg codegenModel.DbConfig) error {
	_, err := openDB(cfg)
	return err
}

func openDB(cfg codegenModel.DbConfig) (*gorm.DB, error) {
	switch strings.ToLower(cfg.DbType) {
	case "mysql":
		dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
			cfg.User, cfg.Password, cfg.Host, cfg.Port, cfg.DbName)
		return gorm.Open(mysql.Open(dsn), &gorm.Config{})
	case "postgres", "postgresql":
		dsn := fmt.Sprintf("host=%s user=%s password=%s dbname=%s port=%s sslmode=disable",
			cfg.Host, cfg.User, cfg.Password, cfg.DbName, cfg.Port)
		return gorm.Open(postgres.Open(dsn), &gorm.Config{})
	case "sqlite":
		return gorm.Open(sqlite.Open(cfg.DbName), &gorm.Config{})
	default:
		return nil, fmt.Errorf("不支持的数据库类型: %s", cfg.DbType)
	}
}

// ----------------------------------------
// Preview 预览生成代码
// ----------------------------------------

func (s *CodegenService) Preview(config codegenModel.GenConfig) ([]codegenModel.PreviewFile, error) {
	backendFiles, err := s.renderAll(config, config.OutputDir)
	if err != nil {
		return nil, err
	}
	if config.FrontendOutputDir != "" {
		feFiles, err := s.renderFrontend(config)
		if err != nil {
			return nil, err
		}
		backendFiles = append(backendFiles, feFiles...)
	}
	return backendFiles, nil
}

// ----------------------------------------
// Generate 生成并写入文件
// ----------------------------------------

func (s *CodegenService) Generate(config codegenModel.GenConfig) (*codegenModel.GenResult, error) {
	outputDir := config.OutputDir
	if outputDir == "" {
		cwd, _ := os.Getwd()
		outputDir = cwd
	}

	// 1. 渲染后端文件
	backendFiles, err := s.renderAll(config, outputDir)
	if err != nil {
		return nil, err
	}

	// 2. 自动注册（必须在写入文件之前，否则 enter.go 已存在导致误判为已有模块）
	regMsg := ""
	if err := s.autoRegister(outputDir, config); err != nil {
		regMsg = fmt.Sprintf("⚠️ 自动注册失败: %s", err.Error())
	} else {
		regMsg = "✅ 自动注册成功（gorm/router/enter）"
	}

	// 3. 写入后端文件（增量模式下跳过已存在文件）
	written, skipped := writeFilesIncremental(outputDir, backendFiles, config.Overwrite)

	allFiles := backendFiles

	// 4. 生成前端文件（如果配置了前端输出目录）
	if config.FrontendOutputDir != "" {
		feFiles, err := s.renderFrontend(config)
		if err != nil {
			return nil, err
		}
		w, sk := writeFilesIncremental(config.FrontendOutputDir, feFiles, config.Overwrite)
		written += w
		skipped += sk
		allFiles = append(allFiles, feFiles...)
	}

	return &codegenModel.GenResult{
		OutputDir: outputDir,
		Files:     allFiles,
		Message:   fmt.Sprintf("写入 %d 个文件，跳过 %d 个已存在文件。%s", written, skipped, regMsg),
	}, nil
}

// writeFilesIncremental 写入文件，支持增量模式
// overwrite=false 时，已存在的文件会被跳过
// 返回 (写入数, 跳过数)
func writeFilesIncremental(baseDir string, files []codegenModel.PreviewFile, overwrite bool) (written int, skipped int) {
	for _, f := range files {
		fullPath := filepath.Join(baseDir, f.FilePath)
		// 增量模式下跳过已存在文件（但 AlwaysOverwrite 的聚合文件始终覆盖）
		if !overwrite && !f.AlwaysOverwrite {
			if _, err := os.Stat(fullPath); err == nil {
				skipped++
				continue
			}
		}
		if err := os.MkdirAll(filepath.Dir(fullPath), 0755); err != nil {
			continue
		}
		if err := os.WriteFile(fullPath, []byte(f.Content), 0644); err != nil {
			continue
		}
		written++
	}
	return
}

// renderFrontend 渲染前端 TypeScript / React 文件
func (s *CodegenService) renderFrontend(config codegenModel.GenConfig) ([]codegenModel.PreviewFile, error) {
	var result []codegenModel.PreviewFile

	funcMap := template.FuncMap{
		"lowerFirst": lowerFirst,
		"goTypeToTs": goTypeToTs,
		"not":        func(b bool) bool { return !b },
	}

	for _, module := range config.Modules {
		// 跳过未填写包名的模块
		if strings.TrimSpace(module.PackageName) == "" || strings.TrimSpace(module.Name) == "" {
			continue
		}
		// ---- TypeScript 类型（模块级，所有实体合并到 index.ts）----
		tsData := struct {
			Module   codegenModel.Module
			Features []codegenModel.Feature
		}{module, module.Features}
		tsContent, err := renderTmpl("fe_ts_type", feTsTypeTmpl, funcMap, tsData)
		if err != nil {
			return nil, err
		}
		result = append(result, codegenModel.PreviewFile{
			FilePath:        filepath.Join("src", "types", module.PackageName, "index.ts"),
			Content:         tsContent,
			AlwaysOverwrite: true,
		})

		for _, feature := range module.Features {
			// 跳过未命名的实体
			if strings.TrimSpace(feature.Name) == "" {
				continue
			}
			snakeName := toSnake(feature.Name)

			feData := struct {
				Module    codegenModel.Module
				Feature   codegenModel.Feature
				SnakeName string
				ColCount  int
			}{module, feature, snakeName, len(feature.Fields) + 2}

			// API service
			apiContent, err := renderTmpl("fe_api", feApiTmpl, funcMap, feData)
			if err != nil {
				return nil, err
			}
			result = append(result, codegenModel.PreviewFile{
				FilePath: filepath.Join("src", "api", module.PackageName, snakeName+".ts"),
				Content:  apiContent,
			})

			// React page
			pageContent, err := renderTmpl("fe_page", fePageTmpl, funcMap, feData)
			if err != nil {
				return nil, err
			}
			result = append(result, codegenModel.PreviewFile{
				FilePath: filepath.Join("src", "pages", module.PackageName, feature.Name+"Page.tsx"),
				Content:  pageContent,
			})
		}
	}
	return result, nil
}

// ----------------------------------------
// renderAll 渲染所有模块的所有文件
// ----------------------------------------

func (s *CodegenService) renderAll(config codegenModel.GenConfig, outputDir string) ([]codegenModel.PreviewFile, error) {
	var result []codegenModel.PreviewFile

	funcMap := template.FuncMap{
		"lowerFirst": lowerFirst,
	}

	for _, module := range config.Modules {
		// 跳过未填写包名的模块
		if strings.TrimSpace(module.PackageName) == "" || strings.TrimSpace(module.Name) == "" {
			continue
		}
		pkg := module.PackageName
		pascalModule := module.Name

		type featureEntry struct {
			Name             string
			PascalModuleName string
		}

		// 发现已存在的 feature（扫描 service/{pkg}/ 下的 *_service.go 文件）
		existingFeatures := discoverExistingFeatures(outputDir, pkg)

		// 合并：已有 feature + 当前配置中的 feature（去重）
		featureSet := make(map[string]bool)
		var allFeatureEntries []featureEntry
		for _, name := range existingFeatures {
			if !featureSet[name] {
				featureSet[name] = true
				allFeatureEntries = append(allFeatureEntries, featureEntry{name, pascalModule})
			}
		}
		for _, f := range module.Features {
			if strings.TrimSpace(f.Name) == "" {
				continue
			}
			if !featureSet[f.Name] {
				featureSet[f.Name] = true
				allFeatureEntries = append(allFeatureEntries, featureEntry{f.Name, pascalModule})
			}
		}

		enterData := struct {
			PackageName string
			Features    []featureEntry
		}{pkg, allFeatureEntries}

		// service/enter.go（始终覆盖，包含所有已有+新增 feature）
		svcEnter, err := renderTmpl("service_enter", serviceEnterTmpl, funcMap, enterData)
		if err != nil {
			return nil, err
		}
		result = append(result, codegenModel.PreviewFile{
			FilePath:        filepath.Join("service", pkg, "enter.go"),
			Content:         svcEnter,
			AlwaysOverwrite: true,
		})

		// api/v1/enter.go
		apiEnter, err := renderTmpl("api_enter", apiEnterTmpl, funcMap, enterData)
		if err != nil {
			return nil, err
		}
		result = append(result, codegenModel.PreviewFile{
			FilePath:        filepath.Join("api", "v1", pkg, "enter.go"),
			Content:         apiEnter,
			AlwaysOverwrite: true,
		})

		// router/enter.go
		routerEnter, err := renderTmpl("router_enter", routerEnterTmpl, funcMap, enterData)
		if err != nil {
			return nil, err
		}
		result = append(result, codegenModel.PreviewFile{
			FilePath:        filepath.Join("router", pkg, "enter.go"),
			Content:         routerEnter,
			AlwaysOverwrite: true,
		})

		// ---- request 结构体（按 feature 分文件，增量安全）----
		for _, feature := range module.Features {
			if strings.TrimSpace(feature.Name) == "" {
				continue
			}
			reqData := struct {
				PackageName string
				Features    []codegenModel.Feature
			}{pkg, []codegenModel.Feature{feature}}
			reqContent, err := renderTmpl("request", requestTmpl, funcMap, reqData)
			if err != nil {
				return nil, err
			}
			result = append(result, codegenModel.PreviewFile{
				FilePath: filepath.Join("model", pkg, "request", toSnake(feature.Name)+"_request.go"),
				Content:  reqContent,
			})
		}

		// 每个 Feature 生成：model / service / api / router
		for _, feature := range module.Features {
			// 跳过未命名的实体
			if strings.TrimSpace(feature.Name) == "" {
				continue
			}
			lower := lowerFirst(feature.Name)
			snakeName := toSnake(feature.Name)
			routerGroup := snakeName
			routerPrefix := pkg + "/" + snakeName

			// ---- model ----
			modelData := struct {
				PackageName  string
				Feature      codegenModel.Feature
				HasTimeField bool
			}{pkg, feature, hasTimeField(feature)}
			modelContent, err := renderTmpl("model", modelTmpl, funcMap, modelData)
			if err != nil {
				return nil, err
			}
			result = append(result, codegenModel.PreviewFile{
				FilePath: filepath.Join("model", pkg, snakeName+".go"),
				Content:  modelContent,
			})

			// ---- service ----
			svcData := struct {
				PackageName string
				Feature     codegenModel.Feature
			}{pkg, feature}
			svcContent, err := renderTmpl("service", serviceTmpl, funcMap, svcData)
			if err != nil {
				return nil, err
			}
			result = append(result, codegenModel.PreviewFile{
				FilePath: filepath.Join("service", pkg, snakeName+"_service.go"),
				Content:  svcContent,
			})

			// ---- api handler ----
			apiData := struct {
				PackageName      string
				Feature          codegenModel.Feature
				LowerName        string
				RouterPrefix     string
				PascalModuleName string
			}{pkg, feature, lower, routerPrefix, pascalModule}
			apiContent, err := renderTmpl("api", apiTmpl, funcMap, apiData)
			if err != nil {
				return nil, err
			}
			result = append(result, codegenModel.PreviewFile{
				FilePath: filepath.Join("api", "v1", pkg, snakeName+".go"),
				Content:  apiContent,
			})

			// ---- router ----
			routerData := struct {
				PackageName string
				Feature     codegenModel.Feature
				LowerName   string
				RouterGroup string
			}{pkg, feature, lower, routerGroup}
			routerContent, err := renderTmpl("router", routerTmpl, funcMap, routerData)
			if err != nil {
				return nil, err
			}
			result = append(result, codegenModel.PreviewFile{
				FilePath: filepath.Join("router", pkg, snakeName+"_router.go"),
				Content:  routerContent,
			})
		}
	}

	return result, nil
}

func renderTmpl(name, tmplStr string, funcMap template.FuncMap, data any) (string, error) {
	t, err := template.New(name).Funcs(funcMap).Parse(tmplStr)
	if err != nil {
		return "", fmt.Errorf("解析模板 [%s] 失败: %w", name, err)
	}
	var buf bytes.Buffer
	if err = t.Execute(&buf, data); err != nil {
		return "", fmt.Errorf("渲染模板 [%s] 失败: %w", name, err)
	}
	return buf.String(), nil
}

// toSnake 将 PascalCase 转为 snake_case
func toSnake(s string) string {
	var result []rune
	for i, r := range s {
		if r >= 'A' && r <= 'Z' {
			if i > 0 {
				result = append(result, '_')
			}
			result = append(result, r+32)
		} else {
			result = append(result, r)
		}
	}
	return string(result)
}