import pytest
import allure


@pytest.mark.usefixtures("app")
class TestReleasesPayload:
    search_type = 'artist'
    
    @allure.title("[Discovery Params Artist] - Releases - TikTok Min.Videos - Payload")
    @allure.description("As user I want to search artists by releases TikTok parameters")
    @allure.testcase("https://data-analytics.atlassian.net/browse/DNAD-300")
    @pytest.mark.regression
    def test_releases_tiktok_min_videos(self):
        self.app.go_to(self.discovery_page.url)
        self.discovery_page.is_page_loaded()
        self.discovery_page.dsp_tiktok_on(True)  # DSP - TIKTOK - ON

        # TIKTOK - min_creations
        min_videos = [['5', 5],
                      ['10', 10],
                      ['25', 25],
                      ['50', 50],
                      ['100', 100],
                      ['250', 250],
                      ['500', 500],
                      ['1k+', 1000],
                      ]
        for item in min_videos:
            with self.app.page.expect_request(self.discovery_page.api_artist_total_count) as total_count:
                self.discovery_page.releases_tiktok_min_creations.slide(direction='Right', times=1)
            self.discovery_page.releases_tiktok_min_creations.has_value(item[0])
            expected = {'tiktok': {'min_videos': item[1]}}
            self.discovery_page.click_discovery_and_compare_payloads_with_diff_and_return(self.search_type, total_count, expected)

    @allure.title("[Discovery Params Artist] - Releases - TikTok Video Duration MIN - Payload")
    @allure.description("As user I want to search artists by releases TikTok parameters")
    @allure.testcase("https://data-analytics.atlassian.net/browse/DNAD-297")
    @pytest.mark.regression
    def test_releases_tiktok_video_duration_min(self):
        self.app.go_to(self.discovery_page.url)
        self.discovery_page.is_page_loaded()
        self.discovery_page.dsp_tiktok_on(True)  # DSP - TIKTOK - ON

        # TIKTOK - min_avg_duration
        min_avg_duration = [['5s', 5],
                            ['10s', 10],
                            ['20s', 20],
                            ['30s', 30],
                            ['40s', 40],
                            ['1m', 60],
                            ]
        for item in min_avg_duration:
            with self.app.page.expect_request(self.discovery_page.api_artist_total_count) as total_count:
                self.discovery_page.releases_tiktok_creation_duration_min.slide(direction='Right', times=1)
            self.discovery_page.releases_tiktok_creation_duration_min.has_value(item[0])
            self.discovery_page.releases_tiktok_creation_duration_max.has_value('3m+')
            expected = {'tiktok': {'min_avg_duration': item[1], 'max_avg_duration': 100000000000}}
            self.discovery_page.click_discovery_and_compare_payloads_with_diff_and_return(self.search_type, total_count, expected)

    @allure.title("[Discovery Params Artist] - Releases - TikTok Video Duration MAX - Payload")
    @allure.description("As user I want to search artists by releases TikTok parameters")
    @allure.testcase("https://data-analytics.atlassian.net/browse/DNAD-297")
    @pytest.mark.regression
    def test_releases_tiktok_video_duration_max(self):
        self.app.go_to(self.discovery_page.url)
        self.discovery_page.is_page_loaded()
        self.discovery_page.dsp_tiktok_on(True)  # DSP - TIKTOK - ON

        # TIKTOK - max_avg_duration
        max_avg_duration = [['5s', 5],
                            ['10s', 10],
                            ['20s', 20],
                            ['30s', 30],
                            ['40s', 40],
                            ['1m', 60],
                            ]
        for item in reversed(max_avg_duration):
            with self.app.page.expect_request(self.discovery_page.api_artist_total_count) as total_count:
                self.discovery_page.releases_tiktok_creation_duration_max.slide(direction='Left', times=1)
            self.discovery_page.releases_tiktok_creation_duration_min.has_value('0s')
            self.discovery_page.releases_tiktok_creation_duration_max.has_value(item[0])
            expected = {'tiktok': {'min_avg_duration': 0, 'max_avg_duration': item[1]}}
            self.discovery_page.click_discovery_and_compare_payloads_with_diff_and_return(self.search_type, total_count, expected)

    @allure.title("[Discovery Params Artist] - Releases - YouTube Min.Videos - Payload")
    @allure.description("As user I want to search artists by releases YouTube parameters")
    @allure.testcase("https://data-analytics.atlassian.net/browse/DNAD-717")
    @pytest.mark.regression
    def test_releases_youtube_min_videos(self):
        self.app.go_to(self.discovery_page.url)
        self.discovery_page.is_page_loaded()
        self.discovery_page.dsp_youtube_on(True)  # DSP - YOUTUBE - ON

        # YOUTUBE - min_videos
        min_videos = [['5', 5],
                      ['10', 10],
                      ['25', 25],
                      ['50', 50],
                      ['100', 100],
                      ['250', 250],
                      ['500', 500],
                      ['1k+', 1000],
                      ]
        for item in min_videos:
            with self.app.page.expect_request(self.discovery_page.api_artist_total_count) as total_count:
                self.discovery_page.releases_youtube_min_videos.slide(direction='Right', times=1)
            self.discovery_page.releases_youtube_min_videos.has_value(item[0])
            expected = {'youtube': {'min_videos': item[1]}}
            self.discovery_page.click_discovery_and_compare_payloads_with_diff_and_return(self.search_type, total_count, expected)

    @allure.title("[Discovery Params Artist] - Releases - Spotify Min.Tracks - Payload")
    @allure.description("As user I want to search artists by releases Spotify parameters")
    @allure.testcase("https://data-analytics.atlassian.net/browse/DNAD-718")
    @pytest.mark.regression
    def test_releases_spotify_min_tracks(self):
        self.app.go_to(self.discovery_page.url)
        self.discovery_page.is_page_loaded()
        self.discovery_page.dsp_spotify_on(True)  # DSP - SPOTIFY - ON

        # SPOTIFY - min_tracks
        min_tracks = [['5', 5],
                      ['10', 10],
                      ['25', 25],
                      ['50', 50],
                      ['100', 100],
                      ['250', 250],
                      ['500', 500],
                      ['1k+', 1000],
                      ]
        for item in min_tracks:
            with self.app.page.expect_request(self.discovery_page.api_artist_total_count) as total_count:
                self.discovery_page.releases_spotify_min_tracks.slide(direction='Right', times=1)
            self.discovery_page.releases_spotify_min_tracks.has_value(item[0])
            expected = {'spotify': {'min_tracks': item[1]}}
            self.discovery_page.click_discovery_and_compare_payloads_with_diff_and_return(self.search_type, total_count, expected)

    @allure.title("[Discovery Params Artist] - Releases - SoundCloud Min.Tracks - Payload")
    @allure.description("As user I want to search artists by releases SoundCloud parameters")
    @allure.testcase("https://data-analytics.atlassian.net/browse/DNAD-719")
    @pytest.mark.regression
    def test_releases_soundcloud_min_tracks(self):
        self.app.go_to(self.discovery_page.url)
        self.discovery_page.is_page_loaded()
        self.discovery_page.dsp_soundcloud_on(True)  # DSP - SOUNDCLOUD - ON

        # SOUNDCLOUD - min_tracks
        min_tracks = [['5', 5],
                      ['10', 10],
                      ['25', 25],
                      ['50', 50],
                      ['100', 100],
                      ['250', 250],
                      ['500', 500],
                      ['1k+', 1000],
                      ]
        for item in min_tracks:
            with self.app.page.expect_request(self.discovery_page.api_artist_total_count) as total_count:
                self.discovery_page.releases_soundcloud_min_tracks.slide(direction='Right', times=1)
            self.discovery_page.releases_soundcloud_min_tracks.has_value(item[0])
            expected = {'soundcloud': {'min_tracks': item[1]}}
            self.discovery_page.click_discovery_and_compare_payloads_with_diff_and_return(self.search_type, total_count, expected)