import pytest
import allure
from datetime import datetime
from assertpy import assert_that

from src.helpers.utils import calc_days_ago

entity_type = 'artist'
input_soundcloud_followers = [
    (0, 1000),
    (1000, 5000),
    (5000, 10000),
    (10000, 25000),
    (25000, 50000),
    (50000, 100000),
    (100000, 250000),
    (250000, 500000),
    (500000, 1000000),
    (1000000, 5000000),
    (5000000, 100000000000)
]
input_soundcloud_min_tracks = [5, 10, 25, 50, 100, 250, 500, 1000]
input_soundcloud_plays = [
    (0, 5000),
    (5000, 10000),
    (10000, 25000),
    (25000, 50000),
    (50000, 100000),
    (100000, 1000000),
    (1000000, 5000000),
    (5000000, 10000000),
    (10000000, 100000000000),
]
input_soundcloud_likes = [
    (0, 10),
    (10, 50),
    (50, 100),
    (100, 500),
    (500, 1000),
    (1000, 10000),
    (10000, 50000),
    (50000, 100000000000),
]
input_soundcloud_comments = [
    (0, 10),
    (10, 50),
    (50, 100),
    (100, 500),
    (500, 1000),
    (1000, 10000),
    (10000, 50000),
    (50000, 100000000000),
]
input_soundcloud_latest_release = [7, 28, 56, 84]


@allure.testcase("https://data-analytics.atlassian.net/browse/DNAD-1604")
@pytest.mark.parametrize("min_val, max_val", input_soundcloud_followers)
def test_soundcloud_followers(api, min_val, max_val):
    data = {"soundcloud": {"min_followers": min_val, "max_followers": max_val}}
    entities = api.get_entities(entity_type=entity_type, discovery_data=data)
    for entity in entities:
        tested_value = float(entity['soundcloud']['followers']['current_value'])
        api.check_entity_in_range(entity, tested_value, min_val, max_val)


@allure.testcase("https://data-analytics.atlassian.net/browse/DNAD-1604")
@pytest.mark.parametrize("min_val", input_soundcloud_min_tracks)
def test_soundcloud_min_tracks(api, min_val):
    data = {"soundcloud": {"min_tracks": min_val}}
    entities = api.get_entities(entity_type=entity_type, discovery_data=data)
    for entity in entities:
        tested_value = float(entity['soundcloud']['tracks']['current_value'])
        api.check_entity_in_range(entity, tested_value)


@allure.testcase("https://data-analytics.atlassian.net/browse/DNAD-1604")
@pytest.mark.parametrize("min_val, max_val", input_soundcloud_plays)
def test_soundcloud_plays(api, min_val, max_val):
    data = {"soundcloud": {"min_plays": min_val, "max_plays": max_val}}
    entities = api.get_entities(entity_type=entity_type, discovery_data=data)
    for entity in entities:
        tested_value = float(entity['soundcloud']['plays']['current_value'])
        api.check_entity_in_range(entity, tested_value, min_val, max_val)


@allure.testcase("https://data-analytics.atlassian.net/browse/DNAD-1604")
@pytest.mark.parametrize("min_val, max_val", input_soundcloud_likes)
def test_soundcloud_likes(api, min_val, max_val):
    data = {"soundcloud": {"min_likes": min_val, "max_likes": max_val}}
    entities = api.get_entities(entity_type=entity_type, discovery_data=data)
    for entity in entities:
        tested_value = float(entity['soundcloud']['likes']['current_value'])
        api.check_entity_in_range(entity, tested_value, min_val, max_val)


@allure.testcase("https://data-analytics.atlassian.net/browse/DNAD-1604")
@pytest.mark.parametrize("min_val, max_val", input_soundcloud_comments)
def test_soundcloud_comments(api, min_val, max_val):
    data = {"soundcloud": {"min_comments": min_val, "max_comments": max_val}}
    entities = api.get_entities(entity_type=entity_type, discovery_data=data)
    for entity in entities:
        tested_value = float(entity['soundcloud']['comments']['current_value'])
        api.check_entity_in_range(entity, tested_value, min_val, max_val)


@allure.testcase("https://data-analytics.atlassian.net/browse/DNAD-1604")
@pytest.mark.parametrize("max_val", input_soundcloud_latest_release)
def test_soundcloud_latest_release(api, max_val):
    data = {"soundcloud": {"min_latest_release_days": max_val}}
    entities = api.get_entities(entity_type=entity_type, discovery_data=data)
    for entity in entities:
        latest_release_date = entity['soundcloud']['latest_release_date']
        days_ago = calc_days_ago(latest_release_date, '%Y-%m-%d')
        tested_value = float(days_ago)
        api.check_entity_in_range(entity, tested_value, max_val=max_val)


@allure.testcase("https://data-analytics.atlassian.net/browse/DNAD-1604")
def test_soundcloud_chart_type(api):
    data = {"soundcloud": {"chart_type": "PLAYS"}}
    entities = api.get_entities(entity_type=entity_type, discovery_data=data)
    for entity in entities:
        actual_chart_type = entity['soundcloud']['chart_type']
        assert_that(actual_chart_type == 'plays').is_true()

    data = {"soundcloud": {"chart_type": "LIKES"}}
    entities = api.get_entities(entity_type=entity_type, discovery_data=data)
    for entity in entities:
        actual_chart_type = entity['soundcloud']['chart_type']
        assert_that(actual_chart_type == 'likes').is_true()

    data = {"soundcloud": {"chart_type": "COMMENTS"}}
    entities = api.get_entities(entity_type=entity_type, discovery_data=data)
    for entity in entities:
        actual_chart_type = entity['soundcloud']['chart_type']
        assert_that(actual_chart_type == 'comments').is_true()

    data = {"soundcloud": {}}
    entities = api.get_entities(entity_type=entity_type, discovery_data=data)
    for entity in entities:
        actual_chart_type = entity['soundcloud']['chart_type']
        assert_that(actual_chart_type == 'followers').is_true()