package services

import (
	"58team_blog/internal/application/commands"
	"58team_blog/internal/application/common"
	"58team_blog/internal/application/errors"
	"58team_blog/internal/application/mapper"
	"58team_blog/internal/application/queries"
	"58team_blog/internal/domain/entities"
	"58team_blog/internal/domain/repository"
)

type UserService struct {
	repo repository.UsersRepository
}

func CreateUserService(repo repository.UsersRepository) UserService {
	return UserService{
		repo: repo,
	}
}

func (s *UserService) Create(cmd commands.CreateUserCommand) (*common.UserResult, error) {
	// Check user with given name exists
	{
		user, err := s.repo.FindByName(cmd.Username)
		if err != nil {
			return nil, errors.NewDBError(err.Error())
		}

		if user != nil {
			return nil, errors.NewAlreadyExistsError("user: " + cmd.Username)
		}
	}

	// Create new user
	user, err := entities.CreateUser(cmd.Username, cmd.Password)
	if err != nil {
		return nil, errors.NewValidationError(err.Error())
	}

	entity, err := s.repo.Create(&user)
	if err != nil {
		return nil, errors.NewDBError(err.Error())
	}

	result := mapper.CreateUserResultFromEntity(entity)

	return result, nil
}

func (s *UserService) FindById(query queries.UserFindByIdQuery) (*queries.UserFindByIdResult, error) {
	entity, err := s.repo.FindById(query.Id)
	if err != nil {
		return nil, errors.NewDBError(err.Error())
	}

	if err := entity.Validate(); err != nil {
		return nil, errors.NewValidationError(err.Error())
	}

	result := mapper.CreateUserFindByIdResultFromEntity(entity)

	return result, nil
}

func (s *UserService) FindByName(query queries.UserFindByNameQuery) (*queries.UserFindByNameResult, error) {
	entity, err := s.repo.FindByName(query.Name)
	if err != nil {
		return nil, errors.NewDBError(err.Error())
	}

	if err := entity.Validate(); err != nil {
		return nil, errors.NewValidationError(err.Error())
	}

	result := mapper.CreateUserFindByNameResultFromEntity(entity)
	return result, nil
}

func (s *UserService) GetAll() (*queries.UserGetAllResult, error) {
	entityList, err := s.repo.GetAll()
	if err != nil {
		return nil, errors.NewDBError(err.Error())
	}

	for _, e := range entityList {
		if err := e.Validate(); err != nil {
			return nil, errors.NewValidationError(err.Error())
		}
	}

	result := mapper.CreateUserGetAllResultFromEntity(entityList)
	return result, nil
}

func (s *UserService) Update(cmd commands.UpdateUserCommand) (*common.UserResult, error) {
	entity, err := s.repo.FindById(cmd.Id)
	if err != nil {
		return nil, errors.NewDBError(err.Error())
	}

	if err := entity.Validate(); err != nil {
		return nil, errors.NewValidationError(err.Error())
	}

	if cmd.Username != entity.UserName {
		return nil, errors.NewValidationError("You cannot change user name")
	}

	entity.Password = cmd.Password

	if err := entity.Validate(); err != nil {
		return nil, errors.NewValidationError(err.Error())
	}

	if err := s.repo.Update(entity); err != nil {
		return nil, errors.NewDBError(err.Error())
	}

	result := mapper.CreateUserResultFromEntity(entity)
	return result, nil
}

func (s *UserService) Delete(cmd commands.DeleteUserCommand) error {
	entity, err := s.repo.FindById(cmd.Id)
	if err != nil {
		return errors.NewDBError(err.Error())
	}

	if err := entity.Validate(); err != nil {
		return errors.NewValidationError(err.Error())
	}

	if err := s.repo.Delete(entity.Id); err != nil {
		return errors.NewDBError(err.Error())
	}

	return nil
}