package entity

import (
	"time"

	"gorm.io/gorm"
)

// User 用户实体
//
// 存储通过 OIDC OAuth2 认证的用户信息。
// 包含来自 profile、email、phone scope 的数据以及游戏内密码。
type User struct {
	// ID 主键
	ID uint `gorm:"primaryKey;autoIncrement" json:"id"`
	// OIDCSubject OIDC Subject（用户唯一标识）
	// 来自 OAuth2 OIDC 认证的 sub 字段，全局唯一
	OIDCSubject string `gorm:"unique;not null;type:varchar(255)" json:"oidc_subject"`
	// Username 用户名/昵称
	// 来自 OIDC profile scope 的 preferred_username 或 name
	Username string `gorm:"not null;type:varchar(255)" json:"username"`
	// Email 邮箱
	// 来自 OIDC email scope，可选
	Email *string `gorm:"type:varchar(255)" json:"email"`
	// Phone 手机号
	// 来自 OIDC phone scope，可选
	Phone *string `gorm:"type:varchar(32)" json:"phone"`
	// GamePassword 游戏内密码
	// 用于 Yggdrasil 认证的游戏密码（加密存储，非站点密码）
	GamePassword string `gorm:"not null;type:varchar(255)" json:"-"`
	// CreatedAt 创建时间
	CreatedAt time.Time `json:"created_at"`
	// UpdatedAt 更新时间
	UpdatedAt time.Time `json:"updated_at"`
	// DeletedAt 软删除时间戳
	DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
	// GameProfiles 游戏档案关联
	// 一个用户可以拥有多个游戏档案
	GameProfiles []GameProfile `gorm:"foreignKey:UserID;constraint:OnDelete:CASCADE" json:"game_profiles,omitempty"`
}

// TableName 指定表名
func (User) TableName() string {
	return "user"
}

package entity

import (
	"time"

	"gorm.io/gorm"
)

// GameProfile 游戏档案实体
//
// 存储 Minecraft 游戏账号信息。
// 一个用户可以拥有多个游戏档案。
type GameProfile struct {
	// ID 主键
	ID uint `gorm:"primaryKey;autoIncrement" json:"id"`
	// UserID 关联用户 ID
	// 外键关联到 User 表
	UserID uint `gorm:"not null;index" json:"user_id"`
	// UUID Minecraft UUID
	// 带横线的标准格式（如：123e4567-e89b-12d3-a456-426614174000）
	UUID string `gorm:"unique;not null;type:varchar(36)" json:"uuid"`
	// Name 游戏内用户名
	// Minecraft 玩家显示名称
	Name string `gorm:"not null;type:varchar(32)" json:"name"`
	// SkinURL 皮肤 URL
	// 可选，Minecraft 皮肤资源地址
	SkinURL *string `gorm:"type:varchar(512)" json:"skin_url"`
	// CapeURL 披风 URL
	// 可选，Minecraft 披风资源地址
	CapeURL *string `gorm:"type:varchar(512)" json:"cape_url"`
	// CreatedAt 创建时间
	CreatedAt time.Time `json:"created_at"`
	// UpdatedAt 更新时间
	UpdatedAt time.Time `json:"updated_at"`
	// DeletedAt 软删除时间戳
	DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
	// User 关联用户
	// 多对一关系，属于一个用户
	User User `gorm:"constraint:OnDelete:CASCADE" json:"user,omitempty"`
}

// TableName 指定表名
func (GameProfile) TableName() string {
	return "game_profile"
}

package entity

import (
	"time"

	xModels "github.com/bamboo-services/bamboo-base-go/models"
	xSnowflake "github.com/bamboo-services/bamboo-base-go/snowflake"
)

// User 用户实体，包含账号验证、安全状态及关联游戏档案信息。
type User struct {
	xModels.BaseEntity            // 嵌入基础实体字段（不会携带 DeletedAt）
	Username           string     `gorm:"not null;type:varchar(255);comment:用户用户名" json:"username"`
	Email              *string    `gorm:"type:varchar(255);comment:用户邮箱;index:idx_email" json:"email"`
	Phone              *string    `gorm:"type:varchar(32);comment:用户手机号;index:idx_phone" json:"phone"`
	GamePassword       string     `gorm:"not null;type:varchar(255);comment:游戏账户密码" json:"-"`
	HasBan             bool       `gorm:"not null;type:boolean;default:false;comment:用户是否被封禁禁止登录" json:"has_ban"`
	JailedAt           *time.Time `gorm:"type:timestamptz;comment:用户被监禁的时间" json:"jailed_at,omitempty"`

	// ----------
	//  外键约束
	// ----------
	GameProfiles []GameProfile `gorm:"foreignKey:UserID;constraint:OnDelete:CASCADE;comment:游戏档案关联" json:"game_profiles,omitempty"`
}

// GetGene 返回 xSnowflake.GeneUser，用于标识该实体在 ID 生成时使用的基因类型。
func (_ *User) GetGene() xSnowflake.Gene {
	return xSnowflake.GeneUser
}

package entity

import (
	xModels "github.com/bamboo-services/bamboo-base-go/models"
	xSnowflake "github.com/bamboo-services/bamboo-base-go/snowflake"
	bConst "github.com/frontleaves-mc/frontleaves-yggleaf/internal/constant"
)

// GameProfile 游戏档案实体，存储 Minecraft 游戏账号信息，一个用户可以拥有多个游戏档案。
type GameProfile struct {
	xModels.BaseEntity                        // 嵌入基础实体字段
	UserID             xSnowflake.SnowflakeID `gorm:"not null;index:idx_user_id;comment:关联用户ID" json:"user_id"`
	UUID               string                 `gorm:"unique;not null;type:varchar(36);comment:Minecraft UUID" json:"uuid"`
	Name               string                 `gorm:"not null;type:varchar(32);comment:游戏内用户名" json:"name"`
	SkinURL            *string                `gorm:"type:varchar(512);comment:皮肤URL" json:"skin_url"`
	CapeURL            *string                `gorm:"type:varchar(512);comment:披风URL" json:"cape_url"`

	// ----------
	//  外键约束
	// ----------
	User User `gorm:"constraint:OnDelete:CASCADE;comment:关联用户" json:"user,omitempty"`
}

// GetGene 返回 xSnowflake.Gene，用于标识该实体在 ID 生成时使用的基因类型。
func (_ *GameProfile) GetGene() xSnowflake.Gene {
	return bConst.GeneForGameProfile
}

package entity

import (
	"regexp"
	"time"

	"gorm.io/gorm"
)

type RoleName string

const (
	RoleSuperAdmin RoleName = "SUPER_ADMIN" // 超级管理员角色名称
	RoleAdmin      RoleName = "ADMIN"       // 管理员角色名称
	RolePlayer     RoleName = "PLAYER"      // 普通玩家角色名称
)

func (rN RoleName) String() string {
	return string(rN)
}

var (
	// roleRegex 角色名称正则，只允许大写字母和下划线，2-32位
	roleRegex = regexp.MustCompile(`^[A-Z_]{2,32}$`)
)

// Role 角色实体，使用 Name 作为主键，不继承 BaseEntity。
type Role struct {
	Name        RoleName  `gorm:"primaryKey;type:varchar(32);comment:角色名称" json:"name"`
	DisplayName string    `gorm:"not null;type:varchar(64);comment:角色显示名称" json:"display_name"`
	Description string    `gorm:"not null;type:varchar(255);comment:角色描述" json:"description"`
	CreatedAt   time.Time `gorm:"not null;type:timestamptz;autoCreateTime:milli;comment:创建时间" json:"-"`
}

// BeforeCreate GORM 钩子，创建前验证角色名称格式。
func (r *Role) BeforeCreate(_ *gorm.DB) error {
	if !roleRegex.MatchString(r.Name.String()) {
		return &RoleNameError{Name: r.Name.String()}
	}
	return nil
}

// RoleNameError 角色名称格式错误。
type RoleNameError struct {
	Name string
}

func (e *RoleNameError) Error() string {
	return "无效角色名称：必须匹配 ^[A-Z_]{2,32}"
}

package main

import (
    xReg "github.com/bamboo-services/bamboo-base-go/register"
    xResult "github.com/bamboo-services/bamboo-base-go/result"
    "github.com/gin-gonic/gin"
)

func main() {
    // 一键初始化
    reg := xReg.Register()

    // 注册路由
    reg.Serve.GET("/api/status", func(c *gin.Context) {
        xResult.SuccessHasData(c, "服务正常", gin.H{
            "status": "running",
        })
    })

    // 启动服务
    reg.Serve.Run(":8080")
}

// Reg 表示应用程序的核心注册结构，包含所有初始化后的组件实例。
type Reg struct {
	Context context.Context // 上下文，用于控制取消和超时
	Serve   *gin.Engine     // Gin 引擎实例
}

// startup.go（根基导入文件）
package startup

import (
	"context"

	xReg "github.com/bamboo-services/bamboo-base-go/register"
	"github.com/gin-gonic/gin"
	"github.com/redis/go-redis/v9"
	"gorm.io/gorm"
)

// Reg 表示应用程序的核心注册结构，包含所有初始化后的组件实例。
type Reg struct {
	Context context.Context // 上下文，用于控制取消和超时
	Serve   *gin.Engine     // Gin 引擎实例
	DB      *gorm.DB        // GORM 数据库实例
	RDB     *redis.Client   // Redis 客户端实例
}

// newRegister 创建一个新的注册结构实例
func newRegister(reg *xReg.Reg) *Reg {
	return &Reg{
		Context: reg.Context,
		Serve:   reg.Serve,
	}
}

func Register(reg *xReg.Reg) *Reg {
	businessReg := newRegister(reg)

	// 初始化注册
	businessReg.databaseInit()
	businessReg.nosqlInit()

	businessReg.businessContextInit() // 稍后解释
	businessReg.businessDataPrepare() // 稍后解释

	return businessReg
}

package startup

import (
	"log/slog"
	"strings"

	xEnv "github.com/bamboo-services/bamboo-base-go/env"
	xLog "github.com/bamboo-services/bamboo-base-go/log"
	"github.com/frontleaves-mc/frontleaves-yggleaf/internal/entity"
	"gorm.io/driver/postgres"
	"gorm.io/gorm"
	"gorm.io/gorm/schema"
)

var migrateTables = []interface{}{
	&entity.Role{},
	&entity.User{},
	&entity.GameProfile{},
}

func (r *Reg) databaseInit() {
	log := xLog.WithName(xLog.NamedINIT)
	log.Debug(r.Context, "正在连接数据库...")

	// Dsn Build
	pgDsnBuilder := strings.Builder{}
	pgDsnBuilder.WriteString("host=")
	pgDsnBuilder.WriteString(xEnv.GetEnvString(xEnv.DatabaseHost, "localhost"))
	pgDsnBuilder.WriteString(" user=")
	pgDsnBuilder.WriteString(xEnv.GetEnvString(xEnv.DatabaseUser, "postgres"))
	pgDsnBuilder.WriteString(" password=")
	pgDsnBuilder.WriteString(xEnv.GetEnvString(xEnv.DatabasePass, ""))
	pgDsnBuilder.WriteString(" dbname=")
	pgDsnBuilder.WriteString(xEnv.GetEnvString(xEnv.DatabaseName, "postgres"))
	pgDsnBuilder.WriteString(" port=")
	pgDsnBuilder.WriteString(xEnv.GetEnvString(xEnv.DatabasePort, "5432"))
	pgDsnBuilder.WriteString(" TimeZone=")
	pgDsnBuilder.WriteString(xEnv.GetEnvString(xEnv.DatabaseTimezone, "Asia/Shanghai"))
	pgDsnBuilder.WriteString(" sslmode=disable")
	db, err := gorm.Open(postgres.Open(pgDsnBuilder.String()), &gorm.Config{
		NamingStrategy: schema.NamingStrategy{
			TablePrefix:   xEnv.GetEnvString(xEnv.DatabasePrefix, "fyl_"), // 表名前缀，`User` 的表名应该是 `fyl_users`
			SingularTable: true,                                           // 使用单数表名
		},
		Logger: xLog.NewSlogLogger(slog.Default().WithGroup(xLog.NamedREPO), xLog.GormLoggerConfig{
			SlowThreshold:             200,
			LogLevel:                  xLog.LevelInfo,
			Colorful:                  false,
			IgnoreRecordNotFoundError: true,
		}),
	})
	if err != nil {
		log.SugarPanic(r.Context, "连接数据库失败", "gorm_err", err.Error())
	}

	// 数据表自动迁移
	err = db.AutoMigrate(migrateTables...)
	if err != nil {
		log.SugarPanic(r.Context, "数据表自动迁移失败", "gorm_err", err.Error())
	}
	log.Info(r.Context, "数据库连接成功")
	r.DB = db
}

// startup_redis.go（缓存初始化文件）
package startup

import (
	xEnv "github.com/bamboo-services/bamboo-base-go/env"
	xLog "github.com/bamboo-services/bamboo-base-go/log"
	"github.com/redis/go-redis/v9"
)

func (r *Reg) nosqlInit() {
	log := xLog.WithName(xLog.NamedINIT)
	log.Debug(r.Context, "正在连接缓存...")

	// 连接 Redis
	rdb := redis.NewClient(&redis.Options{
		Addr:     xEnv.GetEnvString(xEnv.NoSqlHost, "localhost") + ":" + xEnv.GetEnvString(xEnv.NoSqlPort, "6379"),
		Password: xEnv.GetEnvString(xEnv.NoSqlPass, ""),
		DB:       xEnv.GetEnvInt(xEnv.NoSqlDB, 0),
		PoolSize: xEnv.GetEnvInt(xEnv.NoSqlPoolSize, 10),
	})

	log.Info(r.Context, "缓存连接成功")
	r.RDB = rdb
}

package prepare

import (
	"github.com/frontleaves-mc/frontleaves-yggleaf/internal/entity"
)

// prepareRole 初始化并保存系统默认的角色数据
func (p *Prepare) prepareRole() {
	p.db.Model(&entity.Role{}).Where("name = ?", entity.RoleSuperAdmin).Save(&entity.Role{
		Name:        entity.RoleSuperAdmin,
		DisplayName: "超级管理员",
		Description: "最高级别的系统管理员，拥有所有权限",
	})
	p.db.Model(&entity.Role{}).Where("name = ?", entity.RoleAdmin).Save(&entity.Role{
		Name:        entity.RoleAdmin,
		DisplayName: "管理员",
		Description: "系统管理员，拥有大部分管理权限",
	})
	p.db.Model(&entity.Role{}).Where("name = ?", entity.RolePlayer).Save(&entity.Role{
		Name:        entity.RolePlayer,
		DisplayName: "玩家",
		Description: "玩家，拥有基本使用权限",
	})
}

// route.go
package route

import (
	"context"

	xEnv "github.com/bamboo-services/bamboo-base-go/env"
	xMiddle "github.com/bamboo-services/bamboo-base-go/middleware"
	xReg "github.com/bamboo-services/bamboo-base-go/register"
	xRoute "github.com/bamboo-services/bamboo-base-go/route"
	"github.com/frontleaves-mc/frontleaves-yggleaf/internal/app/startup"
	"github.com/gin-gonic/gin"
	"github.com/redis/go-redis/v9"
	"gorm.io/gorm"
)

// route 代表 HTTP 路由配置的核心结构体。
//
// 该类型用于管理和绑定应用中的所有路由。其核心字段 `engine` 是一个 `*gin.Engine`，用于处理 HTTP 请求。
//
// 注意: `route` 类型的实例应通过工厂方法初始化，确保路由结构的完整性和中间件的有效性。
type route struct {
	engine  *gin.Engine     // 路由引擎
	db      *gorm.DB        // GORM 数据库实例
	rdb     *redis.Client   // Redis 客户端实例
	context context.Context // 上下文，用于控制取消和超时
}

// NewRoute 初始化路由配置。
//
// 该函数接收一个 `*gin.Engine` 实例，用于注册应用程序的所有路由。
// 它通过内部方法调用完成特定模块的路由绑定。
//
// 参数说明:
//   - g: Gin 引擎实例，是 HTTP 请求的核心处理器。
//
// 注意: 确保在调用此函数之前已完成 Gin 引擎的初始化和中间件的注册。
func NewRoute(xReg *xReg.Reg, reg *startup.Reg, context context.Context) {
	r := &route{
		engine:  xReg.Serve,
		db:      reg.DB,
		rdb:     reg.RDB,
		context: context,
	}

	// 全局异常处理
	r.engine.NoMethod(xRoute.NoMethod)
	r.engine.NoRoute(xRoute.NoRoute)

	// 全局响应处理
	r.engine.Use(xMiddle.ResponseMiddleware)
	r.engine.Use(xMiddle.ReleaseAllCors)
	r.engine.Use(xMiddle.AllowOption)

	// Swagger Register
	if xEnv.GetEnvBool(xEnv.Debug, false) {
		swaggerRegister(r.engine)
	}

	// 路由初始化注册
	{
		apiRouter := r.engine.Group("/api/v1")
		r.authRouter(apiRouter)
	}
}

// route_auth.go（不完全展示，示例【所以不给包名，压根不存在哈哈哈】）
func (r *route) authRouter(route *gin.RouterGroup) {
	group := route.Group("/auth")

	authHandler := handler.NewAuthHandler(r.db, r.rdb, r.context)
	
	group.GET("/demo", authHandler.ThisDemo)
}

package main

import (
	"context"
	"errors"
	"log/slog"
	"net/http"
	"os"
	"os/signal"
	"sync"
	"syscall"

	xEnv "github.com/bamboo-services/bamboo-base-go/env"
	xLog "github.com/bamboo-services/bamboo-base-go/log"
	xReg "github.com/bamboo-services/bamboo-base-go/register"
	"github.com/frontleaves-mc/frontleaves-yggleaf/internal/app/route"
	"github.com/frontleaves-mc/frontleaves-yggleaf/internal/app/startup"
)

func main() {
	reg := xReg.Register()
	start := startup.Register(reg)
	log := xLog.WithName(xLog.NamedMAIN)

	// 创建上下文和取消函数
	ctx, cancel := context.WithCancel(reg.Context)
	defer cancel()

	// 等待中断信号
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

	// 注册路由器
	route.NewRoute(reg, start, reg.Context)

	// 创建 HttpServer
	getHost := xEnv.GetEnvString(xEnv.Host, "localhost")
	getPort := xEnv.GetEnvString(xEnv.Port, "5566")
	server := &http.Server{
		Addr:    getHost + ":" + getPort, // 使用配置文件中指定的端口
		Handler: reg.Serve,
	}

	// =============
	//   协程启动
	// =============
	engineSync := sync.WaitGroup{}
	engineSync.Add(1) // HTTP Server

	// 启动 HTTP 服务
	go func() {
		defer engineSync.Done()
		log.Info(reg.Context, "服务器已成功启动", slog.String("addr", "http(s)://"+server.Addr))
		if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
			log.Error(reg.Context, err.Error())
		}
	}()

	// 监听关闭信号（只有一个信号监听器！）
	go func() {
		<-sigChan
		cancel() // 取消上下文，触发所有组件的优雅关闭
		log.Warn(reg.Context, "正在关闭 HTTP 服务器...")
		if err := server.Shutdown(ctx); err != nil {
			log.Error(reg.Context, err.Error())
		}
	}()

	engineSync.Wait()
	log.Info(reg.Context, "所有服务已安全退出")
	return
}