package io.delphiplatform.api.v3.bigtable;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Collections;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

import javax.transaction.NotSupportedException;

import io.delphiplatform.api.util.CollectionUtils;
import io.delphiplatform.api.v3.bigtable.processing.PaginationService;
import io.delphiplatform.api.v3.bigtable.processing.PlaylistTrackPositionSummaryAggregator;
import io.delphiplatform.api.v3.bigtable.processing.PlaylistTrackPositionSummarySortingService;
import io.delphiplatform.api.v3.bigtable.processing.TrackPositionConverter;
import io.delphiplatform.api.v3.model.trackposition.PlaylistTrackPositionSummary;
import io.delphiplatform.api.v3.rdb.service.PlaylistManager;
import io.delphiplatform.api.v3.view.util.Params;

@Deprecated
@Service
public class BigtableTrackPositionSummaryService {

    private final PaginationService paginationService;
    private final PlaylistManager playlistManager;
    private final BigtableTrackPositionQueryExecutor trackPositionQueryExecutor;

    private final TrackPositionConverter trackPositionConverter;
    private final PlaylistTrackPositionSummaryAggregator trackPositionSummaryAggregator;
    private final PlaylistTrackPositionSummarySortingService sortingService;

    public BigtableTrackPositionSummaryService(
        PaginationService paginationService,
        PlaylistManager playlistManager,
        BigtableTrackPositionQueryExecutor trackPositionQueryExecutor,
        TrackPositionConverter trackPositionConverter,
        PlaylistTrackPositionSummaryAggregator trackPositionSummaryAggregator,
        PlaylistTrackPositionSummarySortingService sortingService
    ) {
        this.paginationService = paginationService;
        this.playlistManager = playlistManager;
        this.trackPositionQueryExecutor = trackPositionQueryExecutor;
        this.trackPositionConverter = trackPositionConverter;
        this.trackPositionSummaryAggregator = trackPositionSummaryAggregator;
        this.sortingService = sortingService;
    }

    @Transactional(readOnly = true)
    public CompletableFuture<List<PlaylistTrackPositionSummary>> getPlaylistTrackPositionModels(Params params)
        throws NotSupportedException {
        if (CollectionUtils.isNotEmpty(params.getArtistId())
            && CollectionUtils.isEmpty(params.getIsrc())) {
            return CompletableFuture.completedFuture(Collections.emptyList());
        }

        String requestedDsp = CollectionUtils.isEmpty(params.getDsp()) ? null : params.getDsp().get(0);

        return trackPositionQueryExecutor.getAllPlaylistPositions(params)
            .thenApply(trackPositionConverter::convertPlaylistPositions)
            .thenApply(models -> playlistManager.filterPlaylistsByTypes(models, params.getPlaylistTypes()))
            .thenApply(trackPositionSummaryAggregator::groupBy)
            .thenApply(models -> models.peek(m -> m.dsp(requestedDsp)))
            .thenApply(
                models -> sortingService.sortPlaylistPositions(models, params.getSortBy(), params.getSortOrder()))
            .thenApply(models -> paginationService.getPage(models, params))
            .thenApply(models -> models.collect(Collectors.toList()));
    }
}