UserSkillService

package de.ite.onepager.mindmap.service;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.stream.Collectors;

import javax.transaction.Transactional;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import de.ite.onepager.mindmap.common.DateFormatter;
import de.ite.onepager.mindmap.model.Skill;
import de.ite.onepager.mindmap.model.User;
import de.ite.onepager.mindmap.model.UserSkill;
import de.ite.onepager.mindmap.model.education.Certificate;
import de.ite.onepager.mindmap.model.education.Training;
import de.ite.onepager.mindmap.model.requests.CertificateRequest;
import de.ite.onepager.mindmap.model.requests.TrainingRequest;
import de.ite.onepager.mindmap.model.requests.UserSkillRequest;
import de.ite.onepager.mindmap.repository.CertificateRepository;
import de.ite.onepager.mindmap.repository.SkillRepository;
import de.ite.onepager.mindmap.repository.TrainingRepository;
import de.ite.onepager.mindmap.repository.UserRepository;
import de.ite.onepager.mindmap.repository.UserSkillRepository;

@Service
public class UserSkillService {

    @Autowired
    UserSkillRepository userSkillRepository;

    @Autowired
    UserRepository userRepository;

    @Autowired
    SkillRepository skillRepository;

    @Autowired
    CertificateRepository certificateRepository;

    @Autowired
    TrainingRepository trainingRepository;

    public Optional<UserSkillRequest> getUserSkillByUserIdAndSkillId(Long userId, Long skillId) {

        Optional<User> user = userRepository.findById(userId);
        Optional<Skill> skill = skillRepository.findById(skillId);

        if (!user.isPresent() || !skill.isPresent()) {
           return Optional.empty();
        }

        Optional<UserSkill> userSkill = userSkillRepository.findBySkillAndUser(skill.get(), user.get());

        return userSkill.map(this::generateUserSkillsResponse);
    }

    public List<UserSkillRequest> getUserSkillsByEmail(String email) {

        Optional<User> user = userRepository.findByEmail(email);

        if (email == null || email.isEmpty()) {
            throw new IllegalArgumentException();
        }
        if (!user.isPresent()) {
            throw new NoSuchElementException();
        }

        return getUserSkills(user.get().getId());
    }

    public List<UserSkillRequest> getUserSkills(Long userId) {
        List<UserSkill> listUserSkills = new LinkedList<>();

        Optional<User> user = userRepository.findById(userId);

        if (user.isPresent()) {
            listUserSkills = userSkillRepository.findByUser(user.get());
        }

        return generateListUserSkillsResponse(listUserSkills);
    }


    public UserSkill updateUserSkill(UserSkillRequest updateRequest) {
        return this.saveUserSkill(updateRequest);
    }

    // if user skill we attempt to add already exists (by unique key user_id + skill_id), we just update it"
    public UserSkill addUserSkill(UserSkillRequest request) {

        if (request.getUserId() == null || request.getSkillId() == null) {
            throw new IllegalArgumentException();
        }

        Optional<User> user = userRepository.findById(request.getUserId());
        Optional<Skill> skill = skillRepository.findById(request.getSkillId());
        if (!user.isPresent() || !skill.isPresent()) {
            throw new NoSuchElementException();
        }

        Optional<UserSkill> userSkillOptional = userSkillRepository.findBySkillAndUser(skill.get(), user.get());

        if (userSkillOptional.isPresent()) {
            UserSkill updatedUserSkill = userSkillOptional.get();
            updatedUserSkill.setSkillDesireLvl(request.getSkillDesireLvl());
            updatedUserSkill.setSkillLvl(request.getSkillLvl());

            if (!request.getCertificates().isEmpty()) {
                for (CertificateRequest certificate : request.getCertificates()) {
                    certificateRepository.save(getCertificate(certificate, userSkillOptional.get()));
                }
            }

            if (!request.getTrainings().isEmpty()) {
                for (TrainingRequest training : request.getTrainings()) {
                    trainingRepository.save(getTraining(training, userSkillOptional.get()));
                }
            }

            userSkillRepository.save(userSkillOptional.get());
            return updatedUserSkill;
        } else {
            UserSkill userSkillToAdd = new UserSkill(skill.get(), user.get(), request.getSkillLvl(), request.getSkillDesireLvl());

            userSkillRepository.save(userSkillToAdd);
            userSkillRepository.flush();

            if (!request.getCertificates().isEmpty()) {
                for (CertificateRequest certificate : request.getCertificates()) {
                    certificateRepository.save(getCertificate(certificate, userSkillToAdd));
                }
            }

            if (!request.getTrainings().isEmpty()) {
                for (TrainingRequest training : request.getTrainings()) {
                    trainingRepository.save(getTraining(training, userSkillToAdd));
                }
            }

            return userSkillToAdd;
        }
    }

    @Transactional
    private UserSkill saveUserSkill(UserSkillRequest request) {
        Optional<UserSkill> skillToUpdate;

        if (request.getUserId() == null || request.getSkillId() == null) {
            throw new IllegalArgumentException();
        }

        Optional<User> user = userRepository.findById(request.getUserId());
        Optional<Skill> skill = skillRepository.findById(request.getSkillId());

        if (!user.isPresent() || !skill.isPresent()) {
            throw new NoSuchElementException();
        }

        skillToUpdate = userSkillRepository.findBySkillAndUser(skill.get(), user.get());

        if (!skillToUpdate.isPresent()) {
            throw new IllegalArgumentException(); // UserSkill does not exist
        }
        skillToUpdate = userSkillRepository.findById(skillToUpdate.get().getId());
        skillToUpdate.get().setSkillLvl(request.getSkillLvl());
        skillToUpdate.get().setSkillDesireLvl(request.getSkillDesireLvl());

        addCertificatesToRepositoryIfAny(request, skillToUpdate);
        addTrainingsToRepositoryIfAny(request, skillToUpdate);

        userSkillRepository.save(skillToUpdate.get());
        userSkillRepository.flush();

        //ADDING THE NEW CERTIFICATES AND TRAININGS
        if (!request.getCertificates().isEmpty()) {
            for (CertificateRequest certificateRequest : request.getCertificates()) {
                Certificate newCertificate = getCertificate(certificateRequest, skillToUpdate.get());
                certificateRepository.save(newCertificate);
            }
            certificateRepository.flush();
        }

        if (!request.getTrainings().isEmpty()) {
            for (TrainingRequest trainingRequest : request.getTrainings()) {
                Training newTraining = getTraining(trainingRequest, skillToUpdate.get());
                trainingRepository.save(newTraining);
            }
            trainingRepository.flush();
        }

        return skillToUpdate.get();
    }

    private void addTrainingsToRepositoryIfAny(UserSkillRequest request, Optional<UserSkill> skillToUpdate) {
        if (!skillToUpdate.get().getTrainings().isEmpty()) {

            List<Training> intersaction = skillToUpdate.get().getTrainings().stream()
                    .filter(os -> request.getCertificates().stream()                    // filter
                            .anyMatch(ns ->                                             // compare both
                                    os.getId() == ns.getId()))                          // id
                    .collect(Collectors.toList());

            Iterator<Training> iterator = skillToUpdate.get().getTrainings().iterator();

            while (iterator.hasNext()) {
                Training training = iterator.next();

                Training certificateFormIntersaction = intersaction.stream()
                        .filter(certif -> certif.getId() == training.getId())
                        .findFirst()
                        .orElse(null);
                if (null == certificateFormIntersaction) {
                    trainingRepository.deleteById(training.getId());
                    iterator.remove();
                } else {
                    training.setName(certificateFormIntersaction.getName());
                    training.setDescription(certificateFormIntersaction.getDescription());
                    training.setExpiryDate(certificateFormIntersaction.getExpiryDate());
                    training.setCreationDate(certificateFormIntersaction.getExpiryDate());
                    training.setUserSkill(certificateFormIntersaction.getUserSkill());

                    trainingRepository.save(training);
                    request.getCertificates().removeIf(e -> e.getId() == training.getId());
                }
                trainingRepository.flush();
            }
        }
    }

    private void addCertificatesToRepositoryIfAny(UserSkillRequest request, Optional<UserSkill> skillToUpdate) {
        if (skillToUpdate.isPresent()) {

            if (!skillToUpdate.get().getCertificates().isEmpty()) {

                List<Certificate> intersaction = skillToUpdate.get().getCertificates().stream()
                        .filter(os -> request.getCertificates().stream()                    // filter
                                .anyMatch(ns ->                                             // compare both
                                        os.getId() == ns.getId()))                          // id
                        .collect(Collectors.toList());

                Iterator<Certificate> iterator = skillToUpdate.get().getCertificates().iterator();
                while (iterator.hasNext()) {
                    Certificate cert = iterator.next();
                    Certificate certificateFormIntersaction = intersaction.stream()
                            .filter(certif -> certif.getId() == cert.getId())
                            .findFirst()
                            .orElse(null);
                    if (null == certificateFormIntersaction) {
                        certificateRepository.delete(cert);
                        iterator.remove();
                    } else {
                        Certificate certi = certificateRepository.findById(cert.getId()).get();

                        certi.setName(certificateFormIntersaction.getName());
                        certi.setDescription(certificateFormIntersaction.getDescription());
                        certi.setExpiryDate(certificateFormIntersaction.getExpiryDate());
                        certi.setCreationDate(certificateFormIntersaction.getExpiryDate());
                        certi.setUserSkill(certificateFormIntersaction.getUserSkill());

                        certificateRepository.save(certi);
                        request.getCertificates().removeIf(e -> e.getId() == certi.getId());
                    }
                    certificateRepository.flush();
                }
            }
        }
    }

    private Certificate getCertificate(CertificateRequest certificate, UserSkill userSkill) {

        Certificate currCert = new Certificate();

        currCert.setUserSkill(userSkill);
        currCert.setCreationDate(DateFormatter.getDate(certificate.getCreationDate()));
        currCert.setExpiryDate(DateFormatter.getDate(certificate.getExpiryDate()));
        currCert.setDescription(certificate.getDescription());
        currCert.setName(certificate.getName());

        return currCert;
    }

    private Training getTraining(TrainingRequest training, UserSkill userSkill) {

        Training currTraining = new Training();

        currTraining.setUserSkill(userSkill);
        currTraining.setCreationDate(DateFormatter.getDate(training.getCreationDate()));
        currTraining.setExpiryDate(DateFormatter.getDate(training.getExpiryDate()));
        currTraining.setDescription(training.getDescription());
        currTraining.setName(training.getName());

        return currTraining;
    }

    private CertificateRequest getCertificateRequest(Certificate certificate) {

        CertificateRequest result = new CertificateRequest();

        result.setId(certificate.getId());
        result.setUserSkillId(certificate.getUserSkill().getId());
        result.setCreationDate(DateFormatter.getStringDate(certificate.getCreationDate()));
        result.setExpiryDate(DateFormatter.getStringDate(certificate.getExpiryDate()));
        result.setDescription(certificate.getDescription());
        result.setName(certificate.getName());

        return result;
    }

    private TrainingRequest getTrainingRequest(Training training) {

        TrainingRequest result = new TrainingRequest();

        result.setId(training.getId());
        result.setUserSkillId(training.getUserSkill().getId());
        result.setCreationDate(DateFormatter.getStringDate(training.getCreationDate()));
        result.setExpiryDate(DateFormatter.getStringDate(training.getExpiryDate()));
        result.setDescription(training.getDescription());
        result.setName(training.getName());

        return result;
    }

    private List<UserSkillRequest> generateListUserSkillsResponse(List<UserSkill> userSkills) {

        List<UserSkillRequest> result = new LinkedList<>();

        for (UserSkill userSkill : userSkills) {
            result.add(generateUserSkillsResponse(userSkill));
        }

        return result;
    }

    private UserSkillRequest generateUserSkillsResponse(UserSkill userSkill) {

        List<CertificateRequest> certificateRequests = new ArrayList<>();

        for (Certificate certificate : userSkill.getCertificates()) {
            certificateRequests.add(getCertificateRequest(certificate));
        }

        List<TrainingRequest> trainingRequests = new ArrayList<>();

        for (Training training : userSkill.getTrainings()) {
            trainingRequests.add(getTrainingRequest(training));
        }

        return new UserSkillRequest(userSkill.getId(), userSkill.getUser().getId(), userSkill.getSkill().getId(),
                userSkill.getSkillLvl(), userSkill.getSkillDesireLvl(), certificateRequests, trainingRequests);
    }
}