#!/usr/bin/python3
import os
import json
import logging
from deezspot.deezloader.dee_api import API
from deezspot.easy_spoty import Spo
from deezspot.deezloader.deegw_api import API_GW
from deezspot.deezloader.deezer_settings import stock_quality
from deezspot.models import (
    Track,
    Album,
    Playlist,
    Preferences,
    Smart,
    Episode,
)
from deezspot.deezloader.__download__ import (
    DW_TRACK,
    DW_ALBUM,
    DW_PLAYLIST,
    DW_EPISODE,
    Download_JOB,
)
from deezspot.exceptions import (
    InvalidLink,
    TrackNotFound,
    NoDataApi,
    AlbumNotFound,
)
from deezspot.libutils.utils import (
    create_zip,
    get_ids,
    link_is_valid,
    what_kind,
)
from deezspot.libutils.others_settings import (
    stock_output,
    stock_recursive_quality,
    stock_recursive_download,
    stock_not_interface,
    stock_zip,
    stock_save_cover,
)
from deezspot.libutils.logging_utils import ProgressReporter, logger

API()

# Create a logger for the deezspot library
logger = logging.getLogger('deezspot')

class DeeLogin:
    def __init__(
        self,
        arl=None,
        email=None,
        password=None,
        spotify_client_id=None,
        spotify_client_secret=None,
        progress_callback=None,
        silent=False
    ) -> None:

        # Store Spotify credentials
        self.spotify_client_id = spotify_client_id
        self.spotify_client_secret = spotify_client_secret
        
        # Initialize Spotify API if credentials are provided
        if spotify_client_id and spotify_client_secret:
            Spo.__init__(client_id=spotify_client_id, client_secret=spotify_client_secret)

        # Initialize Deezer API
        if arl:
            self.__gw_api = API_GW(arl=arl)
        else:
            self.__gw_api = API_GW(
                email=email,
                password=password
            )
            
        # Reference to the Spotify search functionality
        self.__spo = Spo
        
        # Configure progress reporting
        self.progress_reporter = ProgressReporter(callback=progress_callback, silent=silent)
        
        # Set the progress reporter for Download_JOB
        Download_JOB.set_progress_reporter(self.progress_reporter)

    def report_progress(self, progress_data):
        """Report progress using the configured reporter."""
        self.progress_reporter.report(progress_data)

    def download_trackdee(
        self, link_track,
        output_dir=stock_output,
        quality_download=stock_quality,
        recursive_quality=stock_recursive_quality,
        recursive_download=stock_recursive_download,
        not_interface=stock_not_interface,
        custom_dir_format=None,
        custom_track_format=None,
        pad_tracks=True,
        initial_retry_delay=30,
        retry_delay_increase=30,
        max_retries=5,
        convert_to=None,
        bitrate=None,
        save_cover=stock_save_cover
    ) -> Track:

        link_is_valid(link_track)
        ids = get_ids(link_track)

        try:
            song_metadata = API.tracking(ids)
        except NoDataApi:
            infos = self.__gw_api.get_song_data(ids)

            if not "FALLBACK" in infos:
                raise TrackNotFound(link_track)

            ids = infos['FALLBACK']['SNG_ID']
            song_metadata = API.tracking(ids)

        preferences = Preferences()
        preferences.link = link_track
        preferences.song_metadata = song_metadata
        preferences.quality_download = quality_download
        preferences.output_dir = output_dir
        preferences.ids = ids
        preferences.recursive_quality = recursive_quality
        preferences.recursive_download = recursive_download
        preferences.not_interface = not_interface
        # New custom formatting preferences:
        preferences.custom_dir_format = custom_dir_format
        preferences.custom_track_format = custom_track_format
        # Track number padding option
        preferences.pad_tracks = pad_tracks
        # Retry parameters
        preferences.initial_retry_delay = initial_retry_delay
        preferences.retry_delay_increase = retry_delay_increase
        preferences.max_retries = max_retries
        # Audio conversion parameter
        preferences.convert_to = convert_to
        preferences.bitrate = bitrate
        preferences.save_cover = save_cover

        track = DW_TRACK(preferences).dw()

        return track

    def download_albumdee(
        self, link_album,
        output_dir=stock_output,
        quality_download=stock_quality,
        recursive_quality=stock_recursive_quality,
        recursive_download=stock_recursive_download,
        not_interface=stock_not_interface,
        make_zip=stock_zip,
        custom_dir_format=None,
        custom_track_format=None,
        pad_tracks=True,
        initial_retry_delay=30,
        retry_delay_increase=30,
        max_retries=5,
        convert_to=None,
        bitrate=None,
        save_cover=stock_save_cover
    ) -> Album:

        link_is_valid(link_album)
        ids = get_ids(link_album)

        try:
            album_json = API.get_album(ids)
        except NoDataApi:
            raise AlbumNotFound(link_album)

        song_metadata = API.tracking_album(album_json)

        preferences = Preferences()
        preferences.link = link_album
        preferences.song_metadata = song_metadata
        preferences.quality_download = quality_download
        preferences.output_dir = output_dir
        preferences.ids = ids
        preferences.json_data = album_json
        preferences.recursive_quality = recursive_quality
        preferences.recursive_download = recursive_download
        preferences.not_interface = not_interface
        preferences.make_zip = make_zip
        # New custom formatting preferences:
        preferences.custom_dir_format = custom_dir_format
        preferences.custom_track_format = custom_track_format
        # Track number padding option
        preferences.pad_tracks = pad_tracks
        # Retry parameters
        preferences.initial_retry_delay = initial_retry_delay
        preferences.retry_delay_increase = retry_delay_increase
        preferences.max_retries = max_retries
        # Audio conversion parameter
        preferences.convert_to = convert_to
        preferences.bitrate = bitrate
        preferences.save_cover = save_cover

        album = DW_ALBUM(preferences).dw()

        return album

    def download_playlistdee(
        self, link_playlist,
        output_dir=stock_output,
        quality_download=stock_quality,
        recursive_quality=stock_recursive_quality,
        recursive_download=stock_recursive_download,
        not_interface=stock_not_interface,
        make_zip=stock_zip,
        custom_dir_format=None,
        custom_track_format=None,
        pad_tracks=True,
        initial_retry_delay=30,
        retry_delay_increase=30,
        max_retries=5,
        convert_to=None,
        bitrate=None,
        save_cover=stock_save_cover
    ) -> Playlist:

        link_is_valid(link_playlist)
        ids = get_ids(link_playlist)

        song_metadata = []
        playlist_json = API.get_playlist(ids)

        for track in playlist_json['tracks']['data']:
            c_ids = track['id']

            try:
                c_song_metadata = API.tracking(c_ids)
            except NoDataApi:
                infos = self.__gw_api.get_song_data(c_ids)
                if not "FALLBACK" in infos:
                    c_song_metadata = f"{track['title']} - {track['artist']['name']}"
                else:
                    c_song_metadata = API.tracking(c_ids)

            song_metadata.append(c_song_metadata)

        preferences = Preferences()
        preferences.link = link_playlist
        preferences.song_metadata = song_metadata
        preferences.quality_download = quality_download
        preferences.output_dir = output_dir
        preferences.ids = ids
        preferences.json_data = playlist_json
        preferences.recursive_quality = recursive_quality
        preferences.recursive_download = recursive_download
        preferences.not_interface = not_interface
        preferences.make_zip = make_zip
        # New custom formatting preferences:
        preferences.custom_dir_format = custom_dir_format
        preferences.custom_track_format = custom_track_format
        # Track number padding option
        preferences.pad_tracks = pad_tracks
        # Retry parameters
        preferences.initial_retry_delay = initial_retry_delay
        preferences.retry_delay_increase = retry_delay_increase
        preferences.max_retries = max_retries
        # Audio conversion parameter
        preferences.convert_to = convert_to
        preferences.bitrate = bitrate
        preferences.save_cover = save_cover

        playlist = DW_PLAYLIST(preferences).dw()

        return playlist

    def download_artisttopdee(
        self, link_artist,
        output_dir=stock_output,
        quality_download=stock_quality,
        recursive_quality=stock_recursive_quality,
        recursive_download=stock_recursive_download,
        not_interface=stock_not_interface,
        custom_dir_format=None,
        custom_track_format=None,
        pad_tracks=True,
        convert_to=None,
        bitrate=None,
        save_cover=stock_save_cover
    ) -> list[Track]:

        link_is_valid(link_artist)
        ids = get_ids(link_artist)

        playlist_json = API.get_artist_top_tracks(ids)['data']

        names = [
            self.download_trackdee(
                track['link'], output_dir,
                quality_download, recursive_quality,
                recursive_download, not_interface,
                custom_dir_format=custom_dir_format,
                custom_track_format=custom_track_format,
                pad_tracks=pad_tracks,
                convert_to=convert_to,
                bitrate=bitrate,
                save_cover=save_cover
            )
            for track in playlist_json
        ]

        return names

    def convert_spoty_to_dee_link_track(self, link_track):
        link_is_valid(link_track)
        ids = get_ids(link_track)

        # Use stored credentials for API calls
        track_json = Spo.get_track(ids)
        external_ids = track_json['external_ids']

        if not external_ids:
            msg = f"⚠ The track \"{track_json['name']}\" can't be converted to Deezer link :( ⚠"
            raise TrackNotFound(
                url=link_track,
                message=msg
            )

        isrc = f"isrc:{external_ids['isrc']}"
        track_json_dee = API.get_track(isrc)
        track_link_dee = track_json_dee['link']

        return track_link_dee

    def download_trackspo(
        self, link_track,
        output_dir=stock_output,
        quality_download=stock_quality,
        recursive_quality=stock_recursive_quality,
        recursive_download=stock_recursive_download,
        not_interface=stock_not_interface,
        custom_dir_format=None,
        custom_track_format=None,
        pad_tracks=True,
        initial_retry_delay=30,
        retry_delay_increase=30,
        max_retries=5,
        convert_to=None,
        bitrate=None,
        save_cover=stock_save_cover
    ) -> Track:

        track_link_dee = self.convert_spoty_to_dee_link_track(link_track)

        track = self.download_trackdee(
            track_link_dee,
            output_dir=output_dir,
            quality_download=quality_download,
            recursive_quality=recursive_quality,
            recursive_download=recursive_download,
            not_interface=not_interface,
            custom_dir_format=custom_dir_format,
            custom_track_format=custom_track_format,
            pad_tracks=pad_tracks,
            initial_retry_delay=initial_retry_delay,
            retry_delay_increase=retry_delay_increase,
            max_retries=max_retries,
            convert_to=convert_to,
            bitrate=bitrate,
            save_cover=save_cover
        )

        return track

    def convert_spoty_to_dee_link_album(self, link_album):
        link_is_valid(link_album)
        ids = get_ids(link_album)
        link_dee = None

        spotify_album_data = Spo.get_album(ids)

        # Method 1: Try UPC
        try:
            external_ids = spotify_album_data.get('external_ids')
            if external_ids and 'upc' in external_ids:
                upc_base = str(external_ids['upc']).lstrip('0')
                if upc_base:
                    logger.debug(f"Attempting Deezer album search with UPC: {upc_base}")
                    try:
                        deezer_album_info = API.get_album(f"upc:{upc_base}")
                        if isinstance(deezer_album_info, dict) and 'link' in deezer_album_info:
                            link_dee = deezer_album_info['link']
                            logger.info(f"Found Deezer album via UPC: {link_dee}")
                    except NoDataApi:
                        logger.debug(f"No Deezer album found for UPC: {upc_base}")
                    except Exception as e_upc_search:
                        logger.warning(f"Error during Deezer API call for UPC {upc_base}: {e_upc_search}")
            else:
                logger.debug("No UPC found in Spotify data for album link conversion.")
        except Exception as e_upc_block:
            logger.error(f"Error processing UPC for album {link_album}: {e_upc_block}")

        # Method 2: Try ISRC if UPC failed
        if not link_dee:
            logger.debug(f"UPC method failed or skipped for {link_album}. Attempting ISRC method.")
            try:
                spotify_total_tracks = spotify_album_data.get('total_tracks')
                spotify_tracks_items = spotify_album_data.get('tracks', {}).get('items', [])

                if not spotify_tracks_items:
                    logger.warning(f"No track items in Spotify data for {link_album} to attempt ISRC lookup.")
                else:
                    for track_item in spotify_tracks_items:
                        try:
                            track_spotify_link = track_item.get('external_urls', {}).get('spotify')
                            if not track_spotify_link: continue

                            spotify_track_info = Spo.get_track(track_spotify_link)
                            isrc_value = spotify_track_info.get('external_ids', {}).get('isrc')
                            if not isrc_value: continue
                            
                            logger.debug(f"Attempting Deezer track search with ISRC: {isrc_value}")
                            deezer_track_info = API.get_track(f"isrc:{isrc_value}")

                            if isinstance(deezer_track_info, dict) and 'album' in deezer_track_info:
                                deezer_album_preview = deezer_track_info['album']
                                if isinstance(deezer_album_preview, dict) and 'id' in deezer_album_preview:
                                    deezer_album_id = deezer_album_preview['id']
                                    full_deezer_album_info = API.get_album(deezer_album_id)
                                    if (
                                        isinstance(full_deezer_album_info, dict) and
                                        full_deezer_album_info.get('nb_tracks') == spotify_total_tracks and
                                        'link' in full_deezer_album_info
                                    ):
                                        link_dee = full_deezer_album_info['link']
                                        logger.info(f"Found Deezer album via ISRC ({isrc_value}): {link_dee}")
                                        break  # Found a matching album, exit track loop
                        except NoDataApi:
                            logger.debug(f"No Deezer track/album found for ISRC: {isrc_value}")
                            # Continue to the next track's ISRC
                        except Exception as e_isrc_track_search:
                            logger.warning(f"Error during Deezer search for ISRC {isrc_value}: {e_isrc_track_search}")
                            # Continue to the next track's ISRC
                    if not link_dee: # If loop finished and no link found via ISRC
                        logger.warning(f"ISRC method completed for {link_album}, but no matching Deezer album found.")
            except Exception as e_isrc_block:
                logger.error(f"Error during ISRC processing block for {link_album}: {e_isrc_block}")

        if not link_dee:
            raise AlbumNotFound(f"Failed to convert Spotify album link {link_album} to a Deezer link after all attempts.")

        return link_dee

    def download_albumspo(
        self, link_album,
        output_dir=stock_output,
        quality_download=stock_quality,
        recursive_quality=stock_recursive_quality,
        recursive_download=stock_recursive_download,
        not_interface=stock_not_interface,
        make_zip=stock_zip,
        custom_dir_format=None,
        custom_track_format=None,
        pad_tracks=True,
        initial_retry_delay=30,
        retry_delay_increase=30,
        max_retries=5,
        convert_to=None,
        bitrate=None,
        save_cover=stock_save_cover
    ) -> Album:

        link_dee = self.convert_spoty_to_dee_link_album(link_album)

        album = self.download_albumdee(
            link_dee, output_dir,
            quality_download, recursive_quality,
            recursive_download, not_interface,
            make_zip, 
            custom_dir_format=custom_dir_format,
            custom_track_format=custom_track_format,
            pad_tracks=pad_tracks,
            initial_retry_delay=initial_retry_delay,
            retry_delay_increase=retry_delay_increase,
            max_retries=max_retries,
            convert_to=convert_to,
            bitrate=bitrate,
            save_cover=save_cover
        )

        return album

    def download_playlistspo(
        self, link_playlist,
        output_dir=stock_output,
        quality_download=stock_quality,
        recursive_quality=stock_recursive_quality,
        recursive_download=stock_recursive_download,
        not_interface=stock_not_interface,
        make_zip=stock_zip,
        custom_dir_format=None,
        custom_track_format=None,
        pad_tracks=True,
        initial_retry_delay=30,
        retry_delay_increase=30,
        max_retries=5,
        convert_to=None,
        bitrate=None,
        save_cover=stock_save_cover
    ) -> Playlist:

        link_is_valid(link_playlist)
        ids = get_ids(link_playlist)

        # Use stored credentials for API calls
        playlist_json = Spo.get_playlist(ids)
        playlist_name = playlist_json['name']
        total_tracks = playlist_json['tracks']['total']
        playlist_tracks = playlist_json['tracks']['items']
        playlist = Playlist()
        tracks = playlist.tracks

        # Initializing status - replaced print with report_progress
        self.report_progress({
            "status": "initializing",
            "type": "playlist",
            "name": playlist_name,
            "total_tracks": total_tracks
        })

        for index, item in enumerate(playlist_tracks, 1):
            is_track = item.get('track')
            if not is_track:
                # Progress status for an invalid track item
                self.report_progress({
                    "status": "progress",
                    "type": "playlist",
                    "track": "Unknown Track",
                    "current_track": f"{index}/{total_tracks}"
                })
                continue

            track_info = is_track
            track_name = track_info.get('name', 'Unknown Track')
            artists = track_info.get('artists', [])
            artist_name = artists[0]['name'] if artists else 'Unknown Artist'

            external_urls = track_info.get('external_urls', {})
            if not external_urls:
                # Progress status for unavailable track
                self.report_progress({
                    "status": "progress",
                    "type": "playlist",
                    "track": track_name,
                    "current_track": f"{index}/{total_tracks}"
                })
                logger.warning(f"The track \"{track_name}\" is not available on Spotify :(")
                continue

            # Progress status before download attempt
            self.report_progress({
                "status": "progress",
                "type": "playlist",
                "track": track_name,
                "current_track": f"{index}/{total_tracks}"
            })

            link_track = external_urls['spotify']

            try:
                # Download each track individually via the Spotify-to-Deezer conversion method.
                downloaded_track = self.download_trackspo(
                    link_track,
                    output_dir=output_dir,
                    quality_download=quality_download,
                    recursive_quality=recursive_quality,
                    recursive_download=recursive_download,
                    not_interface=not_interface,
                    custom_dir_format=custom_dir_format,
                    custom_track_format=custom_track_format,
                    pad_tracks=pad_tracks,
                    initial_retry_delay=initial_retry_delay,
                    retry_delay_increase=retry_delay_increase,
                    max_retries=max_retries,
                    convert_to=convert_to,
                    bitrate=bitrate,
                    save_cover=save_cover
                )
                tracks.append(downloaded_track)
            except (TrackNotFound, NoDataApi) as e:
                logger.error(f"Failed to download track: {track_name} - {artist_name}")
                tracks.append(f"{track_name} - {artist_name}")

        # Done status
        self.report_progress({
            "status": "done",
            "type": "playlist",
            "name": playlist_name,
            "total_tracks": total_tracks
        })

        # === New m3u File Creation Section ===
        # Create a subfolder "playlists" inside the output directory
        playlist_m3u_dir = os.path.join(output_dir, "playlists")
        os.makedirs(playlist_m3u_dir, exist_ok=True)
        # The m3u file will be named after the playlist (e.g. "MyPlaylist.m3u")
        m3u_path = os.path.join(playlist_m3u_dir, f"{playlist_name}.m3u")
        with open(m3u_path, "w", encoding="utf-8") as m3u_file:
            # Write the m3u header
            m3u_file.write("#EXTM3U\n")
            # Append each successfully downloaded track's relative path
            for track in tracks:
                if isinstance(track, Track) and track.success and hasattr(track, 'song_path') and track.song_path:
                    # Calculate the relative path from the m3u folder to the track file
                    relative_song_path = os.path.relpath(track.song_path, start=playlist_m3u_dir)
                    m3u_file.write(f"{relative_song_path}\n")
        logger.info(f"Created m3u playlist file at: {m3u_path}")
        # === End m3u File Creation Section ===

        if make_zip:
            playlist_name = playlist_json['name']
            zip_name = f"{output_dir}playlist {playlist_name}.zip"
            create_zip(tracks, zip_name=zip_name)
            playlist.zip_path = zip_name

        return playlist

    def download_name(
        self, artist, song,
        output_dir=stock_output,
        quality_download=stock_quality,
        recursive_quality=stock_recursive_quality,
        recursive_download=stock_recursive_download,
        not_interface=stock_not_interface,
        custom_dir_format=None,
        custom_track_format=None,
        initial_retry_delay=30,
        retry_delay_increase=30,
        max_retries=5,
        pad_tracks=True,
        convert_to=None,
        bitrate=None,
        save_cover=stock_save_cover
    ) -> Track:

        query = f"track:{song} artist:{artist}"
        # Use the stored credentials when searching
        search = self.__spo.search(
            query, 
            client_id=self.spotify_client_id, 
            client_secret=self.spotify_client_secret
        ) if not self.__spo._Spo__initialized else self.__spo.search(query)
        
        items = search['tracks']['items']

        if len(items) == 0:
            msg = f"No result for {query} :("
            raise TrackNotFound(message=msg)

        link_track = items[0]['external_urls']['spotify']

        track = self.download_trackspo(
            link_track,
            output_dir=output_dir,
            quality_download=quality_download,
            recursive_quality=recursive_quality,
            recursive_download=recursive_download,
            not_interface=not_interface,
            custom_dir_format=custom_dir_format,
            custom_track_format=custom_track_format,
            pad_tracks=pad_tracks,
            initial_retry_delay=initial_retry_delay,
            retry_delay_increase=retry_delay_increase,
            max_retries=max_retries,
            convert_to=convert_to,
            bitrate=bitrate,
            save_cover=save_cover
        )

        return track

    def download_episode(
        self,
        link_episode,
        output_dir=stock_output,
        quality_download=stock_quality,
        recursive_quality=stock_recursive_quality,
        recursive_download=stock_recursive_download,
        not_interface=stock_not_interface,
        custom_dir_format=None,
        custom_track_format=None,
        pad_tracks=True,
        initial_retry_delay=30,
        retry_delay_increase=30,
        max_retries=5,
        convert_to=None,
        bitrate=None,
        save_cover=stock_save_cover
    ) -> Episode:
        
        link_is_valid(link_episode)
        ids = get_ids(link_episode)
        
        try:
            episode_metadata = API.tracking(ids)
        except NoDataApi:
            infos = self.__gw_api.get_episode_data(ids)
            if not infos:
                raise TrackNotFound("Episode not found")
            episode_metadata = {
                'music': infos.get('EPISODE_TITLE', ''),
                'artist': infos.get('SHOW_NAME', ''),
                'album': infos.get('SHOW_NAME', ''),
                'date': infos.get('EPISODE_PUBLISHED_TIMESTAMP', '').split()[0],
                'genre': 'Podcast',
                'explicit': infos.get('SHOW_IS_EXPLICIT', '2'),
                'disc': 1,
                'track': 1,
                'duration': int(infos.get('DURATION', 0)),
                'isrc': None,
                'image': infos.get('EPISODE_IMAGE_MD5', '')
            }

        preferences = Preferences()
        preferences.link = link_episode
        preferences.song_metadata = episode_metadata
        preferences.quality_download = quality_download
        preferences.output_dir = output_dir
        preferences.ids = ids
        preferences.recursive_quality = recursive_quality
        preferences.recursive_download = recursive_download
        preferences.not_interface = not_interface
        # No convert_to for episode download (and preferences.convert_to is not set here)
        preferences.max_retries = max_retries
        # Audio conversion parameters
        preferences.convert_to = convert_to
        preferences.bitrate = bitrate
        preferences.save_cover = save_cover
        preferences.is_episode = True

        episode = DW_EPISODE(preferences).dw()

        return episode
    
    def download_smart(
        self, link,
        output_dir=stock_output,
        quality_download=stock_quality,
        recursive_quality=stock_recursive_quality,
        recursive_download=stock_recursive_download,
        not_interface=stock_not_interface,
        make_zip=stock_zip,
        custom_dir_format=None,
        custom_track_format=None,
        pad_tracks=True,
        initial_retry_delay=30,
        retry_delay_increase=30,
        max_retries=5,
        convert_to=None,
        bitrate=None,
        save_cover=stock_save_cover
    ) -> Smart:

        link_is_valid(link)
        link = what_kind(link)
        smart = Smart()

        if "spotify.com" in link:
            source = "https://spotify.com"
        elif "deezer.com" in link:
            source = "https://deezer.com"

        smart.source = source
        
        # Add progress reporting for the smart downloader
        self.report_progress({
            "status": "initializing",
            "type": "smart_download",
            "link": link,
            "source": source
        })

        if "track/" in link:
            if "spotify.com" in link:
                func = self.download_trackspo
            elif "deezer.com" in link:
                func = self.download_trackdee
            else:
                raise InvalidLink(link)

            track = func(
                link,
                output_dir=output_dir,
                quality_download=quality_download,
                recursive_quality=recursive_quality,
                recursive_download=recursive_download,
                not_interface=not_interface,
                custom_dir_format=custom_dir_format,
                custom_track_format=custom_track_format,
                pad_tracks=pad_tracks,
                initial_retry_delay=initial_retry_delay,
                retry_delay_increase=retry_delay_increase,
                max_retries=max_retries,
                convert_to=convert_to,
                bitrate=bitrate,
                save_cover=save_cover
            )
            smart.type = "track"
            smart.track = track

        elif "album/" in link:
            if "spotify.com" in link:
                func = self.download_albumspo
            elif "deezer.com" in link:
                func = self.download_albumdee
            else:
                raise InvalidLink(link)

            album = func(
                link,
                output_dir=output_dir,
                quality_download=quality_download,
                recursive_quality=recursive_quality,
                recursive_download=recursive_download,
                not_interface=not_interface,
                make_zip=make_zip,
                custom_dir_format=custom_dir_format,
                custom_track_format=custom_track_format,
                pad_tracks=pad_tracks,
                initial_retry_delay=initial_retry_delay,
                retry_delay_increase=retry_delay_increase,
                max_retries=max_retries,
                convert_to=convert_to,
                bitrate=bitrate,
                save_cover=save_cover
            )
            smart.type = "album"
            smart.album = album

        elif "playlist/" in link:
            if "spotify.com" in link:
                func = self.download_playlistspo
            elif "deezer.com" in link:
                func = self.download_playlistdee
            else:
                raise InvalidLink(link)

            playlist = func(
                link,
                output_dir=output_dir,
                quality_download=quality_download,
                recursive_quality=recursive_quality,
                recursive_download=recursive_download,
                not_interface=not_interface,
                make_zip=make_zip,
                custom_dir_format=custom_dir_format,
                custom_track_format=custom_track_format,
                pad_tracks=pad_tracks,
                initial_retry_delay=initial_retry_delay,
                retry_delay_increase=retry_delay_increase,
                max_retries=max_retries,
                convert_to=convert_to,
                bitrate=bitrate,
                save_cover=save_cover
            )
            smart.type = "playlist"
            smart.playlist = playlist
            
        # Report completion
        self.report_progress({
            "status": "done",
            "type": "smart_download",
            "source": source,
            "content_type": smart.type
        })

        return smart
