package users

import (
	"fmt"
	"furtuna-be/internal/common/mycontext"
	"gorm.io/gorm"

	"go.uber.org/zap"

	"furtuna-be/internal/common/logger"
	"furtuna-be/internal/entity"
	"furtuna-be/internal/repository"
)

type UserService struct {
	repo       repository.User
	branchRepo repository.Branch
}

func NewUserService(repo repository.User, branchRepo repository.Branch) *UserService {
	return &UserService{
		repo:       repo,
		branchRepo: branchRepo,
	}
}

func (s *UserService) Create(ctx mycontext.Context, userReq *entity.User) (*entity.User, error) {
	//check
	userExist, err := s.repo.GetUserByEmail(ctx, userReq.Email)
	if err != nil {
		return nil, err
	}

	if userExist != nil {
		return nil, fmt.Errorf("Email already exist")
	}

	userDB, err := userReq.ToUserDB(ctx.RequestedBy())
	if err != nil {
		return nil, err
	}

	userDB, err = s.repo.Create(ctx, userDB)
	if err != nil {
		logger.ContextLogger(ctx).Error("error when create user", zap.Error(err))
		return nil, err
	}

	return userDB.ToUser(), nil
}

func (s *UserService) CreateWithTx(ctx mycontext.Context, tx *gorm.DB, userReq *entity.User) (*entity.User, error) {
	//check
	userExist, err := s.repo.GetUserByEmail(ctx, userReq.Email)
	if err != nil {
		return nil, err
	}

	if userExist != nil {
		return nil, fmt.Errorf("Email already exist")
	}

	userDB, err := userReq.ToUserDB(ctx.RequestedBy())
	if err != nil {
		return nil, err
	}

	userDB, err = s.repo.CreateWithTx(ctx, tx, userDB)
	if err != nil {
		logger.ContextLogger(ctx).Error("error when create user", zap.Error(err))
		return nil, err
	}

	return userDB.ToUser(), nil
}

func (s *UserService) GetAll(ctx mycontext.Context, search entity.UserSearch) ([]*entity.User, int, error) {

	users, total, err := s.repo.GetAllUsers(ctx, search)
	if err != nil {
		logger.ContextLogger(ctx).Error("error when get all users", zap.Error(err))
		return nil, 0, err
	}

	return users.ToUserList(), total, nil
}

func (s *UserService) GetByID(ctx mycontext.Context, id int64) (*entity.User, error) {
	userDB, err := s.repo.GetUserByID(ctx, id)
	if err != nil {
		logger.ContextLogger(ctx).Error("error when get user by id", zap.Error(err))
		return nil, err
	}

	return userDB.ToUser(), nil
}

func (s *UserService) Update(ctx mycontext.Context, id int64, userReq *entity.User) (*entity.User, error) {
	existingUser, err := s.repo.GetUserByID(ctx, id)
	if err != nil {
		return nil, err
	}

	//if changed branch
	if *userReq.PartnerID > 0 {
		branch, err := s.branchRepo.GetBranchByID(ctx, *userReq.PartnerID)
		if err != nil {
			return nil, err
		}

		existingUser.PartnerName = branch.Name
	}

	err = existingUser.ToUpdatedUser(*userReq)
	if err != nil {
		return nil, err
	}

	updatedUserDB, err := s.repo.UpdateUser(ctx, existingUser)
	if err != nil {
		logger.ContextLogger(ctx).Error("error when update user", zap.Error(err))
		return nil, err
	}

	return updatedUserDB.ToUser(), nil
}

func (s *UserService) Delete(ctx mycontext.Context, id int64) error {
	userDB, err := s.repo.GetUserByID(ctx, id)
	if err != nil {
		logger.ContextLogger(ctx).Error("error when get user by id", zap.Error(err))
		return err
	}

	userDB.SetDeleted(ctx.RequestedBy())

	_, err = s.repo.UpdateUser(ctx, userDB)
	if err != nil {
		logger.ContextLogger(ctx).Error("error when update user", zap.Error(err))
		return err
	}

	return nil
}