package ru.soune.nocopy.service.search;

import com.fasterxml.jackson.core.JsonProcessingException;
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.dto.file.YandexSearchResponse;
import ru.soune.nocopy.entity.file.FileEntity;
import ru.soune.nocopy.exception.NotValidFieldException;

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;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@Slf4j
@Service
public class YandexSearchService {

    private final ObjectMapper objectMapper;

    private final OkHttpClient httpClient;

    public YandexSearchService() {
        this.httpClient = new OkHttpClient.Builder()
                .connectTimeout(30, TimeUnit.SECONDS)
                .readTimeout(120, TimeUnit.SECONDS)
                .writeTimeout(30, TimeUnit.SECONDS)
                .callTimeout(180, 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 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 String callReverseImageApiByUrl(String imageUrl) throws IOException {
//        if (searchApiKey == null || searchApiKey.isEmpty()) {
//            throw new IllegalStateException("SearchAPI key not configured. Set searchapi.api-key property");
//        }
//
//        if (imageUrl == null || imageUrl.trim().isEmpty()) {
//            throw new IllegalArgumentException("Image URL cannot be null or empty");
//        }
//
//        HttpUrl url = HttpUrl.parse("https://searchapi.io/api/v1/search")
//                .newBuilder()
//                .addQueryParameter("engine", "yandex_reverse_image")
//                .addQueryParameter("api_key", searchApiKey)
//                .addQueryParameter("url", imageUrl)
//                .addQueryParameter("wait", "true")
//                .addQueryParameter("timeout", "30000")
//                .build();
//
//        log.info("Calling Yandex Reverse Image API for URL: {}", imageUrl);
//        log.debug("Full API URL: {}", url);
//
//        Request request = new Request.Builder()
//                .url(url)
//                .header("Accept", "application/json")
//                .header("User-Agent", "Mozilla/5.0 (compatible; YourApp/1.0)")
//                .header("Accept-Encoding", "gzip")
//                .build();
//
//        try (Response response = httpClient.newCall(request).execute()) {
//            ResponseBody responseBody = response.body();
//
//            log.info("Response code: {}", response.code());
//            log.debug("Response headers: {}", response.headers());
//
//            if (!response.isSuccessful()) {
//                String errorBody = responseBody != null ? responseBody.string() : "No error body";
//                log.error("API request failed: {} - {}", response.code(), errorBody);
//                throw new IOException("API request failed: " + response.code() + " - " + response.message());
//            }
//
//            if (responseBody == null) {
//                log.error("Response body is null for successful request");
//                throw new IOException("Response body is null");
//            }
//
//            String responseContent = responseBody.string();
//            log.info("Response body length: {} characters", responseContent.length());
//
//            if (log.isDebugEnabled() && responseContent.length() > 0) {
//                log.debug("Response body (first 500 chars): {}",
//                        responseContent.substring(0, Math.min(responseContent.length(), 500)));
//            }
//
//            return responseContent;
//        } catch (IOException e) {
//            log.error("Failed to call Yandex Reverse Image API for URL: {}", imageUrl, e);
//            throw e;
//        }
//    }

    private String callReverseImageApiByUrl(String imageUrl) throws IOException {
        if (searchApiKey == null || searchApiKey.isEmpty()) {
            throw new IllegalStateException("SearchAPI key not configured. Set searchapi.api-key property");
        }

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

        log.info("Calling Yandex Reverse Image API: {}", url);

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

        try (Response response = httpClient.newCall(request).execute()) {
            log.info("Response code: {}", response.code());
            log.info("Response headers: {}", response.headers());

            if (!response.isSuccessful()) {
                String errorBody = response.body() != null ? response.body().string() : "No error body";
                log.error("API request failed: {} - {}", response.code(), errorBody);
                throw new IOException("API request failed: " + response.code() + " - " + response.message());
            }

            String responseBody = response.body().string();
            log.info("Response body length: {} characters", responseBody.length());

            return responseBody;
        }
    }


    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.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;
    }
}