import datetime
from collections import namedtuple

from apollo_notifications.charts import PushChartsBaseSchema
from apollo_notifications.charts.client import SpotifyChart
from apollo_notifications.charts.config import ChartsConfig, ChartsSchemaConfig
from apollo_notifications.constants import SPOTIFY_TRACK_PREFIX, SPOTIFY_URL_PREFIX
from tests import factories

Track = namedtuple('Track', ['name', 'url', 'artist_name', 'uri', 'isrc'])


class SpotifyChartsConfig(ChartsConfig):
    VENDOR: str = "SPOTIFY"
    TOPIC: str = "test"


class SpotifyChartsSchemaConfig(ChartsSchemaConfig):
    VENDOR: str = "SPOTIFY"
    TOPIC: str = "test"
    MESSAGE_TEMPLATE: str = "🔥 {artist_name} - {track_name} entered " \
                            "Spotify Daily Top 200 Chart {country_flag} at position {position}"
    PUSH_TARGET: str = "test"
    TITLE: str = ""


def get_formatted_today_yesterday():
    today = datetime.date.today()
    yesterday = today - datetime.timedelta(days=1)
    return today.strftime("%Y-%m-%d"), yesterday.strftime("%Y-%m-%d")


def test_get_dates(db_session):
    today, yesterday = get_formatted_today_yesterday()
    market = 'us'
    factories.SpotifyChartsFactory.create(date=today, market=market)
    factories.SpotifyChartsFactory.create(date=yesterday, market=market)
    factories.SpotifyChartsFactory.create_batch(size=10, market=market)

    config = SpotifyChartsConfig()
    notifications_client = SpotifyChart(config)
    dates = notifications_client.get_dates(market)
    assert dates == [today, yesterday]


def test_get_spotify_chart_entries(db_session):
    today, yesterday = get_formatted_today_yesterday()
    market = 'us'
    track_1 = Track(
        name='track 1',
        url=f'{SPOTIFY_URL_PREFIX}1',
        uri=f'{SPOTIFY_TRACK_PREFIX}1',
        artist_name='artist 1',
        isrc='USRC11901901'
    )
    track_2 = Track(
        name='track 2',
        url=f'{SPOTIFY_URL_PREFIX}2',
        uri=f'{SPOTIFY_TRACK_PREFIX}2',
        artist_name='artist 2',
        isrc='USRC11901902'
    )
    factories.SpotifyTrack2Factory.create(id=track_1.uri.replace(SPOTIFY_TRACK_PREFIX, ''), isrc=track_1.isrc)
    factories.SpotifyTrack2Factory.create(id=track_2.uri.replace(SPOTIFY_TRACK_PREFIX, ''), isrc=track_2.isrc)

    # create charts entities
    factories.SpotifyChartsFactory.create(
        position=6,
        track_url=track_1.url,
        artist_name=track_1.artist_name,
        track_name=track_1.name,
        market=market,
        date=yesterday,
        isrc=track_1.isrc
    )
    for i, track in enumerate([track_1, track_2], start=1):
        factories.SpotifyChartsFactory.create(
            position=i,
            track_url=track.url,
            artist_name=track.artist_name,
            track_name=track.name,
            market=market,
            date=today,
            isrc=track.isrc
        )

    config = SpotifyChartsConfig()
    notifications_client = SpotifyChart(config)
    added_tracks = notifications_client.get_diff_tracks_by_dates(market, start_date=today, end_date=yesterday).all()
    assert len(added_tracks) == 1
    assert added_tracks[0].track_id == track_2.uri.replace(SPOTIFY_TRACK_PREFIX, '')
    assert added_tracks[0].position == 2
    assert added_tracks[0].isrc == track_2.isrc


def test_get_spotify_chart_exits(db_session):
    today, yesterday = get_formatted_today_yesterday()
    market = 'us'
    existing_track = Track(
        name='track 1',
        url=f'{SPOTIFY_URL_PREFIX}1',
        uri=f'{SPOTIFY_TRACK_PREFIX}1',
        artist_name='artist 1',
        isrc='USRC11901901'
    )
    dropped_track = Track(
        name='track 2',
        url=f'{SPOTIFY_URL_PREFIX}2',
        uri=f'{SPOTIFY_TRACK_PREFIX}2',
        artist_name='artist 2',
        isrc='USRC11901902'
    )
    factories.SpotifyTrack2Factory.create(
        id=existing_track.uri.replace(SPOTIFY_TRACK_PREFIX, ''), isrc=existing_track.isrc)
    factories.SpotifyTrack2Factory.create(
        id=dropped_track.uri.replace(SPOTIFY_TRACK_PREFIX, ''), isrc=dropped_track.isrc)

    # create charts entities
    factories.SpotifyChartsFactory.create(
        position=1,
        track_url=existing_track.url,
        artist_name=existing_track.artist_name,
        track_name=existing_track.name,
        market=market,
        date=yesterday,
        isrc=existing_track.isrc
    )

    factories.SpotifyChartsFactory.create(
        position=2,
        track_url=dropped_track.url,
        artist_name=dropped_track.artist_name,
        track_name=dropped_track.name,
        market=market,
        date=yesterday,
        isrc=dropped_track.isrc
    )

    factories.SpotifyChartsFactory.create(
        position=1,
        track_url=existing_track.url,
        artist_name=existing_track.artist_name,
        track_name=existing_track.name,
        market=market,
        date=today,
        isrc=existing_track.isrc
    )

    config = SpotifyChartsConfig()
    notifications_client = SpotifyChart(config)
    dropped_tracks = notifications_client.get_diff_tracks_by_dates(market, start_date=yesterday, end_date=today).all()
    assert len(dropped_tracks) == 1
    assert dropped_tracks[0].track_id == dropped_track.uri.replace(SPOTIFY_TRACK_PREFIX, '')
    assert dropped_tracks[0].position == 2
    assert dropped_tracks[0].isrc == dropped_track.isrc


def get_filtered_query(track, starred_track, market, date, user_id, client, session):
    factories.SpotifyTrack2Factory.create(id=track.uri.replace(SPOTIFY_TRACK_PREFIX, ''), isrc=track.isrc)
    factories.SpotifyTrack2Factory.create(
        id=starred_track.uri.replace(SPOTIFY_TRACK_PREFIX, ''), isrc=starred_track.isrc)

    market = factories.MarketFactory.create(market_name=market)

    factories.SpotifyChartsFactory.create(
        position=1,
        track_url=track.url,
        artist_name=track.artist_name,
        track_name=track.name,
        market=market.market_name,
        date=date,
        isrc=track.isrc
    )
    factories.SpotifyChartsFactory.create(
        position=2,
        track_url=starred_track.url,
        artist_name=starred_track.artist_name,
        track_name=starred_track.name,
        market=market.market_name,
        date=date,
        isrc=starred_track.isrc
    )

    # mark track as starred
    factories.UserMarketFactory.create(user_id=user_id, market_id=market.market_id)
    factories.StarredContentFactory.create(user_id=user_id, uri=starred_track.uri, isrc=starred_track.isrc)
    factories.UserDeviceFactory.create_batch(
        size=2, user_id=user_id, is_active=False)
    factories.UserDeviceFactory.create_batch(
        size=3, user_id=user_id, is_active=True)

    tracks_query = client._get_base_query(session, market.market_name, date=date)
    return client.filter_by_starred_and_active(tracks_query, [user_id])


def test_spotify_chart_schema(db_session):
    market = "us"
    user_id = "user_id"

    track = Track(
        name='track 1',
        url=f'{SPOTIFY_URL_PREFIX}1',
        uri=f'{SPOTIFY_TRACK_PREFIX}1',
        artist_name='artist 1',
        isrc='USRC11901901'
    )
    starred_track = Track(
        name='track 2',
        url=f'{SPOTIFY_URL_PREFIX}2',
        uri=f'{SPOTIFY_TRACK_PREFIX}2',
        artist_name='artist 2',
        isrc='USRC11901902'
    )
    today, _ = get_formatted_today_yesterday()

    client_config = SpotifyChartsConfig()
    schema_config = SpotifyChartsSchemaConfig()
    notifications_client = SpotifyChart(client_config)
    schema = PushChartsBaseSchema(schema_config, today, market)

    starred_track = get_filtered_query(
        track, starred_track, market, today, user_id, notifications_client, db_session).all()[0]
    data = schema.dump(starred_track)

    assert data["title"] == schema_config.TITLE
    assert data["user_id"] == starred_track.user_id
    assert data["tokens"] == starred_track.device_tokens.split(',')
    inner_data = data["data"]
    assert data["id"] == inner_data["id"]
    assert inner_data["track_name"] == starred_track.track_name
    assert inner_data["vendor"] == schema_config.VENDOR
    assert inner_data["artist_name"] == starred_track.artist_name
    assert inner_data["track_id"] == starred_track.track_id
    assert inner_data["target"] == schema_config.PUSH_TARGET
    assert inner_data["country_code"] == market
    assert inner_data["topic"] == schema_config.TOPIC
    assert inner_data["position"] == starred_track.position
    assert inner_data["isrc"] == starred_track.isrc


def test_get_filtered_tracks(db_session):
    market = "us"
    user_id = "user_id"

    track = Track(
        name='track 1',
        url=f'{SPOTIFY_URL_PREFIX}1',
        uri=f'{SPOTIFY_TRACK_PREFIX}1',
        artist_name='artist 1',
        isrc='USRC11901901'
    )
    starred_track = Track(
        name='track 2',
        url=f'{SPOTIFY_URL_PREFIX}2',
        uri=f'{SPOTIFY_TRACK_PREFIX}2',
        artist_name='artist 2',
        isrc='USRC11901902'
    )
    today, _ = get_formatted_today_yesterday()

    client_config = SpotifyChartsConfig()
    notifications_client = SpotifyChart(client_config)

    starred_tracks = get_filtered_query(
        track, starred_track, market, today, user_id, notifications_client, db_session).all()

    assert len(starred_tracks) == 1
    assert starred_tracks[0].user_id == user_id
    assert starred_tracks[0].track_id == starred_track.uri.replace(SPOTIFY_TRACK_PREFIX, '')
    assert starred_tracks[0].position == 2
    assert len(starred_tracks[0].device_tokens.split(',')) == 3