package services

import (
	"strings"

	"GoMembership/internal/constants"
	"GoMembership/internal/models"
	"GoMembership/internal/repositories"
	"GoMembership/pkg/errors"

	"github.com/gin-gonic/gin"
	"gorm.io/gorm"

	"time"
)

type UserServiceInterface interface {
	Register(user *models.User) (id uint, token string, err error)
	Update(user *models.User) (*models.User, error)
	Delete(id *uint) error
	FromContext(c *gin.Context) (*models.User, error)
	FromID(id *uint) (*models.User, error)
	FromEmail(email *string) (*models.User, error)
	GetUsers(where map[string]interface{}) (*[]models.User, error)
}

type UserService struct {
	Licences repositories.LicenceInterface
	DB       *gorm.DB
}

func (s *UserService) FromContext(c *gin.Context) (*models.User, error) {
	var user models.User
	if err := user.FromContext(s.DB, c); err != nil {
		return nil, err
	}
	return &user, nil
}

func (s *UserService) FromID(id *uint) (*models.User, error) {
	var user models.User
	if err := user.FromID(s.DB, id); err != nil {
		return nil, err
	}
	return &user, nil
}

func (s *UserService) FromEmail(email *string) (*models.User, error) {
	var user models.User
	if err := user.FromEmail(s.DB, email); err != nil {
		return nil, err
	}
	return &user, nil
}

func (s *UserService) Delete(id *uint) error {
	var user models.User
	if err := user.FromID(s.DB, id); err != nil {
		return err
	}

	return user.Delete(s.DB)
}

func (s *UserService) Update(user *models.User) (*models.User, error) {

	var existingUser models.User
	if err := existingUser.FromID(s.DB, &user.ID); err != nil {
		return nil, err
	}
	user.Membership.ID = existingUser.Membership.ID
	if existingUser.Licence != nil {
		user.Licence.ID = existingUser.Licence.ID
	}
	user.BankAccount.ID = existingUser.BankAccount.ID

	user.SetPassword(user.Password)

	// Validate subscription model
	selectedModel, err := repositories.GetSubscriptionByName(&user.Membership.SubscriptionModel.Name)
	if err != nil {
		return nil, errors.ErrSubscriptionNotFound
	}
	user.Membership.SubscriptionModel = *selectedModel
	user.Membership.SubscriptionModelID = selectedModel.ID

	if err := user.Update(s.DB); err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, errors.ErrUserNotFound
		}
		if strings.Contains(err.Error(), "UNIQUE constraint failed") {
			return nil, errors.ErrDuplicateEntry
		}
		return nil, err
	}
	return user, nil
}

func (s *UserService) Register(user *models.User) (id uint, token string, err error) {
	user.SetPassword(user.Password)

	selectedModel, err := repositories.GetSubscriptionByName(&user.Membership.SubscriptionModel.Name)
	if err != nil {
		return 0, "", errors.ErrSubscriptionNotFound
	}
	user.Membership.SubscriptionModel = *selectedModel
	user.Membership.SubscriptionModelID = selectedModel.ID
	user.Status = constants.UnverifiedStatus
	user.BankAccount.MandateDateSigned = time.Now()
	v, err := user.SetVerification(constants.VerificationTypes.Email)
	if err != nil {
		return 0, "", err
	}

	if err := user.Create(s.DB); err != nil {
		return 0, "", err
	}

	return user.ID, v.VerificationToken, nil
}

// GetUsers returns a list of users based on the provided where clause.
// if where == nil: all users are returned
func (s *UserService) GetUsers(where map[string]interface{}) (*[]models.User, error) {
	if where == nil {
		where = map[string]interface{}{}
	}
	return models.GetUsersWhere(s.DB, where)
}