import (
	"test_go_zero/user/rpc/rpcclient"
	"test_go_zero/video/api/internal/config"

	"github.com/zeromicro/go-zero/zrpc"
)

type ServiceContext struct {
	Config  config.Config	//自己的 config 不动
	UserRpc rpcclient.Rpc	//远程的 Rpc 结构体
}

func NewServiceContext(c config.Config) *ServiceContext {
	return &ServiceContext{
		Config:  c,
		UserRpc: rpcclient.NewRpc(zrpc.MustNewClient(c.UserRpc)),	// 远程的 Rpc 结构体客户端
	}
}

func (l *GetVideoLogic) GetVideo(req *types.VideoReq) (resp *types.VideoRes, err error) {
	ping, err := l.svcCtx.UserRpc.Ping(l.ctx, &rpc.IdRequest{Id: req.Id})	//调用远程 RPC
	if err != nil {
		return nil, err
	}
	return &types.VideoRes{
		Id:   ping.Id,
		Name: ping.Name,
	}, nil
}

package common

import (
	"net/http"

	"github.com/zeromicro/go-zero/rest/httpx"
)

type Body struct {
	Code uint32      `json:"code"`
	Msg  string      `json:"msg"`
	Data interface{} `json:"data"`
}

// Response 统一响应处理
func Response(r *http.Request, w http.ResponseWriter, resp interface{}, err error) {
	if err == nil {
		// 成功响应
		r := Body{
			Code: 0,
			Msg:  "ok",
			Data: resp,
		}
		httpx.WriteJson(w, http.StatusOK, r)
		return
	}

	// 错误响应
	errCode := uint32(404)
	// 可根据错误类型，返回具体错误信息
	errMsg := err.Error()
	httpx.WriteJson(w, http.StatusBadRequest, Body{
		Code: errCode,
		Msg:  errMsg,
		Data: nil,
	})
}

// Code scaffolded by goctl. Safe to edit.
// goctl {{.version}}

package {{.PkgName}}

import (
	"net/http"

	"github.com/zeromicro/go-zero/rest/httpx"
	{{.ImportPackages}}
	"test_go_zero/common"	//替换成自己的项目模块
)

{{if .HasDoc}}{{.Doc}}{{end}}
func {{.HandlerName}}(svcCtx *svc.ServiceContext) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		{{if .HasRequest}}var req types.{{.RequestType}}
		if err := httpx.Parse(r, &req); err != nil {
			httpx.ErrorCtx(r.Context(), w, err)
			return
		}

		{{end}}l := {{.LogicName}}.New{{.LogicType}}(r.Context(), svcCtx)
		{{if .HasResp}}resp, {{end}}err := l.{{.Call}}({{if .HasRequest}}&req{{end}})
		//if err != nil {
		//	httpx.ErrorCtx(r.Context(), w, err)
		//} else {
		//	{{if .HasResp}}httpx.OkJsonCtx(r.Context(), w, resp){{else}}httpx.Ok(w){{end}}
		//}
		{{if .HasResp}}common.Response(r, w, resp, err){{else}}response.Response(r, w, nil, err){{end}}
	}
}

package utils

import (
	"errors"
	"time"

	"github.com/golang-jwt/jwt/v4"
)

// JwtPayLoad JWT Payload 结构
type JwtPayLoad struct {
	UserID   uint   `json:"user_id"`  // 用户ID
	Username string `json:"username"` // 用户名
	Role     int    `json:"role"`     // 权限 1-普通用户 2-管理员
}

// CustomClaims 自定义JWT声明
type CustomClaims struct {
	jwt.RegisteredClaims
	JwtPayLoad
}

// GenToken 生成JWT Token
func GenToken(user JwtPayLoad, accessSecret string, expires int64) (string, error) {
	claims := CustomClaims{
		JwtPayLoad: user,
		RegisteredClaims: jwt.RegisteredClaims{
			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour * time.Duration(expires))),
		},
	}

	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	return token.SignedString([]byte(accessSecret))
}

// ParseToken 解析JWT Token
func ParseToken(tokenStr string, accessSecret string, expires int64) (*CustomClaims, error) {
	token, err := jwt.ParseWithClaims(tokenStr, &CustomClaims{}, func(token *jwt.Token) (interface{}, error) {
		return []byte(accessSecret), nil
	})
	if err != nil {
		return nil, err
	}

	if claims, ok := token.Claims.(*CustomClaims); ok && token.Valid {
		return claims, nil
	}
	return nil, errors.New("invalid token")
}

func (l *LoginLogic) Login(req *types.LoginRequest) (resp *types.LoginResponse, err error) {
	// 从配置文件中获取密钥和过期时间
	secret := l.svcCtx.Config.Auth.AccessSecret
	expire := l.svcCtx.Config.Auth.AccessExpire
	token, err := utils.GenToken(utils.JwtPayLoad{
		UserID:   0,
		Username: req.Name,
		Role:     1,
	}, secret, expire)
	if err != nil {
		return nil, err
	}
	return &types.LoginResponse{
		Token: token,
	}, nil
}

func main() {
	flag.Parse()

	var c config.Config
	conf.MustLoad(*configFile, &c)
	// 添加鉴权失败的回调
	server := rest.MustNewServer(c.RestConf, rest.WithUnauthorizedCallback(JwtUnauthorizedResult))
	defer server.Stop()

	ctx := svc.NewServiceContext(c)
	handler.RegisterHandlers(server, ctx)

	fmt.Printf("Starting server at %s:%d...\n", c.Host, c.Port)
	server.Start()
}

// JwtUnauthorizedResult 鉴权失败
func JwtUnauthorizedResult(w http.ResponseWriter, r *http.Request, err error) {
	fmt.Println("JwtUnauthorizedResult:", err)
	httpx.WriteJson(w, http.StatusOK, common.Body{
		Code: 10087,
		Msg:  "鉴权失败",
		Data: nil,
	})
}

func InitDB(MysqlDataSource string) *gorm.DB {
	db, err := gorm.Open(mysql.Open(MysqlDataSource), &gorm.Config{})
	if err != nil {
		panic("Mysql 连接错误" + err.Error())
	}
	fmt.Println("Mysql 连接成功")
	err = db.AutoMigrate(&models.UserModel{})
	if err != nil {
		panic("自动建表失败" + err.Error())
	}
	return db
}

type ServiceContext struct {
	Config config.Config
	DB     *gorm.DB
}

func NewServiceContext(c config.Config) *ServiceContext {
	db := common.InitDB(c.MySql.DataSource)
	return &ServiceContext{
		Config: c,
		DB:     db,
	}
}