import unittest

import allure
import pytest
from assertpy import assert_that
from faker import Faker

from app.src.helpers.api_data_provider import ApiDataProvider
from app.src.pages.chart_digest_page import ChartDigestPage
from app.src.pages.login_page import LoginPage
from app.src.pages.profile_page import ProfilePage
from app.src.pages.search_page import SearchPage
from app.src.pages.starred_page import StarredPage
from app.src.pages.track_page import TrackPage


@pytest.mark.usefixtures("set_up", "one_time_set_up", "authorized_api")
class TrackMarketsTest(unittest.TestCase):
    @pytest.fixture(autouse=True)
    def classSetup(self, authorized_api):
        self.api = authorized_api
        self.loginPage = LoginPage(self.driver, authorized_api)
        self.chartDigestPage = ChartDigestPage(self.driver, authorized_api)
        self.starredPage = StarredPage(self.driver, authorized_api)
        self.trackPage = TrackPage(self.driver, authorized_api)
        self.searchPage = SearchPage(self.driver, authorized_api)
        self.profilePage = ProfilePage(self.driver)
        self.data_provider = ApiDataProvider(authorized_api)
        self.fake = Faker()

    @allure.story("https://data-analytics.atlassian.net/browse/AG-5267")
    @allure.severity(allure.severity_level.NORMAL)
    @allure.title("Markets availability")
    @allure.description("User should be open to see markets section on a track page")
    @allure.testcase("https://data-analytics.atlassian.net/browse/AG-4824," "https://data-analytics.atlassian.net/browse/AG-4864," "https://data-analytics.atlassian.net/browse/AG-4863")
    @pytest.mark.smoke
    def test_markets_availability_global(self):
        track_without_charts = "Sheena is a Punk"
        market = "United States"

        self.loginPage.login_as_notifications_user()
        self.searchPage.search_for(track_without_charts).open_track_page_from_results(1)
        assert_that(self.trackPage.is_markets_section_available_without_data_global(), "Verified markets availability").is_true()

        self.trackPage.click_back_button().swipe_back()
        self.profilePage.open_profile_screen_and_select_market(market).select_search_tab()
        self.searchPage.search_for("Dance Monkey").open_track_page_from_results(1)
        assert_that(self.trackPage.is_markets_section_available_with_data(), "Verified markets availability").is_true()

        self.trackPage.click_back_button()
        self.searchPage.clear_search_field().search_for(track_without_charts).open_track_page_from_results(1)
        assert_that(self.trackPage.is_markets_section_available_with_data_market(), "Verified markets availability").is_true()

    @allure.story("AG-5936")
    @allure.severity(allure.severity_level.NORMAL)
    @allure.title("Availability for market selector button")
    @allure.description("Market selector button should be available tn the track page for users market set as Global")
    @allure.testcase("https://data-analytics.atlassian.net/browse/AG-5247," "https://data-analytics.atlassian.net/browse/AG-5227," "https://data-analytics.atlassian.net/browse/AG-5223," "https://data-analytics.atlassian.net/browse/AG-5304")
    @pytest.mark.smoke
    def test_market_selector_main_track_page(self):
        new_market = "Canada"
        track = self.data_provider.get_top_charts_spotify_track_data()

        self.loginPage.login_as_notifications_user().select_search_tab()
        self.searchPage.search_for(track[0])
        track_name = self.searchPage.get_result_track_title(1)
        self.searchPage.open_track_page_from_results(1)
        assert_that(self.trackPage.is_track_page_opened(track_name), "Verified track page is opened").is_true()
        assert_that(self.trackPage.is_market_selection_card_displayed(), "Verified market selection available").is_true()

        self.trackPage.click_select_market_button().select_market_via_search(new_market)
        assert_that(self.trackPage.is_market_selected("CA", new_market), "Market is updated on the track page").is_true()

        self.trackPage.close_track_page()
        self.searchPage.select_starred_tracks_tab()
        self.starredPage.click_market_icon()
        starred_market = self.starredPage.get_market()
        assert_that(starred_market).is_equal_to(new_market)

        self.starredPage.close_popup_tap_outside().select_chart_digest_tab()
        self.chartDigestPage.open_full_charts().click_filter_selection()
        starred_market = self.chartDigestPage.get_market_full_charts()
        assert_that(starred_market).is_equal_to(new_market)

        self.chartDigestPage.close_popup_tap_outside().click_back_button().select_profile_tab()
        self.profilePage.open_markets()
        home_market = self.profilePage.get_market_name_by_position_with_icons(2)
        assert_that(home_market).contains(new_market)

    @allure.story("AG-5936")
    @allure.severity(allure.severity_level.NORMAL)
    @allure.title("Navigation back and Cancel on market selector")
    @allure.description("User should be able to cancel market selection")
    @allure.testcase("https://data-analytics.atlassian.net/browse/AG-5226," "https://data-analytics.atlassian.net/browse/AG-5225")
    @pytest.mark.smoke
    def test_market_selector_cancel(self):
        new_market = "Canada"
        track = self.data_provider.get_top_charts_spotify_track_data()

        self.loginPage.login_as_notifications_user().select_search_tab()
        self.searchPage.search_for(track[0])
        track_name = self.searchPage.get_result_track_title(1)
        self.searchPage.open_track_page_from_results(1)
        assert_that(self.trackPage.is_track_page_opened(track_name), "Verified track page is opened").is_true()
        assert_that(self.trackPage.is_market_selection_card_displayed(), "Verified market selection available").is_true()

        self.trackPage.click_select_market_button().select_market_from_the_list_and_cancel(new_market).click_back_button()
        self.searchPage.select_starred_tracks_tab()
        self.starredPage.click_market_icon()
        starred_market = self.starredPage.get_market()
        assert_that(starred_market).is_equal_to("Global")