package com.backend.unifier.title.service;

import java.util.List;

import org.mapstruct.factory.Mappers;

import com.backend.metadata.kodik.api.model.KodikResponse;
import com.backend.unifier.title.mapper.KodikResponseMapper;
import com.backend.unifier.title.model.SearchEntryDTO;
import com.backend.unifier.title.model.SearchResponseDTO;

import io.smallrye.mutiny.Uni;
import jakarta.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class KodikResponseConvertService {

    private final KodikResponseMapper responseMapper = Mappers.getMapper(KodikResponseMapper.class);
    private final PosterUrlValidator posterUrlValidator;
    private final PosterUrlNormalizer posterUrlNormalizer;

    public KodikResponseConvertService(PosterUrlValidator posterUrlValidator, PosterUrlNormalizer posterUrlNormalizer) {
        this.posterUrlValidator = posterUrlValidator;
        this.posterUrlNormalizer = posterUrlNormalizer;
    }

    public SearchResponseDTO convert(KodikResponse response) {
        return convertSimple(response);
    }

    @SuppressWarnings("unchecked")
    public Uni<SearchResponseDTO> convertAsync(KodikResponse response) {
        if (response == null || response.results == null) {
            return Uni.createFrom().item(new SearchResponseDTO(List.of()));
        }

        List<Uni<SearchEntryDTO>> entries = convertSimple(response).result()
                .stream()
                .map(this::resolveEntryPosters)
                .toList();

        if (entries.isEmpty()) {
            return Uni.createFrom().item(new SearchResponseDTO(List.of()));
        }

        return Uni.combine().all().unis(entries)
                .with(list -> new SearchResponseDTO((List<SearchEntryDTO>) list));
    }

    private Uni<SearchEntryDTO> resolveEntryPosters(SearchEntryDTO entry) {
        return posterUrlValidator.resolvePosters(entry.posterURLs())
                .map(entry::withPosterURLs)
                .onFailure().recoverWithItem(entry);
    }

    private SearchResponseDTO convertSimple(KodikResponse response) {
        return normalizeUrls(responseMapper.toSearchResponseDTO(response));
    }

    private SearchResponseDTO normalizeUrls(SearchResponseDTO response) {
        var normalizedResults = response.result().stream()
                .map(r -> r.withPosterURLs(r.posterURLs().stream()
                        .map(posterUrlNormalizer::normalize)
                        .toList()))
                .toList();
        return response.withResult(normalizedResults);
    }
}