package http_handler

import (
	"bou.ke/monkey"
	"common/db/redis"
	"common/net/grpc/service"
	"common/net/http/http_resp"
	"common/proto/ss/grpc_pb"
	"common/proto/ss/grpc_pb/mocks"
	"common/utils"
	"context"
	"fmt"
	"gateway/internal/global"
	"gateway/internal/testutil"
	"github.com/gin-gonic/gin"
	"github.com/golang/mock/gomock"
	redis2 "github.com/redis/go-redis/v9"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/suite"
	"net/http"
	"testing"
)

type LoginTestSuite struct {
	testutil.TestSuite
}

func (ts *LoginTestSuite) TestGenToken() {
	usn := utils.RandInt(1, 100000000)
	at, rt, err := genToken(context.Background(), int64(usn))
	ts.Assert().NoError(err)

	redisAt := redis.GetClient().Get(context.Background(), fmt.Sprintf(global.KeyGatewayAccessToken, usn)).Val()
	ts.Assert().Equal(at, redisAt)
	redisRt := redis.GetClient().Get(context.Background(), fmt.Sprintf(global.KeyGatewayRefreshToken, usn)).Val()
	ts.Assert().Equal(rt, redisRt)
}

func (ts *LoginTestSuite) TestLogin() {
	gin.SetMode(gin.TestMode)

	ts.Run("ShouldBindJSON Failed", func() {
		w, c := utils.CreateTestContext("POST", "/", &LoginReq{
			Phone: "",
			Code:  "",
		})
		Login(c)
		utils.AssertResponse(&ts.Suite, w, http.StatusBadRequest, http_resp.ParamError)
	})

	ts.Run("UserNewClientLB Failed", func() {
		monkey.Patch(service.UserNewClientLB, func() (grpc_pb.UserClient, error) {
			return nil, assert.AnError
		})
		defer monkey.Unpatch(service.UserNewClientLB)

		w, c := utils.CreateTestContext("POST", "/", &LoginReq{
			Phone: "13800000000",
			Code:  "1234",
		})
		Login(c)
		utils.AssertResponse(&ts.Suite, w, http.StatusOK, http_resp.Failed)
	})

	ts.Run("Login Failed", func() {
		ctrl := gomock.NewController(ts.T())
		defer ctrl.Finish()
		client := mocks.NewMockUserClient(ctrl)
		client.EXPECT().
			Login(gomock.Any(), gomock.Any()).
			Return(nil, fmt.Errorf("gRPC failed"))

		monkey.Patch(service.UserNewClientLB, func() (grpc_pb.UserClient, error) {
			return client, nil
		})
		defer monkey.Unpatch(service.UserNewClientLB)

		w, c := utils.CreateTestContext("POST", "/", &LoginReq{
			Phone: "13800000000",
			Code:  "1234",
		})
		Login(c)
		utils.AssertResponse(&ts.Suite, w, http.StatusOK, http_resp.Failed)
	})

	ts.Run("OK", func() {
		ctrl := gomock.NewController(ts.T())
		defer ctrl.Finish()
		client := mocks.NewMockUserClient(ctrl)
		client.EXPECT().
			Login(gomock.Any(), gomock.Any()).
			Return(&grpc_pb.LoginResp{USN: 1, Name: "hh"}, nil)

		monkey.Patch(service.UserNewClientLB, func() (grpc_pb.UserClient, error) {
			return client, nil
		})
		defer monkey.Unpatch(service.UserNewClientLB)

		w, c := utils.CreateTestContext("POST", "/", &LoginReq{
			Phone: "13800000000",
			Code:  "1234",
		})
		Login(c)
		utils.AssertResponse(&ts.Suite, w, http.StatusOK, http_resp.OK)
	})
}

func (ts *LoginTestSuite) TestRefreshToken() {
	gin.SetMode(gin.TestMode)

	ts.Run("ShouldBindJSON Failed", func() {
		w, c := utils.CreateTestContext("POST", "/", &RefreshTokenReq{
			RefreshToken: "",
		})
		RefreshToken(c)
		utils.AssertResponse(&ts.Suite, w, http.StatusBadRequest, http_resp.ParamError)
	})

	ts.Run("ParseToken Failed", func() {
		monkey.Patch(utils.ParseToken, func(tokenString string, secret string) (*utils.Claims, error) {
			return nil, assert.AnError
		})
		defer monkey.Unpatch(utils.ParseToken)

		w, c := utils.CreateTestContext("POST", "/", &RefreshTokenReq{
			RefreshToken: "abc",
		})
		RefreshToken(c)
		utils.AssertResponse(&ts.Suite, w, http.StatusOK, http_resp.TokenInvalid)
	})

	ts.Run("Redis Get Failed", func() {
		monkey.Patch(utils.ParseToken, func(tokenString string, secret string) (*utils.Claims, error) {
			if tokenString == "abc" {
				return &utils.Claims{USN: 1}, nil
			}
			return nil, assert.AnError
		})
		defer monkey.Unpatch(utils.ParseToken)

		redis.GetClient().Set(context.Background(), fmt.Sprintf(global.KeyGatewayRefreshToken, 1), "ab", redis2.KeepTTL)

		w, c := utils.CreateTestContext("POST", "/", &RefreshTokenReq{
			RefreshToken: "abc",
		})
		RefreshToken(c)
		utils.AssertResponse(&ts.Suite, w, http.StatusOK, http_resp.TokenInvalid)
	})

	ts.Run("OK", func() {
		monkey.Patch(utils.ParseToken, func(tokenString string, secret string) (*utils.Claims, error) {
			if tokenString == "abc" {
				return &utils.Claims{USN: 1}, nil
			}
			return nil, assert.AnError
		})
		defer monkey.Unpatch(utils.ParseToken)

		redis.GetClient().Set(context.Background(), fmt.Sprintf(global.KeyGatewayRefreshToken, 1), "abc", redis2.KeepTTL)

		w, c := utils.CreateTestContext("POST", "/", &RefreshTokenReq{
			RefreshToken: "abc",
		})
		RefreshToken(c)
		utils.AssertResponse(&ts.Suite, w, http.StatusOK, http_resp.OK)
	})
}

func TestLoginTestSuite(t *testing.T) {
	suite.Run(t, &LoginTestSuite{})
}