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

package ru.soune.nocopy.service;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.DeserializationFeature;
import jakarta.annotation.PostConstruct;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import ru.soune.nocopy.dto.file.YandexSearchResponse;
import ru.soune.nocopy.entity.file.FileEntity;
import ru.soune.nocopy.repository.FileEntityRepository;

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Base64;

@Slf4j
@Service
@RequiredArgsConstructor
public class YandexSearchService {

    private final FileEntityRepository fileEntityRepository;
    private final ObjectMapper objectMapper;

    @Value("${yandex.api-key}")
    private String apiKey;

    @Value("${yandex.folder-id}")
    private String folderId;

    @Value("${yandex.search-url}")
    private String searchUrl;

    @PostConstruct
    public void init() {
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
    }

    public YandexSearchResponse searchByFileEntity(String fileId) throws IOException {
        FileEntity fileEntity = fileEntityRepository.findById(fileId)
                .orElseThrow(() -> {
                    log.error("File not found: {}", fileId);
                    return new RuntimeException("ФFile not found: " + fileId);
                });


        if (!isImageFile(fileEntity)) {
            log.error("File not image: {}", fileEntity.getMimeType());
            throw new RuntimeException("File not image: " + fileId);
        }

        byte[] fileBytes = readFileFromDisk(fileEntity);
        log.info("Прочитано {} байт с диска", fileBytes.length);

        return callYandexApi(fileBytes);
    }

    private boolean isImageFile(FileEntity fileEntity) {
        String mimeType = fileEntity.getMimeType();
        return mimeType != null && mimeType.startsWith("image");
    }

    private byte[] readFileFromDisk(FileEntity fileEntity) throws IOException {
        Path filePath = Path.of(fileEntity.getFilePath());

        if (!Files.exists(filePath)) {
            throw new IOException("File not found: " + fileEntity.getFilePath());
        }

        if (!Files.isReadable(filePath)) {
            throw new IOException("Cannot read file: " + fileEntity.getFilePath());
        }

        return Files.readAllBytes(filePath);
    }

    private YandexSearchResponse callYandexApi(byte[] imageBytes) throws IOException {
        String imageBase64 = Base64.getEncoder().encodeToString(imageBytes);
        String jsonRequest = String.format("{\"folderId\":\"%s\",\"data\":\"%s\",\"page\":0,\"showSimilarImages\":true}",
                folderId, imageBase64);

        URL url = new URL(searchUrl);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();

        try {
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Authorization", "Api-Key " + apiKey);
            connection.setRequestProperty("Content-Type", "application/json");
            connection.setRequestProperty("Accept", "application/json");
            connection.setRequestProperty("User-Agent", "Mozilla/5.0");
            connection.setConnectTimeout(30000);
            connection.setReadTimeout(30000);
            connection.setDoOutput(true);

            try (OutputStream os = connection.getOutputStream()) {
                byte[] input = jsonRequest.getBytes("utf-8");
                os.write(input, 0, input.length);
                os.flush();
            }

            int responseCode = connection.getResponseCode();

            String responseBody;
            if (responseCode == HttpURLConnection.HTTP_OK) {
                try (BufferedReader br = new BufferedReader(
                        new InputStreamReader(connection.getInputStream(), "utf-8"))) {
                    responseBody = readAll(br);
                }
            } else {
                try (BufferedReader br = new BufferedReader(
                        new InputStreamReader(connection.getErrorStream(), "utf-8"))) {
                    responseBody = readAll(br);
                }
                throw new IOException("Ошибка Yandex API: " + responseCode + " - " + responseBody);
            }

            return parseJsonResponse(responseBody);

        } finally {
            connection.disconnect();
        }
    }

    private String readAll(BufferedReader reader) throws IOException {
        StringBuilder sb = new StringBuilder();
        String line;
        while ((line = reader.readLine()) != null) {
            sb.append(line);
        }
        return sb.toString();
    }

    private YandexSearchResponse parseJsonResponse(String json) {
        YandexSearchResponse response = null;
        try {
            response = objectMapper.readValue(json, YandexSearchResponse.class);
        } catch (JsonProcessingException e) {
                throw new RuntimeException(e);
        }

        return response;
    }
}