package users

import (
	"errors"
	"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
}

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

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) GetAllCustomer(ctx mycontext.Context, search entity.CustomerSearch) ([]*entity.Customer, int, error) {

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

	return users.ToCustomerList(), 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 existingUser == nil {
		return nil, errors.New("user not found")
	}

	if *existingUser.PartnerID != *userReq.PartnerID {
		return nil, errors.New("user not found")
	}

	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) UpdateWithTx(ctx mycontext.Context, tx *gorm.DB, req *entity.User) (*entity.User, error) {
	existingUser, err := s.repo.GetUserByID(ctx, req.ID)
	if err != nil {
		return nil, err
	}

	if existingUser == nil {
		return nil, errors.New("user not found")
	}

	if *existingUser.PartnerID != *req.PartnerID {
		return nil, errors.New("invalid request")
	}

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

	updatedUserDB, err := s.repo.UpdateUserWithTx(ctx, tx, 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
}