package ru.soune.no_copy.service;

import lombok.RequiredArgsConstructor;
import org.springframework.context.MessageSource;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import ru.soune.no_copy.dto.LoginRequest;
import ru.soune.no_copy.dto.RegisterRequest;
import ru.soune.no_copy.entity.AuthToken;
import ru.soune.no_copy.entity.User;
import ru.soune.no_copy.exception.NotValidationPasswordException;
import ru.soune.no_copy.exception.UserAlreadyExistsException;
import ru.soune.no_copy.exception.UserNotFoundException;
import ru.soune.no_copy.repository.AuthTokenRepository;
import ru.soune.no_copy.repository.UserRepository;

import java.security.SecureRandom;
import java.util.Base64;
import java.util.Locale;
import java.util.Optional;

@Service
@RequiredArgsConstructor
public class AuthService {

    private final UserRepository userRepository;

    private final AuthTokenRepository authTokenRepository;

    private final PasswordEncoder passwordEncoder;

    private final MessageSource messageSource;

    private final SecureRandom secureRandom = new SecureRandom();

    @Transactional
    public AuthToken register(RegisterRequest registerRequest) {
        if (userRepository.existsByEmail(registerRequest.email())) {
            throw new UserAlreadyExistsException(messageSource.getMessage("error.user.exists", null,
                    Locale.getDefault()));
        }

        User user = new User();
        user.setFirstName(registerRequest.firstName());
        user.setSecondName(registerRequest.secondName());
        user.setLastName(registerRequest.lastName());
        user.setEmail(registerRequest.email());
        user.setPassword(passwordEncoder.encode(registerRequest.password()));

        User savedUser = userRepository.save(user);

        AuthToken authToken = new AuthToken();
        authToken.setToken(generateAuthToken());
        authToken.setUser(savedUser);

        return authTokenRepository.save(authToken);
    }

    @Transactional
    public AuthToken login(LoginRequest request) {
        Optional<User> userOpt = userRepository.findByEmail(request.getEmail());

        if (userOpt.isEmpty()) {
            throw new UserNotFoundException("User with email " + request.getEmail() + " not found");
        }

        User user = userOpt.get();

        if (!passwordEncoder.matches(request.getPassword(), user.getPassword())) {
            throw new NotValidationPasswordException("Invalid password");
        }

        AuthToken authToken = new AuthToken();
        authToken.setToken(generateAuthToken());
        authToken.setUser(user);

        return authTokenRepository.save(authToken);
    }

    public void logout(String token) {
        authTokenRepository.findByToken(token)
                .ifPresent(authTokenRepository::delete);
    }

    private String generateAuthToken() {
        byte[] bytes = new byte[32];
        secureRandom.nextBytes(bytes);
        return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);
    }
}