package ru.soune.nocopy.controller;

import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.*;
import ru.soune.nocopy.dto.BaseResponse;
import ru.soune.nocopy.dto.MessageCode;
import ru.soune.nocopy.dto.register.ChangePasswordRequest;
import ru.soune.nocopy.dto.register.RegAnswer;
import ru.soune.nocopy.dto.register.RegRequest;
import ru.soune.nocopy.dto.user.UserDTO;
import ru.soune.nocopy.dto.user.UserRequest;
import ru.soune.nocopy.entity.user.AuthToken;
import ru.soune.nocopy.entity.user.User;
import ru.soune.nocopy.exception.InvalidUserEmail;
import ru.soune.nocopy.exception.NotFoundAuthToken;
import ru.soune.nocopy.exception.NotValidFieldException;
import ru.soune.nocopy.mapper.UserMapper;
import ru.soune.nocopy.repository.AuthTokenRepository;
import ru.soune.nocopy.repository.UserRepository;
import ru.soune.nocopy.service.register.AuthService;
import ru.soune.nocopy.service.user.UserService;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Optional;

@RestController
@RequestMapping("v1/api/user")
@RequiredArgsConstructor
public class UserController {

    private final UserRepository userRepository;

    private final UserService userService;

    private final AuthTokenRepository authTokenRepository;

    private final UserMapper userMapper;

    private final PasswordEncoder passwordEncoder;

    private final AuthService authService;

    @GetMapping("/all")
    public ResponseEntity<List<UserDTO>> getAllUsers() {
        List<UserDTO> allUsers = userRepository.findAll().stream()
                .map(u -> new UserDTO(u.getFullName(), u.getCompany(), u.getEmail(), u.isActive(),
                        u.getPhone(), u.getGenderType(),
                        u.getBirthday(), u.getCreatedAt(), u.getSubscriptionType()))
                .toList();

        return ResponseEntity.ok(allUsers);
    }

    @GetMapping
    public ResponseEntity<UserDTO> getUser(@RequestParam("email") String email,
                                           @RequestHeader("Authorization") String tokenHeader) {
        String token = tokenHeader.replace("Bearer ", "");

        Optional<AuthToken> tokenOptional = authTokenRepository.findByToken(token);

        AuthToken authToken = tokenOptional.orElseThrow(() -> new NotFoundAuthToken("Token: " + token + "not found"));

        if (authToken != null) {
            User user = userRepository.findByEmail(email);
            //TODO add mapper
            if (user != null) {
                UserDTO userDTO = userMapper.toDTO(user);
                userDTO.setEmail(email);
                userDTO.setFullName(user.getFullName());
                userDTO.setCompany(user.getCompany());
                userDTO.setPhone(user.getPhone());
                userDTO.setGenderType(user.getGenderType());
                userDTO.setBirthday(user.getBirthday());
                userDTO.setCreatedAt(user.getCreatedAt());
                userDTO.setSubscriptionType(user.getSubscriptionType());
                userDTO.setActive(user.isActive());

                return ResponseEntity.ok(userDTO);
            }

        }

        return ResponseEntity.notFound().build();
    }

    //TODO fix mapper,doesnot exist all fields
    @PostMapping("/change-password")
    public ResponseEntity<UserDTO> updateUser(@RequestBody ChangePasswordRequest changePasswordRequest,
                                              @RequestHeader("Authorization") String tokenHeader) {
        String token = tokenHeader.replace("Bearer ", "");

        Optional<AuthToken> tokenOptional = authTokenRepository.findByToken(token);

        AuthToken authToken = tokenOptional.orElseThrow(() -> new NotFoundAuthToken("Token: " + token + "not found"));

        User user = authToken.getUser();

        if (!changePasswordRequest.getEmail().equals(user.getEmail())) {
            throw new InvalidUserEmail("Email is not valid: " + changePasswordRequest.getEmail() + "not found");
        }

        User updateUser = userService.changePassword(user, changePasswordRequest);

        return ResponseEntity.ok(userMapper.toDTO(updateUser));
    }

    @PatchMapping("/user-update")
    public ResponseEntity<UserDTO> updateUser(@RequestBody UserRequest userRequest,
                                              @RequestHeader("Authorization") String tokenHeader) {
        String token = tokenHeader.replace("Bearer ", "");

        Optional<AuthToken> tokenOptional = authTokenRepository.findByToken(token);

        AuthToken authToken = tokenOptional.orElseThrow(() -> new NotFoundAuthToken("Token: " + token + "not found"));

        User user = authToken.getUser();

        return ResponseEntity.ok(userService.updateUser(userRequest, user));
    }

    @PostMapping("/create-user")
    public ResponseEntity<User> addUser(@RequestBody RegRequest registerRequest) {

        if (userRepository.existsByEmail(registerRequest.getEmail()) ||
                userRepository.existsByPhone(registerRequest.getPhone())) {
            RegAnswer regAnswer = new RegAnswer();
            regAnswer.setFieldErrors(Arrays.asList(Map.of("email", registerRequest.getEmail())));
            regAnswer.setFieldErrors(Arrays.asList(Map.of("phone", registerRequest.getPhone())));

            throw new NotValidFieldException("User already exists with email:" + registerRequest.getEmail() + " or phone: " +
                    registerRequest.getPhone(), new BaseResponse(2,
                    MessageCode.REG_EMAIL_OR_PHONE_EXISTS.getCode(),
                    MessageCode.REG_EMAIL_OR_PHONE_EXISTS.getDescription(), regAnswer));
        }

        User user = new User();
        user.setFullName(registerRequest.getFullName());
        user.setEmail(registerRequest.getEmail());
        user.setPassword(passwordEncoder.encode(registerRequest.getPassword()));
        user.setActive(true);
        user.setEmailVerified(true);

        if (registerRequest.getCompanyName() != null) {
            user.setCompany(registerRequest.getCompanyName());
        }

        if (registerRequest.getPhone() != null) {
            user.setPhone(registerRequest.getPhone());
        }

        User savedUser = userRepository.save(user);

        AuthToken authToken = authService.generateAuthToken(savedUser);

        authTokenRepository.save(authToken);

        return ResponseEntity.ok().body(savedUser);
    }

    @DeleteMapping("/delete-user/{userId}")
    public ResponseEntity<?> addUser(@PathVariable Long userId) {
        userRepository.deleteById(userId);
        return ResponseEntity.ok().body(Map.of("userId", userId, "deleted", "true"));
    }

}