"""Jobs a ejecutar en el fondo"""
import logging
import json

import django_rq

from fetcher import musicbrainz as mb
from utils import get_redis_connection

_log = logging.getLogger('fetcher_jobs')
_log.addHandler(logging.NullHandler())


@django_rq.job('high')
def load_release_cover_art(release):
    """Carga en cache el cover art de una release"""
    with get_redis_connection() as redis:
        mbid = release
        if isinstance(release, dict):
            mbid = release.get('id')

        if f'release_cover_art_{mbid}' in redis:
            _log.info('El cover art ya estaba guardado')
            return

        cover_art = mb.get_release_cover_art(mbid)
        redis.set(f'release_cover_art_{mbid}', json.dumps(cover_art))
        _log.info('Cover art de release %s almacenado en cache', mbid)


@django_rq.job('high')
def load_release_group_cover_art(release_group):
    """Carga en cache el cover art de un release group"""
    with get_redis_connection() as redis:
        mbid = release_group
        if isinstance(release_group, dict):
            mbid = release_group.get('id')

        if f'release_group_cover_art_{mbid}' in redis:
            _log.info('El cover art ya estaba guardado')
            return

        cover_art = mb.get_release_group_cover_art(mbid)
        redis.set(f'release_group_cover_art_{mbid}', json.dumps(cover_art))
        _log.info('Cover art de release group %s almacenado en cache', mbid)


@django_rq.job
def load_entities_of_recording(recording):
    """Carga en cache una grabacion y sus entidades relacionadas"""
    with get_redis_connection() as redis:
        mbid = recording
        if isinstance(recording, dict):
            mbid = recording.get('id')

        if f'recording_{mbid}' in redis:
            _log.info('La recording ya se había procesado anteriormente')
            return

        if isinstance(recording, str):
            recording = mb.get_recording_by_mbid(mbid)

        redis.set(f'recording_{mbid}', json.dumps(recording))
        _log.info('Recording %s fue almacenada correctamente', mbid)


@django_rq.job
def load_entities_of_release(release):
    """Carga en cache una release y sus entidades relacionadas"""
    with get_redis_connection() as redis:
        mbid = release
        if isinstance(release, dict):
            mbid = release.get('id')

        if f'release_{mbid}' in redis:
            _log.info('La release ya se había procesado anteriormente')
            return

        if isinstance(release, str):
            release = mb.get_release_by_mbid(mbid)

        redis.set(f'release_{mbid}', json.dumps(release))
        _log.info('Release %s fue almacenada en cache', mbid)

        load_release_cover_art.delay(release)

        offset = 0
        while True:
            recordings = mb.browse_recordings({'release': mbid}, limit=100, offset=offset)
            for recording in recordings.get('recordings'):
                load_entities_of_recording(recording)

            offset += 100
            if offset > recordings.get('recording_count', 0):
                break


@django_rq.job
def load_entities_of_release_group(release_group):
    """Carga en cache un release group y sus entidades relacionadas"""
    with get_redis_connection() as redis:
        mbid = release_group
        if isinstance(release_group, dict):
            mbid = release_group.get('id')

        if f'release_group_{mbid}' in redis:
            _log.info('La release group ya se habia procesado anteriormente')
            return

        if isinstance(release_group, str):
            release_group = mb.get_release_group_by_mbid(mbid)

        redis.set(f'release_group_{mbid}', json.dumps(release_group))
        _log.info('Release Group %s almacenado en cache', mbid)

        load_release_group_cover_art.delay(release_group)

        offset = 0
        while True:
            releases = mb.browse_releases({'release-group': mbid}, limit=100, offset=offset)
            for release in releases.get('releases'):
                load_entities_of_release(release)

            offset += 100
            if offset > releases.get('release_count', 0):
                break


@django_rq.job
def load_artist_on_cache(artist):
    """Carga en cache a un artista y todas sus entidades"""
    with get_redis_connection() as redis:
        mbid = artist
        if isinstance(artist, dict):
            mbid = artist.get('id')

        if f'artist_{mbid}' in redis:
            _log.info('El artista ya se había procesado anteriormente')
            return

        if isinstance(artist, str):
            artist = mb.get_artist_by_mbid(mbid, includes=['tags'])

        redis.set(f'artist_{mbid}', json.dumps(artist))
        _log.info('Artista %s almacenado en cache', mbid)

        offset = 0
        while True:
            release_groups = mb.browse_release_groups({'artist': mbid}, limit=100, offset=offset)
            if f'artist_{mbid}:release_group_count' not in redis:
                redis.set(f'artist_{mbid}:release_group_count',
                          release_groups.get('release_group_count'))
            for release_group in release_groups.get('release_groups'):
                release_group_id = release_group.get('id')
                redis.rpush(f'artist_{mbid}:release_groups', release_group_id)
                redis.set(f'release_group_{release_group_id}:artist', mbid)
                load_entities_of_release_group.delay(release_group)

            offset += 100
            if offset > release_groups.get('release_group_count', 0):
                break