# -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2018 The gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#


# sync.py -- Device synchronization
# Thomas Perl <thp@perli.net> 2007-12-06
# based on libipodsync.py (2006-04-05 Thomas Perl)
# Ported to gPodder 3 by Joseph Wickremasinghe in June 2012

import logging
import os.path
import threading
import time

import gpodder
from gpodder import download, services, util

import gi  # isort:skip
gi.require_version('Gio', '2.0')  # isort:skip
from gi.repository import GLib, Gio  # isort:skip


logger = logging.getLogger(__name__)


_ = gpodder.gettext

gpod_available = True
try:
    from gpodder import libgpod_ctypes
except:
    logger.info('iPod sync not available')
    gpod_available = False

mplayer_available = True if util.find_command('mplayer') is not None else False

eyed3mp3_available = True
try:
    import eyed3.mp3
except:
    logger.info('eyeD3 MP3 not available')
    eyed3mp3_available = False


def open_device(gui):
    config = gui._config
    device_type = gui._config.device_sync.device_type
    if device_type == 'ipod':
        return iPodDevice(config,
                gui.download_status_model,
                gui.download_queue_manager)
    elif device_type == 'filesystem':
        return MP3PlayerDevice(config,
                gui.download_status_model,
                gui.download_queue_manager,
                gui.mount_volume_for_file)

    return None


def get_track_length(filename):
    attempted = False

    if mplayer_available:
        try:
            mplayer_output = os.popen('mplayer -msglevel all=-1 -identify -vo null -ao null -frames 0 "%s" 2>/dev/null' % filename).read()
            return int(float(mplayer_output[mplayer_output.index('ID_LENGTH'):].splitlines()[0][10:]) * 1000)
        except Exception:
            logger.error('MPlayer could not determine length: %s', filename, exc_info=True)
            attempted = True

    if eyed3mp3_available:
        try:
            length = int(eyed3.mp3.Mp3AudioFile(filename).info.time_secs * 1000)
            # Notify user on eyed3 success if mplayer failed.
            # A warning is used to make it visible in gpo or on console.
            if attempted:
                logger.warning('eyed3.mp3 successfully determined length: %s', filename)
            return length
        except Exception:
            logger.error('eyed3.mp3 could not determine length: %s', filename, exc_info=True)
            attempted = True

    if not attempted:
        logger.warning('Could not determine length: %s', filename)
        logger.warning('Please install MPlayer or the eyed3.mp3 module for track length detection.')

    return int(60 * 60 * 1000 * 3)
    # Default is three hours (to be on the safe side)


def episode_filename_on_device(config, episode):
    """
    :param gpodder.config.Config config: configuration (for sync options)
    :param gpodder.model.PodcastEpisode episode: episode to get filename for
    :return str: basename minus extension to use to save episode on device
    """
    # get the local file
    from_file = episode.local_filename(create=False)
    # get the formatted base name
    filename_base = util.sanitize_filename(episode.sync_filename(
        config.device_sync.custom_sync_name_enabled,
        config.device_sync.custom_sync_name),
        config.device_sync.max_filename_length)
    # add the file extension
    to_file = filename_base + os.path.splitext(from_file)[1].lower()

    # dirty workaround: on bad (empty) episode titles,
    # we simply use the from_file basename
    # (please, podcast authors, FIX YOUR RSS FEEDS!)
    if os.path.splitext(to_file)[0] == '':
        to_file = os.path.basename(from_file)
    return to_file


def episode_foldername_on_device(config, episode):
    """
    :param gpodder.config.Config config: configuration (for sync options)
    :param gpodder.model.PodcastEpisode episode: episode to get folder name for
    :return str: folder name to save episode to on device
    """
    if config.device_sync.one_folder_per_podcast:
        # Add channel title as subfolder
        folder = episode.channel.title
        # Clean up the folder name for use on limited devices
        folder = util.sanitize_filename(folder, config.device_sync.max_filename_length)
    else:
        folder = None
    return folder


class SyncTrack(object):
    """
    This represents a track that is on a device. You need
    to specify at least the following keyword arguments,
    because these will be used to display the track in the
    GUI. All other keyword arguments are optional and can
    be used to reference internal objects, etc... See the
    iPod synchronization code for examples.

    Keyword arguments needed:
        playcount (How often has the track been played?)
        podcast (Which podcast is this track from? Or: Folder name)

    If any of these fields is unknown, it should not be
    passed to the function (the values will default to None
    for all required fields).
    """
    def __init__(self, title, length, modified, **kwargs):
        self.title = title
        self.length = length
        self.filesize = util.format_filesize(length)
        self.modified = modified

        # Set some (possible) keyword arguments to default values
        self.playcount = 0
        self.podcast = None

        # Convert keyword arguments to object attributes
        self.__dict__.update(kwargs)

    def __repr__(self):
        return 'SyncTrack(title={}, podcast={})'.format(self.title, self.podcast)

    @property
    def playcount_str(self):
        return str(self.playcount)


class Device(services.ObservableService):
    def __init__(self, config):
        self._config = config
        self.cancelled = False
        self.allowed_types = ['audio', 'video']
        self.errors = []
        self.tracks_list = []
        signals = ['progress', 'sub-progress', 'status', 'done', 'post-done']
        services.ObservableService.__init__(self, signals)

    def open(self):
        pass

    def cancel(self):
        self.cancelled = True
        self.notify('status', _('Cancelled by user'))

    def close(self):
        self.notify('status', _('Writing data to disk'))
        if self._config.device_sync.after_sync.sync_disks and not gpodder.ui.win32:
            os.system('sync')
        else:
            logger.warning('Not syncing disks. Unmount your device before unplugging.')
        return True

    def create_task(self, track):
        return SyncTask(track)

    def cancel_task(self, task):
        pass

    def cleanup_task(self, task):
        pass

    def add_sync_tasks(self, tracklist, force_played=False, done_callback=None):
        for track in list(tracklist):
            # Filter tracks that are not meant to be synchronized
            does_not_exist = not track.was_downloaded(and_exists=True)
            exclude_played = (not track.is_new
                    and self._config.device_sync.skip_played_episodes)
            wrong_type = track.file_type() not in self.allowed_types

            if does_not_exist:
                tracklist.remove(track)
            elif exclude_played or wrong_type:
                logger.info('Excluding %s from sync', track.title)
                tracklist.remove(track)

        if tracklist:
            for track in sorted(tracklist, key=lambda e: e.pubdate_prop):
                if self.cancelled:
                    break

                # XXX: need to check if track is added properly?
                sync_task = self.create_task(track)

                sync_task.status = sync_task.NEW
                sync_task.device = self
                # New Task, we must wait on the GTK Loop
                self.download_status_model.register_task(sync_task)
                # Executes after task has been registered
                util.idle_add(self.download_queue_manager.queue_task, sync_task)
        else:
            logger.warning("No episodes to sync")

        if done_callback:
            done_callback()

    def get_all_tracks(self):
        pass

    def add_track(self, track, reporthook=None):
        pass

    def remove_track(self, track):
        pass

    def get_free_space(self):
        pass

    def episode_on_device(self, episode):
        return self._track_on_device(episode.title)

    def _track_on_device(self, track_name):
        for t in self.tracks_list:
            title = t.title
            if track_name == title:
                return t
        return None


class iPodDevice(Device):
    def __init__(self, config,
            download_status_model,
            download_queue_manager):
        Device.__init__(self, config)

        self.mountpoint = self._config.device_sync.device_folder
        self.download_status_model = download_status_model
        self.download_queue_manager = download_queue_manager

        self.ipod = None

    def get_free_space(self):
        # Reserve 10 MiB for iTunesDB writing (to be on the safe side)
        RESERVED_FOR_ITDB = 1024 * 1024 * 10
        result = util.get_free_disk_space(self.mountpoint)
        if result == -1:
            # Can't get free disk space
            return -1
        return result - RESERVED_FOR_ITDB

    def open(self):
        Device.open(self)
        if not gpod_available:
            logger.error('Please install libgpod 0.8.3 to sync with an iPod device.')
            return False
        if not os.path.isdir(self.mountpoint):
            return False

        self.notify('status', _('Opening iPod database'))
        self.ipod = libgpod_ctypes.iPodDatabase(self.mountpoint)

        if not self.ipod.itdb or not self.ipod.podcasts_playlist or not self.ipod.master_playlist:
            return False

        self.notify('status', _('iPod opened'))

        # build the initial tracks_list
        self.tracks_list = self.get_all_tracks()

        return True

    def close(self):
        if self.ipod is not None:
            self.notify('status', _('Saving iPod database'))
            self.ipod.close()
            self.ipod = None

        Device.close(self)
        return True

    def get_all_tracks(self):
        tracks = []
        for track in self.ipod.get_podcast_tracks():
            filename = track.filename_on_ipod

            if filename is None:
                length = 0
                modified = ''
            else:
                length = util.calculate_size(filename)
                timestamp = util.file_modification_timestamp(filename)
                modified = util.format_date(timestamp)

            t = SyncTrack(track.episode_title, length, modified,
                    ipod_track=track,
                    playcount=track.playcount,
                    podcast=track.podcast_title)
            tracks.append(t)
        return tracks

    def episode_on_device(self, episode):
        return next((track for track in self.tracks_list
                     if track.ipod_track.podcast_rss == episode.channel.url
                     and track.ipod_track.podcast_url == episode.url), None)

    def remove_track(self, track):
        self.notify('status', _('Removing %s') % track.title)
        logger.info('Removing track from iPod: %r', track.title)
        track.ipod_track.remove_from_device()
        try:
            self.tracks_list.remove(next((sync_track for sync_track in self.tracks_list
                                          if sync_track.ipod_track == track), None))
        except ValueError:
            ...

    def add_track(self, task, reporthook=None):
        episode = task.episode
        self.notify('status', _('Adding %s') % episode.title)
        tracklist = self.ipod.get_podcast_tracks()
        episode_urls = [track.podcast_url for track in tracklist]

        if episode.url in episode_urls:
            # Mark as played on iPod if played locally (and set podcast flags)
            self.update_from_episode(tracklist[episode_urls.index(episode.url)], episode)
            return True

        local_filename = episode.local_filename(create=False)
        # The file has to exist, if we ought to transfer it, and therefore,
        # local_filename(create=False) must never return None as filename
        assert local_filename is not None

        if util.calculate_size(local_filename) > self.get_free_space():
            logger.error('Not enough space on %s, sync aborted...', self.mountpoint)
            d = {'episode': episode.title, 'mountpoint': self.mountpoint}
            message = _('Error copying %(episode)s: Not enough free space on %(mountpoint)s')
            self.errors.append(message % d)
            self.cancelled = True
            return False

        (fn, extension) = os.path.splitext(local_filename)
        if extension.lower().endswith('ogg'):
            # XXX: Proper file extension/format support check for iPod
            logger.error('Cannot copy .ogg files to iPod.')
            return False

        track = self.ipod.add_track(local_filename, episode.title, episode.channel.title,
                episode._text_description, episode.url, episode.channel.url,
                episode.published, get_track_length(local_filename), episode.file_type() == 'audio')

        self.update_from_episode(track, episode, initial=True)

        reporthook(episode.file_size, 1, episode.file_size)

        return True

    def update_from_episode(self, track, episode, *, initial=False):
        if initial:
            # Set the initial bookmark on the device based on what we have locally
            track.initialize_bookmark(episode.is_new, episode.current_position * 1000)
        else:
            # Copy updated status from iPod
            if track.playcount > 0:
                episode.is_new = False

            if track.bookmark_time > 0:
                logger.info('Playback position from iPod: %s', util.format_time(track.bookmark_time / 1000))
                episode.is_new = False
                episode.current_position = int(track.bookmark_time / 1000)
                episode.current_position_updated = time.time()

            episode.save()


class MP3PlayerDevice(Device):
    def __init__(self, config,
            download_status_model,
            download_queue_manager,
            mount_volume_for_file):
        Device.__init__(self, config)

        folder = self._config.device_sync.device_folder
        self.destination = util.new_gio_file(folder)
        self.mount_volume_for_file = mount_volume_for_file
        self.download_status_model = download_status_model
        self.download_queue_manager = download_queue_manager

    def get_free_space(self):
        info = self.destination.query_filesystem_info(Gio.FILE_ATTRIBUTE_FILESYSTEM_FREE, None)
        return info.get_attribute_uint64(Gio.FILE_ATTRIBUTE_FILESYSTEM_FREE)

    def open(self):
        Device.open(self)
        self.notify('status', _('Opening MP3 player'))

        if not self.mount_volume_for_file(self.destination):
            return False

        try:
            info = self.destination.query_info(
                Gio.FILE_ATTRIBUTE_ACCESS_CAN_WRITE + ","
                + Gio.FILE_ATTRIBUTE_STANDARD_TYPE,
                Gio.FileQueryInfoFlags.NONE,
                None)
        except GLib.Error as err:
            logger.error('querying destination info for %s failed with %s',
                self.destination.get_uri(), err.message)
            return False

        if info.get_file_type() != Gio.FileType.DIRECTORY:
            logger.error('destination %s is not a directory', self.destination.get_uri())
            return False

        # open is ok if the target is a directory, and it can be written to
        # for smb, query_info doesn't return FILE_ATTRIBUTE_ACCESS_CAN_WRITE,
        # -- if that's the case, just assume that it's writable
        if (not info.has_attribute(Gio.FILE_ATTRIBUTE_ACCESS_CAN_WRITE)
                or info.get_attribute_boolean(Gio.FILE_ATTRIBUTE_ACCESS_CAN_WRITE)):
            self.notify('status', _('MP3 player opened'))
            self.tracks_list = self.get_all_tracks()
            return True

        logger.error('destination %s is not writable', self.destination.get_uri())
        return False

    def get_episode_folder_on_device(self, episode):
        folder = episode_foldername_on_device(self._config, episode)
        if folder:
            folder = self.destination.get_child(folder)
        else:
            folder = self.destination

        return folder

    def get_episode_file_on_device(self, episode):
        return episode_filename_on_device(self._config, episode)

    def create_task(self, track):
        return GioSyncTask(track)

    def cancel_task(self, task):
        task.cancellable.cancel()

    # called by the sync task when it is removed and needs partial files cleaning up
    def cleanup_task(self, task):
        episode = task.episode
        folder = self.get_episode_folder_on_device(episode)
        file = self.get_episode_file_on_device(episode)
        file = folder.get_child(file)
        self.remove_track_file(file)

    def add_track(self, task, reporthook=None):
        episode = task.episode
        self.notify('status', _('Adding %s') % episode.title)

        # get the folder on the device
        folder = self.get_episode_folder_on_device(episode)

        filename = episode.local_filename(create=False)
        # The file has to exist, if we ought to transfer it, and therefore,
        # local_filename(create=False) must never return None as filename
        assert filename is not None

        from_file = filename

        # verify free space
        needed = util.calculate_size(from_file)
        free = self.get_free_space()
        if free == -1:
            logger.warning('Cannot determine free disk space on device')
        elif needed > free:
            d = {'path': self.destination, 'free': util.format_filesize(free), 'need': util.format_filesize(needed)}
            message = _('Not enough space in %(path)s: %(free)s available, but need at least %(need)s')
            raise SyncFailedException(message % d)

        # get the filename that will be used on the device
        to_file = self.get_episode_file_on_device(episode)
        to_file = folder.get_child(to_file)

        util.make_directory(folder)

        to_file_exists = to_file.query_exists()
        from_size = episode.file_size
        to_size = episode.file_size
        if to_file_exists:
            try:
                info = to_file.query_info(Gio.FILE_ATTRIBUTE_STANDARD_SIZE, Gio.FileQueryInfoFlags.NONE)
                to_size = info.get_attribute_uint64(Gio.FILE_ATTRIBUTE_STANDARD_SIZE)
            except GLib.Error:
                # Assume same size and don't sync again
                pass
        if not to_file_exists or from_size != to_size:
            logger.info('Copying %s (%d bytes) => %s (%d bytes)',
                    os.path.basename(from_file), from_size,
                    to_file.get_uri(), to_size)
            from_file = Gio.File.new_for_path(from_file)
            try:
                def hookconvert(current_bytes, total_bytes, user_data):
                    return reporthook(current_bytes, 1, total_bytes)
                from_file.copy(to_file, Gio.FileCopyFlags.OVERWRITE, task.cancellable, hookconvert, None)
            except GLib.Error as err:
                if err.matches(Gio.io_error_quark(), Gio.IOErrorEnum.CANCELLED):
                    raise SyncCancelledException()
                logger.error('Error copying %s to %s: %s', from_file.get_uri(), to_file.get_uri(), err.message)
                d = {'from_file': from_file.get_uri(), 'to_file': to_file.get_uri(), 'message': err.message}
                self.errors.append(_('Error copying %(from_file)s to %(to_file)s: %(message)s') % d)
                return False

        return True

    def add_sync_track(self, tracks, file, info, podcast_name):
        (title, extension) = os.path.splitext(info.get_name())
        timestamp = info.get_modification_time()
        modified = util.format_date(timestamp.tv_sec)

        t = SyncTrack(title, info.get_size(), modified,
                filename=file.get_uri(),
                podcast=podcast_name)
        tracks.append(t)

    def get_all_tracks(self):
        tracks = []

        attributes = (
            Gio.FILE_ATTRIBUTE_STANDARD_NAME + ","
            + Gio.FILE_ATTRIBUTE_STANDARD_TYPE + ","
            + Gio.FILE_ATTRIBUTE_STANDARD_SIZE + ","
            + Gio.FILE_ATTRIBUTE_TIME_MODIFIED)

        root_path = self.destination
        for path_info in root_path.enumerate_children(attributes, Gio.FileQueryInfoFlags.NONE, None):
            if self._config.one_folder_per_podcast:
                if path_info.get_file_type() == Gio.FileType.DIRECTORY:
                    path_file = root_path.get_child(path_info.get_name())
                    for child_info in path_file.enumerate_children(attributes, Gio.FileQueryInfoFlags.NONE, None):
                        if child_info.get_file_type() == Gio.FileType.REGULAR:
                            child_file = path_file.get_child(child_info.get_name())
                            self.add_sync_track(tracks, child_file, child_info, path_info.get_name())

            else:
                if path_info.get_file_type() == Gio.FileTypeFlags.REGULAR:
                    path_file = root_path.get_child(path_info.get_name())
                    self.add_sync_track(tracks, path_file, path_info, None)
        return tracks

    def episode_on_device(self, episode):
        e = util.sanitize_filename(episode.sync_filename(
            self._config.device_sync.custom_sync_name_enabled,
            self._config.device_sync.custom_sync_name),
            self._config.device_sync.max_filename_length)
        return self._track_on_device(e)

    def remove_track_file(self, file):
        folder = file.get_parent()
        if file.query_exists():
            try:
                file.delete()
            except GLib.Error as err:
                # if the file went away don't worry about it
                if not err.matches(Gio.io_error_quark(), Gio.IOErrorEnum.NOT_FOUND):
                    logger.error('deleting file %s failed: %s', file.get_uri(), err.message)
                return

        if self._config.one_folder_per_podcast:
            try:
                if self.directory_is_empty(folder):
                    folder.delete()
            except GLib.Error as err:
                # if the folder went away don't worry about it (multiple threads could
                # make this happen if they both notice the folder is empty simultaneously)
                if not err.matches(Gio.io_error_quark(), Gio.IOErrorEnum.NOT_FOUND):
                    logger.error('deleting folder %s failed: %s', folder.get_uri(), err.message)

    def remove_track(self, track):
        self.notify('status', _('Removing %s') % track.title)

        # get the folder on the device
        file = Gio.File.new_for_uri(track.filename)
        self.remove_track_file(file)

    def directory_is_empty(self, directory):
        for child in directory.enumerate_children(Gio.FILE_ATTRIBUTE_STANDARD_NAME, Gio.FileQueryInfoFlags.NONE, None):
            return False
        return True


class SyncCancelledException(Exception): pass


class SyncFailedException(Exception): pass


class SyncTask(download.DownloadTask):
    # An object representing the synchronization task of an episode

    # Possible states this sync task can be in
    STATUS_MESSAGE = (_('Queued'), _('Queued'), _('Syncing'),
            _('Finished'), _('Failed'), _('Cancelling'), _('Cancelled'), _('Pausing'), _('Paused'))
    (NEW, QUEUED, DOWNLOADING, DONE, FAILED, CANCELLING, CANCELLED, PAUSING, PAUSED) = list(range(9))

    def __str__(self):
        return self.__episode.title

    def __get_status(self):
        return self.__status

    def __set_status(self, status):
        if status != self.__status:
            self.__status_changed = True
            self.__status = status

    status = property(fget=__get_status, fset=__set_status)

    def __get_device(self):
        return self.__device

    def __set_device(self, device):
        self.__device = device

    device = property(fget=__get_device, fset=__set_device)

    def __get_status_changed(self):
        if self.__status_changed:
            self.__status_changed = False
            return True
        else:
            return False

    status_changed = property(fget=__get_status_changed)

    def __get_activity(self):
        return self.__activity

    def __set_activity(self, activity):
        self.__activity = activity

    activity = property(fget=__get_activity, fset=__set_activity)

    def __get_empty_string(self):
        return ''

    url = property(fget=__get_empty_string)
    podcast_url = property(fget=__get_empty_string)

    def __get_episode(self):
        return self.__episode

    episode = property(fget=__get_episode)

    def can_queue(self):
        return self.status in (self.CANCELLED, self.PAUSED, self.FAILED)

    def can_pause(self):
        return self.status in (self.DOWNLOADING, self.QUEUED)

    def pause(self):
        with self:
            # Pause a queued download
            if self.status == self.QUEUED:
                self.status = self.PAUSED
            # Request pause of a running download
            elif self.status == self.DOWNLOADING:
                self.status = self.PAUSING

    def can_cancel(self):
        return self.status in (self.DOWNLOADING, self.QUEUED, self.PAUSED, self.FAILED)

    def cancel(self):
        with self:
            # Cancelling directly is allowed if the task isn't currently downloading
            if self.status in (self.QUEUED, self.PAUSED, self.FAILED):
                self.status = self.CANCELLED
                # Call run, so the partial file gets deleted
                self.run()
                self.recycle()
            # Otherwise request cancellation
            elif self.status == self.DOWNLOADING:
                self.status = self.CANCELLING
                self.device.cancel()

    def can_remove(self):
        return self.status in (self.CANCELLED, self.FAILED, self.DONE)

    def removed_from_list(self):
        if self.status != self.DONE:
            self.device.cleanup_task(self)

    def __init__(self, episode):
        self.__lock = threading.RLock()
        self.__status = SyncTask.NEW
        self.__activity = SyncTask.ACTIVITY_SYNCHRONIZE
        self.__status_changed = True
        self.__episode = episode

        # Create the target filename and save it in the database
        self.filename = self.__episode.local_filename(create=False)

        self.total_size = self.__episode.file_size
        self.speed = 0.0
        self.progress = 0.0
        self.error_message = None
        self.custom_downloader = None

        # Have we already shown this task in a notification?
        self._notification_shown = False

        # Variables for speed limit and speed calculation
        self.__start_time = 0
        self.__start_blocks = 0
        self.__limit_rate_value = 999
        self.__limit_rate = 999

        # Callbacks
        self._progress_updated = lambda x: None

    def __enter__(self):
        return self.__lock.acquire()

    def __exit__(self, type, value, traceback):
        self.__lock.release()

    def notify_as_finished(self):
        if self.status == SyncTask.DONE:
            if self._notification_shown:
                return False
            else:
                self._notification_shown = True
                return True

        return False

    def notify_as_failed(self):
        if self.status == SyncTask.FAILED:
            if self._notification_shown:
                return False
            else:
                self._notification_shown = True
                return True

        return False

    def add_progress_callback(self, callback):
        self._progress_updated = callback

    def status_updated(self, count, blockSize, totalSize):
        # We see a different "total size" while downloading,
        # so correct the total size variable in the thread
        if totalSize != self.total_size and totalSize > 0:
            self.total_size = float(totalSize)

        if self.total_size > 0:
            self.progress = max(0.0, min(1.0, (count * blockSize) / self.total_size))
            self._progress_updated(self.progress)

        if self.status in (SyncTask.CANCELLING, SyncTask.PAUSING):
            self._signal_cancel_from_status()

    # default implementation
    def _signal_cancel_from_status(self):
        raise SyncCancelledException()

    def recycle(self):
        self.episode.download_task = None

    def run(self):
        # Speed calculation (re-)starts here
        self.__start_time = 0
        self.__start_blocks = 0

        # If the download has already been cancelled/paused, skip it
        with self:
            if self.status in (SyncTask.CANCELLING, SyncTask.CANCELLED):
                self.progress = 0.0
                self.speed = 0.0
                self.status = SyncTask.CANCELLED
                return False

            if self.status == SyncTask.PAUSING:
                self.status = SyncTask.PAUSED
                return False

            # We only start this download if its status is downloading
            if self.status != SyncTask.DOWNLOADING:
                return False

            # We are syncing this file right now
            self._notification_shown = False

        sync_result = SyncTask.DOWNLOADING
        try:
            logger.info('Starting SyncTask')
            self.device.add_track(self, reporthook=self.status_updated)
        except SyncCancelledException as e:
            sync_result = SyncTask.CANCELLED
        except Exception as e:
            sync_result = SyncTask.FAILED
            logger.error('Sync failed: %s', str(e), exc_info=True)
            self.error_message = _('Error: %s') % (str(e),)

        with self:
            if sync_result == SyncTask.DOWNLOADING:
                # Everything went well - we're done
                self.status = SyncTask.DONE
                if self.total_size <= 0:
                    self.total_size = util.calculate_size(self.filename)
                    logger.info('Total size updated to %d', self.total_size)
                self.progress = 1.0
                gpodder.user_extensions.on_episode_synced(self.device, self.__episode)
                return True

            self.speed = 0.0

            if sync_result == SyncTask.FAILED:
                self.status = SyncTask.FAILED

            # cancelled/paused -- update state to mark it as safe to manipulate this task again
            elif self.status == SyncTask.PAUSING:
                self.status = SyncTask.PAUSED
            elif self.status == SyncTask.CANCELLING:
                self.status = SyncTask.CANCELLED

        # We finished, but not successfully (at least not really)
        return False


class GioSyncTask(SyncTask):
    def __init__(self, episode):
        super().__init__(episode)
        # For cancelling the copy
        self.cancellable = Gio.Cancellable()

    def _signal_cancel_from_status(self):
        self.cancellable.cancel()