import logging
import unittest
from datetime import datetime

import allure
import pytest
from assertpy import assert_that
from faker import Faker
from ui_automation_framework.utils import AppConfig
from ui_automation_framework.utils import logger as cl
from waiting import ALL

from app.src.helpers.api_data_provider import ApiDataProvider
from app.src.helpers.data_formaters import DataFormatter
from app.src.helpers.waiting_wrapper import wait
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 TrackChartsPlacementsTest(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.api_helper = ApiDataProvider(authorized_api)
        self.log = cl.Logger(logging.DEBUG)
        self.fake = Faker()

    @allure.story("https://data-analytics.atlassian.net/browse/AG-5266")
    @allure.severity(allure.severity_level.NORMAL)
    @allure.title("Charts availability")
    @allure.description("User should be open to see charts section on a track page")
    @allure.testcase("https://data-analytics.atlassian.net/browse/AG-2904," "https://data-analytics.atlassian.net/browse/AG-2905," "https://data-analytics.atlassian.net/browse/AG-2917")
    @pytest.mark.smoke
    def test_chart_placement_availability(self):
        test_data = self.api_helper.get_top_track_data_for_spotify_and_apple_for_chart_widget()
        track_with_charts = test_data[0]
        track_without_charts = "Sheena is a Punk"

        self.loginPage.login_as_regular_user().select_search_tab()
        self.searchPage.search_for(track_with_charts).open_track_page_from_results(1)
        wait(ALL([self.trackPage.lb_markets_title.is_present, self.trackPage.bn_charts_apple.is_present]))
        # self.trackPage.driver.scroll(self.trackPage.lb_markets_title._element, self.trackPage.bn_charts_apple._element)
        self.trackPage.swipe_down().swipe_down()
        assert_that(self.trackPage.is_charts_section_available_with_data(), "Verified charts placemets availability").is_true()

        self.trackPage.click_back_button()
        self.searchPage.clear_search_field().search_for(track_without_charts).open_track_page_from_results(1)
        # self.trackPage.scroll_to_chart_placements()
        assert_that(self.trackPage.is_charts_section_available_without_data(), "Verified charts placemets availability").is_true()

    @allure.story("https://data-analytics.atlassian.net/browse/AG-5266")
    @allure.severity(allure.severity_level.NORMAL)
    @allure.title("Pagination")
    @allure.description("User should be able to scroll charts page")
    @allure.testcase("https://data-analytics.atlassian.net/browse/AG-2972," "https://data-analytics.atlassian.net/browse/AG-2962")
    @pytest.mark.smoke
    def test_chart_placement_pagination(self):
        self.loginPage.login_as_regular_user().select_chart_digest_tab()
        self.chartDigestPage.open_full_charts().open_track_from_full_charts(1)
        self.trackPage.scroll_to_chart_placements().click_apple_charts()
        total_number_of_charts_before_scroll = len(self.trackPage.get_chart_placements_data())
        last_track = self.trackPage.get_chart_title(total_number_of_charts_before_scroll)
        self.trackPage.scroll_on_the_charts()
        total_number_of_charts_after_scroll = len(self.trackPage.get_chart_placements_data())
        updated_last_track = self.trackPage.get_chart_title(total_number_of_charts_after_scroll)
        assert_that(updated_last_track, "Pagination check").is_not_equal_to(last_track)

        self.trackPage.click_back_button().click_spotify_charts()
        total_number_of_charts_before_scroll = len(self.trackPage.get_chart_placements_data())
        last_track = self.trackPage.get_chart_title(total_number_of_charts_before_scroll)
        self.trackPage.scroll_on_the_charts()
        total_number_of_charts_after_scroll = len(self.trackPage.get_chart_placements_data())
        updated_last_track = self.trackPage.get_chart_title(total_number_of_charts_after_scroll)
        assert_that(updated_last_track, "Pagination check").is_not_equal_to(last_track)

    @allure.story("https://data-analytics.atlassian.net/browse/AG-5266")
    @allure.severity(allure.severity_level.NORMAL)
    @allure.title("Charts unavailability")
    @allure.description("User should be able to see if chart is unavailable")
    @allure.testcase("https://data-analytics.atlassian.net/browse/AG-4672," "https://data-analytics.atlassian.net/browse/AG-4671")
    @pytest.mark.regression
    def test_chart_unavailability(self):
        market = "Australia"
        track_without_apple_charts = "Reminding Me"
        track_without_spotify_charts = "Celestial"

        self.loginPage.login_as_regular_user()
        self.profilePage.open_profile_screen_and_select_market(market).select_search_tab()
        self.searchPage.search_for(track_without_apple_charts).open_track_page_from_results(1)
        wait(self.trackPage.is_apple_charts_unavailable, waiting_for="Verified charts placement unavailable for Apple")

        self.trackPage.close_track_page()
        self.searchPage.clear_search_field().search_for(track_without_spotify_charts).open_track_page_from_results(1)
        wait(
            self.trackPage.is_spotify_charts_unavailable,
            waiting_for="Verified charts placement unavailable for Spotify",
        )

    @allure.story("https://data-analytics.atlassian.net/browse/AG-6817")
    @allure.severity(allure.severity_level.NORMAL)
    @allure.title("Charts card content apple")
    @allure.description("All card content should be displayed and accordingly to API")
    @allure.testcase("https://data-analytics.atlassian.net/browse/AG-3001")
    @pytest.mark.smoke
    def test_chart_card_content_apple(self):
        test_data = self.api_helper.get_top_track_data_for_spotify_and_apple_for_chart_widget()
        test_track_name = test_data[0]
        test_track_isrc = test_data[1]
        charts_data_api = self.api.apollo.get_charts_summary(test_track_isrc, "apple", 20, 0, sort_by="rank")["body"]["items"]

        self.loginPage.login_as_regular_user()
        self.searchPage.search_for(test_track_name).open_track_page_from_results(1)
        self.trackPage.scroll_to_chart_placements().click_apple_charts()

        charts_data_ui = self.trackPage.get_chart_placements_data()

        for i in range(len(charts_data_api)):
            formatted_data = self.format_api_charts_data(charts_data_api[i])
            country_name = formatted_data["country"].split()
            if len(country_name) > 3:
                country_name = f"{country_name[0]} {country_name[1]}"
            else:
                country_name = formatted_data["country"]

            expected_added_date = DataFormatter.convert_days_to_years(formatted_data["added_date"])
            assert_that(charts_data_ui[i].lower(), "Countries matching").contains(country_name.replace("Czech Republic", "Czechia").lower())
            assert_that(charts_data_ui[i]).described_as("Dates").contains(formatted_data["date"]).described_as("Added dates").contains(expected_added_date).described_as("Positions").contains(str(formatted_data["position"])).described_as("Trends").contains(formatted_data["trend"]).described_as(
                "Trend values"
            ).contains(str(formatted_data["trend_value"]))

    @allure.story("https://data-analytics.atlassian.net/browse/AG-6817")
    @allure.severity(allure.severity_level.NORMAL)
    @allure.title("Charts card content spotify")
    @allure.description("All card content should be displayed and accordingly to API")
    @allure.testcase("https://data-analytics.atlassian.net/browse/AG-3001")
    @pytest.mark.smoke
    def test_chart_card_content_spotify(self):
        test_data = self.api_helper.get_top_charts_spotify_track_data()
        test_track_name = test_data[0]
        test_track_isrc = test_data[1]
        charts_data_api = self.api.apollo.get_charts_summary(test_track_isrc, "spotify", 20, 0, sort_by="rank")["body"]["items"]

        self.loginPage.login_as_regular_user()
        self.searchPage.search_for(test_track_name).open_track_page_from_results(1)
        self.trackPage.scroll_to_chart_placements().click_spotify_charts()

        charts_data_ui = self.trackPage.get_chart_placements_data()

        for i in range(len(charts_data_api)):
            formatted_data = self.format_api_charts_data(charts_data_api[i])
            self.log.info(formatted_data)
            assert_that(charts_data_ui[i]).contains(formatted_data["country"].replace(" and ", " And ").replace("Czech Republic", "Czechia"))
            assert_that(charts_data_ui[i]).described_as("Dates").contains(formatted_data["date"]).described_as("Added dates").contains(DataFormatter.convert_days_to_years(formatted_data["added_date"])).described_as("Position").contains(str(formatted_data["position"])).described_as(
                "Trends"
            ).contains(formatted_data["trend"]).described_as("Trend values").contains(str(formatted_data["trend_value"]))

    @allure.story("https://data-analytics.atlassian.net/browse/AG-6817")
    @allure.severity(allure.severity_level.NORMAL)
    @allure.title("Chart widgets data")
    @allure.description("Chart placements widgets on a track page should display actual data")
    @allure.testcase("https://data-analytics.atlassian.net/browse/AG-2925" "https://data-analytics.atlassian.net/browse/AG-3023")
    @pytest.mark.regression
    def test_chart_widgets(self):
        test_data = self.api_helper.get_top_track_data_for_spotify_and_apple_for_chart_widget()
        test_track_name = test_data[0]
        charts_data_api_spotify = test_data[2]
        charts_data_api_apple = test_data[3]

        top_market = sorted(charts_data_api_spotify, key=lambda x: (x["streams"]))[-1]["country_name"]

        self.loginPage.login_as_regular_user()
        self.searchPage.search_for(test_track_name).open_track_page_from_results(1)
        self.trackPage.scroll_to_chart_placements()

        spotify_widget_data = self.trackPage.get_spotify_widget_data()
        apple_widget_data = self.trackPage.get_apple_widget_data()

        spotify_charts_count = self.trackPage.get_chats_count_from_chart_widget(spotify_widget_data)
        apple_charts_count = self.trackPage.get_chats_count_from_chart_widget(apple_widget_data)
        assert_that(spotify_widget_data).described_as("Spotify chart widget content").contains("Spotify").described_as("Top market for Spotify chart widget card").contains(f"Top Market: {top_market}")
        assert_that(apple_widget_data, "Apple chart widget content").contains("Apple Music")
        assert_that(charts_data_api_apple, "Chart totals ").is_length(int(apple_charts_count))
        assert_that(charts_data_api_spotify, "Chart totals ").is_length(int(spotify_charts_count))

    @allure.story("https://data-analytics.atlassian.net/browse/AG-6817")
    @allure.severity(allure.severity_level.NORMAL)
    @allure.title("Chart placements sorting")
    @allure.description("Charts should be sorted in alphabetical order")
    @allure.testcase("https://data-analytics.atlassian.net/browse/AG-2995" "https://data-analytics.atlassian.net/browse/AG-2986")
    @pytest.mark.regression
    def test_chart_sorting(self):
        test_track_name = AppConfig.get("chart_placement_track_data_spotify")[0]

        self.loginPage.login_as_regular_user()
        self.searchPage.search_for(test_track_name).open_track_page_from_results(1)
        self.trackPage.scroll_to_chart_placements().click_spotify_charts()

        # spotify_charts = [chart.split()[0] for chart in self.trackPage.get_chart_placements_data()]
        # assert_that(spotify_charts, 'Sorting order').is_sorted()

        self.trackPage.click_back_button().click_apple_charts()
        # apple_charts = [chart.split()[0] for chart in self.trackPage.get_chart_placements_data()]
        # assert_that(apple_charts, 'Sorting order').is_sorted()

    @allure.story("https://data-analytics.atlassian.net/browse/AG-6817")
    @allure.severity(allure.severity_level.NORMAL)
    @allure.title("Chart placements sorting. Search")
    @allure.description("Charts should be sorted in alphabetical order")
    @allure.testcase("https://data-analytics.atlassian.net/browse/AG-5395")
    @pytest.mark.regression
    def test_charts_sorting_search(self):
        test_track_name = AppConfig.get("chart_placement_track_data_spotify")[0]
        query = "an"

        self.loginPage.login_as_regular_user()
        self.searchPage.search_for(test_track_name).open_track_page_from_results(1)
        self.trackPage.click_spotify_charts()
        self.trackPage.search_in_charts(query)

        spotify_charts = [chart.split()[0] for chart in self.trackPage.get_chart_placements_data()]
        assert_that(spotify_charts).is_sorted()

        self.trackPage.click_back_button().click_apple_charts()
        self.trackPage.search_in_charts(query)
        apple_charts = [chart.split()[0] for chart in self.trackPage.get_chart_placements_data()]
        assert_that(apple_charts).is_sorted()

    @allure.story("https://data-analytics.atlassian.net/browse/AG-6817")
    @allure.severity(allure.severity_level.NORMAL)
    @allure.title("Chart placements search")
    @allure.description("Charts placements search field states")
    @allure.testcase(
        "https://data-analytics.atlassian.net/browse/AG-5389"
        "https://data-analytics.atlassian.net/browse/AG-5388"
        "https://data-analytics.atlassian.net/browse/AG-5387"
        "https://data-analytics.atlassian.net/browse/AG-5386"
        "https://data-analytics.atlassian.net/browse/AG-5385"
        "https://data-analytics.atlassian.net/browse/AG-5383"
        "https://data-analytics.atlassian.net/browse/AG-5382"
        "https://data-analytics.atlassian.net/browse/AG-5381"
    )
    @pytest.mark.regression
    def test_charts_search_spotify(self):
        test_data = self.api_helper.get_top_track_data_for_spotify_and_apple_for_chart_widget()
        test_track_name = test_data[0]
        query = "An"
        full_query = "United States"
        no_results_query = "007"

        self.loginPage.login_as_regular_user()
        self.searchPage.search_for(test_track_name).open_track_page_from_results(1)
        self.trackPage.click_spotify_charts().search_in_charts(query)
        data = self.trackPage.get_chart_placements_data()
        for item in data:
            assert_that(item.lower(), "Search result includes the query").contains(query.lower())

        self.trackPage.click_back_button().click_spotify_charts()
        data_after_reopen = self.trackPage.get_chart_placements_data()
        assert_that(data_after_reopen, "Placements search results were cleared").is_not_equal_to(data)
        assert_that(self.trackPage.is_charts_search_empty, "Placements search results weren't cleared").is_true()

        self.trackPage.search_in_charts(full_query)
        data = self.trackPage.get_chart_placements_data()
        for item in data:
            assert_that(item, "Search result includes query").contains(full_query)

        self.trackPage.click_clear_search_icon()
        cleared_data = self.trackPage.get_chart_placements_data()
        assert_that(cleared_data, "Search was cleared").is_not_equal_to(data)
        assert_that(self.trackPage.is_charts_search_empty, "Placements search results weren't cleared").is_true()

        self.trackPage.search_in_charts(no_results_query)
        assert_that(self.trackPage.is_no_charts_search_results_msg_shown(), "No results message wasn't displayed").is_true()

    @allure.story("https://data-analytics.atlassian.net/browse/AG-6817")
    @allure.severity(allure.severity_level.NORMAL)
    @allure.title("Chart placements search")
    @allure.description("Charts placements search field states")
    @allure.testcase(
        "https://data-analytics.atlassian.net/browse/AG-5389"
        "https://data-analytics.atlassian.net/browse/AG-5388"
        "https://data-analytics.atlassian.net/browse/AG-5387"
        "https://data-analytics.atlassian.net/browse/AG-5386"
        "https://data-analytics.atlassian.net/browse/AG-5385"
        "https://data-analytics.atlassian.net/browse/AG-5383"
        "https://data-analytics.atlassian.net/browse/AG-5382"
        "https://data-analytics.atlassian.net/browse/AG-5381"
    )
    @pytest.mark.regression
    def test_charts_search_apple(self):
        test_data = self.api_helper.get_top_track_data_for_spotify_and_apple_for_chart_widget()
        test_track_name = test_data[0]
        query = "An"
        full_query = "United States"
        no_results_query = "007"

        self.loginPage.login_as_regular_user()
        self.searchPage.search_for(test_track_name).open_track_page_from_results(1)
        self.trackPage.click_apple_charts().search_in_charts(query)
        data = self.trackPage.get_chart_placements_data()
        for item in data:
            assert_that(item.lower(), "Search result includes the query").contains(query.lower())

        self.trackPage.click_back_button().click_apple_charts()
        data_after_reopen = self.trackPage.get_chart_placements_data()
        assert_that(data_after_reopen, "Placements search results were cleared").is_not_equal_to(data)
        assert_that(self.trackPage.is_charts_search_empty, "Placements search results weren't cleared").is_true()

        self.trackPage.search_in_charts(full_query)
        data = self.trackPage.get_chart_placements_data()
        for item in data:
            assert_that(item, "Search results includes the query").contains(full_query)

        self.trackPage.click_clear_search_icon()
        cleared_data = self.trackPage.get_chart_placements_data()
        assert_that(data, "Search were cleared").is_not_equal_to(cleared_data)
        assert_that(self.trackPage.is_charts_search_empty, "Placements search results weren't cleared").is_true()

        self.trackPage.search_in_charts(no_results_query)
        assert_that(self.trackPage.is_no_charts_search_results_msg_shown(), "No results message wasn't displayed").is_true()

    def format_api_charts_data(self, charts_data):
        country = charts_data["country_name"].replace("the ", "")
        date = datetime.strptime(charts_data["date"], "%Y-%m-%d").strftime("%m/%d/%y")
        added_date = (datetime.today() - datetime.strptime(charts_data["added_date"], "%Y-%m-%d")).days
        position = charts_data["position"]
        if charts_data["change"]:
            trend_value = abs(charts_data["change"])
            if charts_data["change"] > 0:
                trend = "\ue905"
            elif charts_data["change"] == 0:
                trend = "\ue904"
            else:
                trend = "\ue902"
        else:
            trend_value = ""
            trend = ""

        return {
            "country": country,
            "date": date,
            "added_date": added_date,
            "position": position,
            "trend": trend,
            "trend_value": trend_value,
        }