package myJwt

import (
	"errors"
	"github.com/golang-jwt/jwt/v5"
	"time"
)

type Claims struct {
	UserId int `json:"uid"`
	jwt.RegisteredClaims
}

func (t Claims) toSimpleJwt() *SimpleJwt {
	return &SimpleJwt{
		Audience:  t.Audience,
		ExpiresAt: t.ExpiresAt,
		Id:        t.ID,
		IssuedAt:  t.IssuedAt,
		Issuer:    t.Issuer,
		NotBefore: t.NotBefore,
		Subject:   t.Subject,
		userId:    t.UserId,
		jwtSecret: "",
	}

}

type SimpleJwt struct {
	Audience  jwt.ClaimStrings
	ExpiresAt *jwt.NumericDate
	Id        string
	IssuedAt  *jwt.NumericDate
	Issuer    string
	NotBefore *jwt.NumericDate
	Subject   string

	userId    int
	jwtSecret string
}

func NewSimpleJwt(userId int, jwtSecret string) *SimpleJwt {
	return &SimpleJwt{
		userId:    userId,
		jwtSecret: jwtSecret,

		ExpiresAt: jwt.NewNumericDate(time.Now().Add(90 * 24 * time.Hour)),
		Issuer:    "zhecent",
	}
}

func (t *SimpleJwt) SetExpiresAt(expiresAt time.Time) {
	t.ExpiresAt = jwt.NewNumericDate(expiresAt)
}

func (t *SimpleJwt) makeClaims() Claims {
	return Claims{
		UserId: t.userId,
		RegisteredClaims: jwt.RegisteredClaims{
			ExpiresAt: t.ExpiresAt,
			Issuer:    t.Issuer,
		},
	}
}

func (t *SimpleJwt) GetUserId() int {
	return t.userId
}

func (t *SimpleJwt) GenerateToken() (string, error) {
	tokenClaims := jwt.NewWithClaims(jwt.SigningMethodHS256, t.makeClaims())
	token, err := tokenClaims.SignedString([]byte(t.jwtSecret))
	return token, err
}

func (t *SimpleJwt) MustGenerateToken() string {
	s, e := t.GenerateToken()
	if e != nil {
		panic(e.Error())
	}
	return s
}

func ParseToken(token string, jwtSecret string) (*SimpleJwt, error) {
	tokenClaims, err := jwt.ParseWithClaims(token, &Claims{}, func(token *jwt.Token) (interface{}, error) {
		return []byte(jwtSecret), nil
	})

	if tokenClaims != nil {
		if claims, ok := tokenClaims.Claims.(*Claims); ok && tokenClaims.Valid {
			return claims.toSimpleJwt(), nil
		}
	}

	switch {
	case errors.Is(err, jwt.ErrTokenMalformed):
		return nil, errors.New("that's not even a token")
	case errors.Is(err, jwt.ErrTokenSignatureInvalid):
		// Invalid signature
		return nil, errors.New("invalid signature")
	case errors.Is(err, jwt.ErrTokenExpired) || errors.Is(err, jwt.ErrTokenNotValidYet):
		// Token is either expired or not active yet
		return nil, errors.New("timing is everything")
	default:
		return nil, errors.New("token校验失败")
	}
}

func MustParseToken(token string, jwtSecret string) *SimpleJwt {
	s, e := ParseToken(token, jwtSecret)
	if e != nil {
		panic(e.Error())
	}
	return s
}