package eu.eudat.migration.services;

import eu.eudat.data.entities.UserInfo;
import eu.eudat.migration.dao.TemplateRepository;
import eu.eudat.migration.dao.UserRepository;
import eu.eudat.migration.entities.Perm;
import eu.eudat.migration.entities.Plan;
import eu.eudat.migration.entities.Template;
import eu.eudat.migration.entities.User;
import eu.eudat.migration.properties.ConfigProperties;
import eu.eudat.migration.properties.DefaultEntities;
import eu.eudat.models.data.admin.composite.DatasetProfile;
import eu.eudat.models.data.datasetwizard.DatasetWizardModel;
import eu.eudat.models.data.dmp.DataManagementPlan;
import eu.eudat.models.data.dmp.DataManagementPlanEditorModel;
import eu.eudat.models.data.listingmodels.UserInfoListingModel;
import eu.eudat.models.data.security.Principal;
import eu.eudat.types.Authorities;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@Service
public class DMPRoadmapService {

    private static final Logger logger = LoggerFactory.getLogger(DMPRoadmapService.class);

    /**
     * DMPRoadmap Repositories
     */
    private final TemplateRepository templateRepository;
    private final UserRepository userRepository;
    /**
     * Default Entities
     */
    private final DefaultEntities defaultEntities;
    /**
     * Services
     */
    private final ArgosService argosService;
    /**
     * Metadata
     */
    private final List<UUID> datasetProfiles = new ArrayList<>();
    private final List<UUID> dmps = new ArrayList<>();
    private final List<UUID> datasets = new ArrayList<>();
    private Principal principal;

    @Autowired
    public DMPRoadmapService(TemplateRepository templateRepository, UserRepository userRepository, ArgosService argosService, ConfigProperties properties) {
        this.templateRepository = templateRepository;
        this.userRepository = userRepository;
        this.defaultEntities = properties.getEntities();
        this.argosService = argosService;
    }

    public void migrateUsers() {
        this.argosService.createUserInfo(Objects.requireNonNull(defaultUser()));
        List<User> users = this.userRepository.findAll();
        users.forEach(user -> {
            logger.info("Create user with email: " + user.getEmail());
            this.argosService.createUserInfo(user.buildUserInfo());
        });
    }

    public void migrate() {
        try {
            List<UserInfo> users = this.userRepository.findAll().stream().filter(user ->
                    user.getPerms().stream().map(Perm::getName).collect(Collectors.toList()).contains("modify_templates")).map(user ->
                    this.argosService.getUserInfo(user.getEmail())
            ).collect(Collectors.toList());
            UserInfo userInfo = this.argosService.getUserInfo(users.size() > 0 ? users.get(0).getEmail() : defaultEntities.getUser().getEmail());
            for (Long group : templateRepository.findAllGroups()) {
                List<Template> templates = templateRepository.findAllByFamilyId(group, Sort.by(Sort.Direction.ASC, "version"));
                UUID id = null;
                for (Template template : templates) {
                    this.argosService.assignRole(userInfo, Authorities.DATASET_PROFILE_MANAGER);
                    this.principal = this.argosService.login(userInfo);
                    DatasetProfile datasetProfile = template.buildDatasetProfile();
                    if (id == null) {
                        if (users.size() > 1) {
                            datasetProfile.setUsers(users.subList(1, users.size()).stream().map(info -> {
                                UserInfoListingModel model = new UserInfoListingModel();
                                model.setId(info.getId());
                                return model;
                            }).collect(Collectors.toList()));
                        }
                        logger.info("Create Dataset Profile with label: " + datasetProfile.getLabel());
                        id = this.argosService.createDatasetProfile(datasetProfile, principal);
                    } else {
                        if (users.size() > 0) {
                            datasetProfile.setUsers(users.stream().map(info -> {
                                UserInfoListingModel model = new UserInfoListingModel();
                                model.setId(info.getId());
                                return model;
                            }).collect(Collectors.toList()));
                        } else {
                            datasetProfile.setUsers(Stream.of(userInfo).map(info -> {
                                UserInfoListingModel model = new UserInfoListingModel();
                                model.setId(info.getId());
                                return model;
                            }).collect(Collectors.toList()));
                        }
                        logger.info("Create a new version of Dataset Profiles with label: " + datasetProfile.getLabel());
                        id = this.argosService.createNewVersionDatasetProfile(id, datasetProfile);
                    }
                    this.datasetProfiles.add(id);
                    for (Plan plan : template.getPlans()) {
                        DataManagementPlanEditorModel dataManagementPlanEditorModel = plan.buildDMP(id, datasetProfile.getLabel(), defaultEntities.getFunder(), defaultEntities.getGrant());
                        List<UserInfo> collaborators = plan.getUsers().stream().map(user -> this.argosService.getUserInfo(user.getEmail())).collect(Collectors.toList());
                        Principal principal = this.principal;
                        if (collaborators.size() > 0) {
                            principal = this.argosService.login(collaborators.get(0));
                        }
                        logger.info("Create DMP and its Dataset with label: " + dataManagementPlanEditorModel.getLabel());
                        DataManagementPlan dmp = this.argosService.createDMP(dataManagementPlanEditorModel, principal);
                        this.dmps.add(dmp.getId());
                        if (collaborators.size() > 1) {
                            List<UserInfoListingModel> modelList = collaborators.subList(1, collaborators.size()).stream().map(user -> {
                                UserInfoListingModel model = new UserInfoListingModel();
                                model.setId(user.getId());
                                return model;
                            }).collect(Collectors.toList());
                            this.argosService.updateUsers(dmp.getId(), modelList, principal);
                        }
                        DatasetWizardModel dataset = plan.buildDataset(id, datasetProfile.getLabel(), dmp, this.argosService.getDataset(id));
                        dataset = this.argosService.createDataset(dataset, principal);
                        this.datasets.add(dataset.getId());
                    }
                }
            }
        } catch (Exception e) {
            logger.error("Migration Failed. All data will be deleted.");
            this.clear();
        }
    }

    public void clear() {
        logger.info("Deleting Datasets");
        this.datasets.forEach(id -> this.argosService.deleteDataset(id, this.principal));
        logger.info("Deleting DMPs");
        this.dmps.forEach(this.argosService::deleteDMP);
        logger.info("Deleting Dataset Profiles");
        this.datasetProfiles.forEach(this.argosService::deleteDatasetProfile);
    }

    private UserInfo defaultUser() {
        eu.eudat.migration.properties.User user = defaultEntities.getUser();
        if (user != null && user.getEmail() != null && user.getName() != null) {
            UserInfo userInfo = new UserInfo();
            userInfo.setEmail(user.getEmail());
            userInfo.setName(user.getName());
            userInfo.setUsertype((short) 0);
            userInfo.setUserStatus((short) 0);
            userInfo.setAuthorization_level((short) 1);
            userInfo.setVerified_email(false);
            userInfo.setCreated(new Date());
            return userInfo;
        }
        return null;
    }
}