from typing import Optional, List

from external_api.base.clients.apollo_client import ApolloClient, SearchType
from external_api.base.clients.delphi_client import DelphiClient
from external_api.base.clients.client_factory import ApiClientFactory
from external_api.base.search_models import ApolloSearchResponse, Track, Album
from external_api.tracks_search.responses import SearchResults, SearchMediaItem
from external_api.tracks_search.schemas import DelphiTrackSearchQueryParams

DEFAULT_APOLLO_SEARCH_LIMIT = 10


def map_track(track: Track) -> SearchMediaItem:
    return SearchMediaItem(
        type="track",
        apollo_id=track.id,
        title=track.name,
        artist=track.album.artists[0].name if len(track.album.artists) > 0 else None,
        external_id=track.external_ids.isrc,
        cover_url=track.album.images[0].url if len(track.album.images) > 0 else None,
    )


def map_album(album: Album) -> SearchMediaItem:
    return SearchMediaItem(
        type="album",
        apollo_id=album.id,
        title=album.name,
        artist=album.artists[0].name if len(album.artists) > 0 else None,
        external_id=album.id,
        cover_url=album.images[0].url if len(album.images) > 0 else None,
    )


def map_search_response(response: ApolloSearchResponse) -> SearchResults:
    tracks = list(map(map_track, response.tracks.items)) if response.tracks is not None else []
    albums = list(map(map_album, response.albums.items)) if response.albums is not None else []
    return SearchResults(tracks=tracks, albums=albums)


class ApolloSearchService:
    apollo_client: ApolloClient

    def __init__(self, client: ApolloClient) -> None:
        super().__init__()
        self.apollo_client = client

    async def search(self, query: str, types: Optional[List[SearchType]] = None) -> SearchResults:
        if types is None:
            types = [SearchType.TRACK, SearchType.ALBUM]

        response = await self.apollo_client.search(query, types, 0, DEFAULT_APOLLO_SEARCH_LIMIT)

        return map_search_response(response)


class DelphiSearchService:
    delphi_client: DelphiClient

    def __init__(self, ) -> None:
        self.delphi_client = ApiClientFactory.delphi_client()

    async def search(self, query_params: DelphiTrackSearchQueryParams):
        response = await self.delphi_client.search_for_tracks(query_params)
        return response