package logic

import (
	"ark-permission/internal/entity"
	"bytes"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"github.com/golang-jwt/jwt/v4"
	"time"
)

func generateAccessToken(token entity.Token, data any, sign string) (string, error) {
	claim := entity.Claims{
		Data: data,
		RegisteredClaims: jwt.RegisteredClaims{
			ID:        token.ID,
			ExpiresAt: jwt.NewNumericDate(time.Unix(int64(token.ExpiresIn), 0)),
			Issuer:    "permission",
		},
	}

	accessToken, err := jwt.NewWithClaims(jwt.SigningMethodHS256, claim).
		SignedString([]byte(sign))
	if err != nil {
		return "", err
	}

	return accessToken, nil
}

func generateRefreshToken(accessToken string) string {
	buf := bytes.NewBufferString(accessToken)
	h := sha256.New()
	_, _ = h.Write(buf.Bytes())

	return hex.EncodeToString(h.Sum(nil))
}

func parseClaims(accessToken string) (claims, error) {
	claimMap, err := parseToken(accessToken)
	if err != nil {
		return claims{}, err
	}

	claims, ok := claimMap["data"].(map[string]string)
	if ok {
		return claims, nil
	}

	return nil, fmt.Errorf("get data from claim map error")
}

func parseToken(accessToken string) (jwt.MapClaims, error) {
	// token, err := jwt.Parse(accessToken, func(token *jwt.Token) (interface{}, error) {
	// 	if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
	// 		return nil, domain.TokenUnexpectedSigningErr(fmt.Sprintf("token unexpected signing method: %v", token.Header["alg"]))
	// 	}
	//
	// 	return []byte(uc.Config.CustomConfig.Token.Secret), nil
	// })
	//
	// if err != nil {
	// 	ers.FromCode()
	// 	return jwt.MapClaims{}, usecase.TokenError{Msg: fmt.Sprintf("parse token error: %s token: %s", err.Error(), accessToken)}
	// }
	//
	// claims, ok := token.Claims.(jwt.MapClaims)
	//
	// if !(ok && token.Valid) {
	// 	return jwt.MapClaims{}, usecase.TokenError{Msg: "token valid error"}
	// }
	//
	// return claims, nil
	return nil, nil
}