package eu.dnetlib.repo.manager.service;

import eu.dnetlib.repo.manager.domain.*;
import eu.dnetlib.repo.manager.domain.dto.User;
import eu.dnetlib.repo.manager.exception.ResourceConflictException;
import eu.dnetlib.repo.manager.exception.ResourceNotFoundException;
import eu.dnetlib.repo.manager.repository.InterfaceComplianceRequestsRepository;
import eu.dnetlib.repo.manager.service.security.AuthorizationService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

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

@Service
public class InterfaceComplianceService {

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


    private final InterfaceComplianceRequestsRepository repository;
    private final EmailUtils emailUtils;
    private final AuthorizationService authorizationService;
    private final RepositoryService repositoryService;

    public InterfaceComplianceService(InterfaceComplianceRequestsRepository repository,
                                      EmailUtils emailUtils,
                                      AuthorizationService authorizationService,
                                      RepositoryService repositoryService) {
        this.repository = repository;
        this.emailUtils = emailUtils;
        this.authorizationService = authorizationService;
        this.repositoryService = repositoryService;
    }


    @Scheduled(cron = "0 0 0 * * *") // every day at 00:00
    public void cleanUp() {
        Set<InterfaceComplianceRequest> requests = getOutdated();
        for (InterfaceComplianceRequest request : requests) {
            try {
                Map<String, RepositoryInterface> repositoryInterfaceMap = repositoryService.getRepositoryInterface(request.getRepositoryId())
                        .stream()
                        .collect(Collectors.toMap(ApiDetails::getId, i -> i));
                Repository repo = repositoryService.getRepositoryById(request.getRepositoryId());
                RepositoryInterface iFace = repositoryInterfaceMap.get(request.getInterfaceId());
                List<User> repositoryAdmins = authorizationService.getAdminsOfRepo(request.getRepositoryId());
                emailUtils.sendUserUpdateInterfaceComplianceFailure(repositoryAdmins.stream().map(User::getEmail).collect(Collectors.toList()), repo, iFace, request);
                emailUtils.sendAdminUpdateInterfaceComplianceFailure(repo, iFace, request);
            } catch (ResourceNotFoundException e) {
                logger.error("Error", e);
            }
        }
        repository.deleteAll(requests);
    }

    private Set<InterfaceComplianceRequest> getOutdated() {
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DATE, -7);    // 7-days-old
        return this.repository.findAllBySubmissionDateBefore(calendar.getTime());
    }

    public Optional<InterfaceComplianceRequest> getById(InterfaceComplianceRequestId id) {
        return this.repository.findById(id);
    }

    public Iterable<InterfaceComplianceRequest> get() {
        return this.repository.findAll();
    }

    public InterfaceComplianceRequest create(InterfaceComplianceRequest request) {
        Optional<InterfaceComplianceRequest> existing = getById(request.getId());
        if (existing.isPresent()) {
            logger.warn("New Request: {}\nExisting request: {}", request, existing.get());
            throw new ResourceConflictException("A request for altering compliance already exists. Desired Compatibility value: " + existing.get().getDesiredCompatibilityLevel());
        }

        return this.repository.save(request);
    }

    public void delete(InterfaceComplianceRequestId id) {
        this.repository.deleteById(id);
    }
}