no-copy/src/main/java/ru/soune/nocopy/service/violation/ViolationService.java

package ru.soune.nocopy.service.violation;

import lombok.AllArgsConstructor;
import org.apache.commons.codec.digest.DigestUtils;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;
import ru.soune.nocopy.dto.file.YandexSearchResponse;
import ru.soune.nocopy.entity.file.FileEntity;
import ru.soune.nocopy.entity.search.GlobalSearchResult;
import ru.soune.nocopy.entity.violation.Violation;
import ru.soune.nocopy.exception.ViolationNotFoundException;
import ru.soune.nocopy.repository.ViolationRepository;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Service
@AllArgsConstructor
public class ViolationService {

    private final ViolationRepository violationRepository;

    public void processViolation(YandexSearchResponse.ImageResult imageResult, FileEntity file,
                                 GlobalSearchResult result) {
        String url = imageResult.getUrl();
        String urlHash = DigestUtils.sha256Hex(url);

        if (!violationRepository.existsByUrlHash(urlHash)) {
            Violation violation = new Violation();

            if (result != null) {
                violation.setGlobalSearchResult(result);
            }

            violation.setHost(imageResult.getHost());
            violation.setUrl(url);
            violation.setUrlHash(urlHash);
            violation.setPageUrl(imageResult.getPageUrl());
            violation.setPageTitle(imageResult.getPageTitle());
            violation.setFileEntity(file);
            violation.setStatus("CREATED");

            violationRepository.save(violation);
        }
    }

    public List<Violation> violationsByFileId(FileEntity file) {
        return violationRepository.findByFileEntity(file);
    }

    public void changeStatusViolation(Long violationId, String status) {
        Violation violation = violationRepository.findById(violationId)
                .orElseThrow(() -> new ViolationNotFoundException("Violation not found with id: " + violationId));
        violation.setStatus(status);
        violationRepository.save(violation);
    }

    public Page<Violation> getViolationsByFile(FileEntity file, int page, int size, String sortDirection) {
        Sort sort = Sort.by(sortDirection.equalsIgnoreCase("desc") ? Sort.Direction.DESC : Sort.Direction.ASC, "createdDate");
        Pageable pageable = PageRequest.of(page, size, sort);
        return violationRepository.findByFileEntity(file, pageable);
    }

    public Page<Violation> getViolationsByFileAndStatus(FileEntity file, String status, int page, int size, String sortDirection) {
        Sort sort = Sort.by(sortDirection.equalsIgnoreCase("desc") ? Sort.Direction.DESC : Sort.Direction.ASC, "createdDate");
        Pageable pageable = PageRequest.of(page, size, sort);
        return violationRepository.findByFileEntityAndStatus(file, status, pageable);
    }

    public Page<Violation> getViolationsByFileAndDateRange(FileEntity file, LocalDateTime startDate, LocalDateTime endDate,
                                                           int page, int size, String sortDirection) {
        Sort sort = Sort.by(sortDirection.equalsIgnoreCase("desc") ? Sort.Direction.DESC : Sort.Direction.ASC, "createdDate");
        Pageable pageable = PageRequest.of(page, size, sort);
        return violationRepository.findByFileEntityAndCreatedDateBetween(file, startDate, endDate, pageable);
    }

    public Map<String, Long> getGroupedViolations(FileEntity file, String groupBy, String status,
                                                  LocalDateTime startDate, LocalDateTime endDate) {

        List<Violation> violations;

        if (status != null && !status.isEmpty() && startDate != null && endDate != null) {
            violations = violationRepository.findByFileEntityAndStatusAndCreatedDateBetween(file, status, startDate, endDate);
        } else if (status != null && !status.isEmpty()) {
            violations = violationRepository.findByFileEntityAndStatus(file, status);
        } else if (startDate != null && endDate != null) {
            violations = violationRepository.findByFileEntityAndCreatedDateBetween(file, startDate, endDate);
        } else {
            violations = violationRepository.findByFileEntity(file);
        }

        return violations.stream()
                .collect(Collectors.groupingBy(
                        v -> extractGroupKey(v.getPageUrl(), groupBy),
                        Collectors.counting()
                ));
    }

    private String extractGroupKey(String url, String groupBy) {
        try {
            String domain = url.replaceAll("https?://(www\\.)?", "").split("/")[0];
            if ("tld".equalsIgnoreCase(groupBy)) {
                int lastDot = domain.lastIndexOf('.');
                return lastDot > 0 ? domain.substring(lastDot + 1) : domain;
            }
            return domain;
        } catch (Exception e) {
            return "unknown";
        }
    }
}