package service

import (
	"context"
	"errors"
	"fmt"

	entity "git.ego.freeddns.org/egommerce/api-entities/identity/entity"
	domain "git.ego.freeddns.org/egommerce/identity-service/domain/repository"

	"github.com/go-redis/redis/v8"
)

var (
	passSrv *PaswordService

	ErrLoginIncorrect     = errors.New("login incorrect")
	ErrUnableToCacheToken = errors.New("unable to save tokens in cache")
	ErrInvalidAccessToken = errors.New("invalid access token")
)

func init() {
	passSrv = NewPasswordService()
}

type Auth struct {
	userRepo *domain.UserRepository
	cache    *redis.Client
}

func NewAuthService(userRepo *domain.UserRepository, cache *redis.Client) *Auth {
	return &Auth{
		userRepo: userRepo,
		cache:    cache,
	}
}

func (a *Auth) Login(login, passwd string) (string, error) {
	user, err := a.userRepo.FindByUsername(login)
	if err != nil {
		// if err = database.NoRowsInQuerySet(err); err != nil {
		// 	return "", errors.New("no user found")
		// }

		return "", ErrLoginIncorrect
	}

	if err = passSrv.Verify(passwd, user.Password); err != nil {
		return "", ErrLoginIncorrect
	}

	accessToken, _ := jwtSrv.CreateAccessToken(user.ID)
	refreshToken, _ := jwtSrv.CreateRefreshToken(user.ID)
	if err = a.saveTokensToCache(user.ID, accessToken, refreshToken); err != nil {
		return "", ErrUnableToCacheToken
	}

	return accessToken, nil
}

func (a *Auth) RefreshToken(accessToken string) (string, error) {
	token, claims, err := jwtSrv.ValidateAccessToken(accessToken)
	if err != nil || !token.Valid {
		return "", ErrInvalidAccessToken
	}

	id := claims["sub"]

	newAccessToken, _ := jwtSrv.CreateAccessToken(id.(string))
	newRefreshToken, _ := jwtSrv.CreateRefreshToken(id.(string))
	if err = a.saveTokensToCache(id.(string), newAccessToken, newRefreshToken); err != nil {
		return "", ErrUnableToCacheToken
	}

	return newAccessToken, nil
}

func (a *Auth) VerifyToken(token string) (string, error) {

	return token, nil
}

func (a *Auth) Register(email, login, passwd string) (string, error) {
	passwd, _ = passSrv.Hash(passwd)

	id, err := a.userRepo.Create(&entity.User{
		Email:    email,
		Username: login,
		Password: passwd,
	})
	if err != nil {
		return "", err
	}

	return id, nil
}

func (a *Auth) saveTokensToCache(id, accessToken, refreshToken string) error {
	res := a.cache.Set(context.Background(), "auth:access_token:"+id, accessToken, accessTokenExpireTime)
	if err := res.Err(); err != nil {
		fmt.Println("failed to save access token in cache: ", err.Error())
	}

	res = a.cache.Set(context.Background(), "auth:refresh_token:"+id, refreshToken, refreshTokenExpireTime)
	if err := res.Err(); err != nil {
		fmt.Println("failed to save refresh token in cache: ", err.Error())
	}

	return nil
}