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

package ru.soune.nocopy.service.search;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.DeserializationFeature;
import jakarta.annotation.PostConstruct;
import lombok.extern.slf4j.Slf4j;
import okhttp3.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import ru.soune.nocopy.dto.BaseResponse;
import ru.soune.nocopy.dto.MessageCode;
import ru.soune.nocopy.entity.file.FileEntity;
import ru.soune.nocopy.exception.NotValidFieldException;

import java.io.*;
import java.net.SocketTimeoutException;
import java.util.Map;
import java.util.concurrent.*;

@Slf4j
@Service
public class SearchImageService {

    private final ObjectMapper objectMapper;

    private final OkHttpClient httpClient;

    public SearchImageService() {
        this.httpClient = new OkHttpClient.Builder()
                .connectTimeout(5, TimeUnit.SECONDS)
                .writeTimeout(5, TimeUnit.SECONDS)
                .readTimeout(15, TimeUnit.SECONDS)
                .callTimeout(20, TimeUnit.SECONDS)
                .retryOnConnectionFailure(true)
                .build();

        this.objectMapper = new ObjectMapper();
    }

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

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

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

    @Value("${searchapi.api-key:}")
    private String searchApiKey;

    @Value("${server.baseurl}")
    private String appBaseUrl;

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

    public String searchReverseByPublicUrl(FileEntity fileEntity, String engine, String searchType)
            throws IOException, TimeoutException {

        if (!isImageFile(fileEntity)) {
            throw new NotValidFieldException(
                    "File not image",
                    new BaseResponse(
                            20007,
                            MessageCode.INVALID_FIELD.getCode(),
                            MessageCode.INVALID_FIELD.getDescription(),
                            Map.of("file_type", fileEntity.getMimeType())
                    )
            );
        }

        String publicUrl = String.format("%s/api/files/public/%s", appBaseUrl, fileEntity.getId());

        log.info("Searching reverse for image: {}", publicUrl);

        try {
            return callReverseImageApiByUrl(publicUrl, engine, searchType);
        } catch (SocketTimeoutException e) {
            log.error("Yandex search timeout after {}", fileEntity.getId());
            throw new TimeoutException("Search timeout");
        }
    }

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

    private String callReverseImageApiByUrl(String imageUrl, String engine, String searchType) throws IOException {

        if (searchApiKey == null || searchApiKey.isBlank()) {
            throw new IllegalStateException("SearchAPI key not configured");
        }

        HttpUrl url = HttpUrl.parse("https://searchapi.io/api/v1/search")
                .newBuilder()
                .addQueryParameter("engine", engine)
                .addQueryParameter("api_key", searchApiKey)
                .addQueryParameter("url", imageUrl)
//                .addQueryParameter("search_type", "visual_matches")
                .addQueryParameter("search_type", searchType)
                .addQueryParameter("wait", "true")
                .build();

        Request request = new Request.Builder()
                .url(url)
                .header("Accept", "application/json")
                .header("User-Agent", "Mozilla/5.0")
                .build();

        long start = System.currentTimeMillis();

        try (Response response = httpClient.newCall(request).execute()) {

            long duration = System.currentTimeMillis() - start;
            log.info("Yandex response code={}, duration={}ms", response.code(), duration);

            if (!response.isSuccessful()) {
                throw new IOException("API error: " + response.code());
            }

            ResponseBody body = response.body();
            if (body == null) {
                throw new IOException("Empty response body");
            }

            return body.string();
        }
    }

//    public YandexSearchResponse searchByFileEntity(FileEntity fileEntity) throws IOException {
//        byte[] fileBytes;
//
//        if (!isImageFile(fileEntity)) {
//            log.error("File not image: {}", fileEntity.getMimeType());
//            throw new NotValidFieldException("File not image", new BaseResponse(20007,
//                    MessageCode.INVALID_FIELD.getCode(), MessageCode.INVALID_FIELD.getDescription(),
//                    Map.of("file_type", fileEntity.getMimeType())));
//        }
//
//        try {
//            fileBytes = readFileFromDisk(fileEntity);
//        } catch (IOException e) {
//            throw new NotValidFieldException("File not found or cannot read file", new BaseResponse(20007,
//                    MessageCode.FILE_NOT_FOUND.getCode(), MessageCode.FILE_NOT_FOUND.getDescription(),
//                    Map.of("fileId", fileEntity.getId(),
//                            "filePath", fileEntity.getFilePath())));
//        }
//
//        return callYandexApi(fileBytes);
//    }


//    public String searchReverseByPublicUrl(FileEntity fileEntity) throws IOException {
//        if (!isImageFile(fileEntity)) {
//            log.error("File not image: {}", fileEntity.getMimeType());
//            throw new NotValidFieldException("File not image", new BaseResponse(20007,
//                    MessageCode.INVALID_FIELD.getCode(), MessageCode.INVALID_FIELD.getDescription(),
//                    Map.of("file_type", fileEntity.getMimeType())));
//        }
//
//         String publicUrl = String.format("%s/api/files/public/%s", appBaseUrl, fileEntity.getId());
//
//        log.info("Searching reverse for image: {}", publicUrl);
//
//        return callReverseImageApiByUrl(publicUrl);
//    }

//    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.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("Error 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;
//    }
}