import json
import flag
from redis import StrictRedis
from sqlalchemy.orm.session import Session
from sqlalchemy import distinct, func

from apollo_main_db.apollo import PlaylistBlacklist
from apollo_main_db.apple.models import AppleMusicContainerStreamSummary

from apple_playlists_additions_notifications import constants
from apple_playlists_additions_notifications.redis_db import get_key


def is_new_track(
        date: str, playlist_id: str, song_id: str, market: str, user_id: str, redis_client
) -> bool:
    """Checking is track new or we have already fetch it today

    Args:
        date (str): Date with %Y-%m-%d format.
        playlist_id (str): Playlist ID.
        song_id (str): Song ID.
        market (str): Market short name.
        user_id (str): User ID.
        redis_client: Redis client.
    Returns:
        Boolean
    """
    redis_key = get_key(f'{date}/{market}/{playlist_id}/{user_id}')
    if redis_client.sismember(redis_key, song_id):
        return False

    redis_client.sadd(redis_key, song_id)
    redis_client.expire(redis_key, constants.REDIS_KEY_TTL)
    return True


def add_to_already_sent(date: str, playlist_id: str, song_id: str, market: str, user_id: str, redis_client):
    """Append track push to already list of already sent one.

    Args:
        date (str): Date with %Y-%m-%d format.
        playlist_id (str): Playlist ID.
        song_id (str): Song ID.
        market (str): Market short name.
        user_id (str): User ID.
        redis_client: Redis client.
    """

    redis_key = get_key(f'{date}/{market}/{playlist_id}/{user_id}')
    if redis_client.sismember(redis_key, song_id):
        return
    redis_client.sadd(redis_key, song_id)


def get_blacklisted_ids(db_session: Session, redis_client: StrictRedis) -> list:
    redis_key = get_key(f'blacklist/{constants.VENDOR_NAME}')
    cached_value = redis_client.get(redis_key)

    if cached_value:
        return json.loads(cached_value)

    query = db_session.query(
        PlaylistBlacklist.playlist_id
    ).filter(
        PlaylistBlacklist.vendor == constants.VENDOR_NAME
    )

    playlist_ids = [str(q.playlist_id) for q in query]
    redis_client.setex(redis_key, constants.BLACKLIST_TTL, json.dumps(playlist_ids, default=str))
    return playlist_ids


def get_country_codes_from_db(db_session: Session) -> list:
    # NB: GLOBAL market should be the last one in a list of country codes.
    query = (
        db_session.query(
            distinct(AppleMusicContainerStreamSummary.country_code).label("country_code")
        ).order_by(
            func.length(AppleMusicContainerStreamSummary.country_code),
            AppleMusicContainerStreamSummary.country_code
        )
    )
    return [q.country_code for q in query.all()]


def get_country_code(country_code: str or None) -> str:
    if not country_code:
        return ''

    _country_code = country_code.lower()
    if _country_code in [constants.APOLLO_GLOBAL_MARKET, constants.GLOBAL_MARKET]:
        return constants.APOLLO_GLOBAL_MARKET

    return _country_code


def get_country_flag(country_code: str or None) -> str:
    if not country_code:
        return ''
    return '🌍' if country_code == constants.APOLLO_GLOBAL_MARKET else flag.flag(country_code)


def build_push_message(track: object, country_flag: str) -> str:
    message = constants.MESSAGE_TEMPLATE.format(
        artist_name=track.artist_name,
        track_name=track.song_name,
        playlist_name=track.playlist_name,
        position=track.position + 1,
        country_flag=country_flag
    )
    return message.strip()