package services

import (
	"errors"
	"fmt"
	"math/rand"
	"rijig/config"
	"rijig/dto"
	"rijig/internal/repositories"
	"rijig/model"
	"rijig/utils"
	"time"

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

const otpCooldown = 30 * time.Second

type AuthService interface {
	RegisterOrLogin(req *dto.RegisterRequest) error
	VerifyOTP(req *dto.VerifyOTPRequest) (*dto.UserDataResponse, error)
	Logout(userID, phone string) error
}

type authService struct {
	userRepo repositories.UserRepository
	roleRepo repositories.RoleRepository
}

func NewAuthService(userRepo repositories.UserRepository, roleRepo repositories.RoleRepository) AuthService {
	return &authService{userRepo, roleRepo}
}

func (s *authService) RegisterOrLogin(req *dto.RegisterRequest) error {

	if err := s.checkOTPRequestCooldown(req.Phone); err != nil {
		return err
	}

	user, err := s.userRepo.GetUserByPhoneAndRole(req.Phone, req.RoleID)
	if err != nil {
		return fmt.Errorf("failed to check existing user: %w", err)
	}

	if user != nil {
		return s.sendOTP(req.Phone)
	}

	user = &model.User{
		Phone:  req.Phone,
		RoleID: req.RoleID,
	}

	createdUser, err := s.userRepo.CreateUser(user)
	if err != nil {
		return fmt.Errorf("failed to create new user: %w", err)
	}

	if err := s.saveUserToRedis(createdUser.ID, createdUser, req.Phone); err != nil {
		return err
	}

	return s.sendOTP(req.Phone)
}

func (s *authService) checkOTPRequestCooldown(phone string) error {
	otpSentTime, err := utils.GetStringData("otp_sent:" + phone)
	if err != nil || otpSentTime == "" {
		return nil
	}
	lastSent, _ := time.Parse(time.RFC3339, otpSentTime)
	if time.Since(lastSent) < otpCooldown {
		return errors.New("please wait before requesting a new OTP")
	}
	return nil
}

func (s *authService) sendOTP(phone string) error {
	otp := generateOTP()
	if err := config.SendWhatsAppMessage(phone, fmt.Sprintf("Your OTP is: %s", otp)); err != nil {
		return err
	}

	if err := utils.SetStringData("otp:"+phone, otp, 10*time.Minute); err != nil {
		return err
	}
	return utils.SetStringData("otp_sent:"+phone, time.Now().Format(time.RFC3339), 10*time.Minute)
}

func (s *authService) VerifyOTP(req *dto.VerifyOTPRequest) (*dto.UserDataResponse, error) {

	storedOTP, err := utils.GetStringData("otp:" + req.Phone)
	if err != nil || storedOTP == "" {
		return nil, errors.New("OTP expired or not found")
	}

	if storedOTP != req.OTP {
		return nil, errors.New("invalid OTP")
	}

	if err := utils.DeleteData("otp:" + req.Phone); err != nil {
		return nil, fmt.Errorf("failed to remove OTP from Redis: %w", err)
	}

	existingUser, err := s.userRepo.GetUserByPhoneAndRole(req.Phone, req.RoleID)
	if err != nil {
		return nil, fmt.Errorf("failed to check existing user: %w", err)
	}

	var user *model.User
	if existingUser != nil {
		user = existingUser
	} else {

		user = &model.User{
			Phone:  req.Phone,
			RoleID: req.RoleID,
		}
		createdUser, err := s.userRepo.CreateUser(user)
		if err != nil {
			return nil, err
		}
		user = createdUser
	}

	token, err := s.generateJWTToken(user.ID)
	if err != nil {
		return nil, err
	}

	role, err := s.roleRepo.FindByID(user.RoleID)
	if err != nil {
		return nil, fmt.Errorf("failed to get role: %w", err)
	}

	if err := s.saveSessionData(user.ID, user.RoleID, role.RoleName, token); err != nil {
		return nil, err
	}

	return &dto.UserDataResponse{
		UserID:   user.ID,
		UserRole: role.RoleName,
		Token:    token,
	}, nil
}

func (s *authService) saveUserToRedis(userID string, user *model.User, phone string) error {
	if err := utils.SetJSONData("user:"+userID, user, 10*time.Minute); err != nil {
		return fmt.Errorf("failed to store user data in Redis: %w", err)
	}

	if err := utils.SetStringData("user_phone:"+userID, phone, 10*time.Minute); err != nil {
		return fmt.Errorf("failed to store user phone in Redis: %w", err)
	}

	return nil
}

func (s *authService) generateJWTToken(userID string) (string, error) {
	expirationTime := time.Now().Add(24 * time.Hour)
	claims := &jwt.RegisteredClaims{
		Subject:   userID,
		ExpiresAt: jwt.NewNumericDate(expirationTime),
	}

	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	secretKey := config.GetSecretKey()

	return token.SignedString([]byte(secretKey))
}

func (s *authService) saveSessionData(userID string, roleID string, roleName string, token string) error {
	sessionKey := fmt.Sprintf("session:%s", userID)
	sessionData := map[string]interface{}{
		"userID":   userID,
		"roleID":   roleID,
		"roleName": roleName,
	}

	if err := utils.SetJSONData(sessionKey, sessionData, 24*time.Hour); err != nil {
		return fmt.Errorf("failed to set session data: %w", err)
	}

	if err := utils.SetStringData("session_token:"+userID, token, 24*time.Hour); err != nil {
		return fmt.Errorf("failed to set session token: %w", err)
	}

	return nil
}

func (s *authService) Logout(userID, phone string) error {
	keys := []string{
		"session:" + userID,
		"session_token:" + userID,
		"user_logged_in:" + userID,
		"user:" + userID,
		"user_phone:" + userID,
		"otp_sent:" + phone,
	}

	for _, key := range keys {
		if err := utils.DeleteData(key); err != nil {
			return fmt.Errorf("failed to delete key %s from Redis: %w", key, err)
		}
	}

	return nil
}

func generateOTP() string {
	randGenerator := rand.New(rand.NewSource(time.Now().UnixNano()))
	return fmt.Sprintf("%04d", randGenerator.Intn(10000))
}