import logging
import unittest

import allure
import pytest
from assertpy import assert_that
from ui_automation_framework.core import TestStatus
from ui_automation_framework.utils import AppConfig
from ui_automation_framework.utils import logger as cl

from app.api_client import ApiClient
from app.src.pages.add_track_popup import AddTrackPopup
from app.src.pages.amplitude_helper import AmplitudeHelper
from app.src.pages.comparison_page import TrackComparisonPage
from app.src.pages.left_navigation_panel import LeftNavigationPanel
from app.src.pages.login_page import LoginPage
from app.src.pages.track_page import TrackPage


@pytest.mark.usefixtures("set_up", "one_time_set_up")
class Amplitude(unittest.TestCase):
    log = cl.Logger(logging.DEBUG)
    dsp_list = [AppConfig.get("dsp")["amazon"], AppConfig.get("dsp")["apple"], AppConfig.get("dsp")["spotify"], AppConfig.get("dsp")["total_streams"]]
    album_source = "Album"
    artist_source = "Artist"
    all_sources = "All sources"
    playlist_details_tab = "Playlist Support"
    streams_details_tab = "Streams Details"
    order_ascending = "Ascending"
    order_descending = "Descending"
    by_dsp_titles_list = ["track_name", "spotify", "apple", "amazon", "total"]
    by_engagement_titles_list = ["name", "lean-forward", "lean-back", "total"]

    @pytest.fixture(autouse=True)
    def classSetup(self):
        self.log = cl.Logger(logging.DEBUG)
        self.loginPage = LoginPage(self.driver)
        self.ts = TestStatus(self.driver)
        self.amplitude_helper = AmplitudeHelper(self.driver)
        self.track_page = TrackPage(self.driver)
        self.comparison_page = TrackComparisonPage(self.driver)
        self.add_track_popup = AddTrackPopup(self.driver)
        self.left_panel = LeftNavigationPanel(self.driver)
        self.api_client = ApiClient()

    @allure.story("AP-3271")
    @allure.severity(allure.severity_level.NORMAL)
    @allure.title("[AP-3213] Amplitude verification for Track Compare v2")
    @allure.description("""TC Verifies Comparison page events""")
    def test_comparison_page_events(self):
        self.comparison_page.remove_tracks_if_present_with_worker(AppConfig.get("market")["us"]["market"])
        user = self.loginPage.get_user_email_with_worker()
        token = self.api_client.authorize(user=user)
        for track in [AppConfig.get("track40"), AppConfig.get("track41"), AppConfig.get("track42")]:
            self.api_client.add_track_to_comparison(token=token, market=AppConfig.get("market")["us"]["market"], isrc=track["isrc"], id=track["id"])
        self.loginPage.login_with_worker()
        self.loginPage.is_logged_in()
        self.track_page.select_market(AppConfig.get("market")["us"]["name"])
        events = self.amplitude_helper.wait_and_get_amplitude_events(5, False)
        self.amplitude_helper.is_initializer_event(events[0])
        self.amplitude_helper.verify_event_user_properties(events[0])
        # step 1
        # market global
        self.left_panel.open_comparison_page()
        self.comparison_page.select_market_from_dd(AppConfig.get("market")["global"]["name"])
        events = self.amplitude_helper.wait_and_get_amplitude_events(3)
        self.amplitude_helper.verify_for_event_type(events[2], self.amplitude_helper.COMPARISON_PAGE["event_type_page_filtered"])
        assert_that(events[2]["event_properties"]["tc_market_selector"]).is_equal_to(AppConfig.get("market")["global"]["name"])
        # market algeria
        self.left_panel.open_comparison_page()
        self.comparison_page.select_market_from_dd(AppConfig.get("market")["algerial"]["name"])
        events = self.amplitude_helper.wait_and_get_amplitude_events(1)
        self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_page_filtered"])
        assert_that(events[0]["event_properties"]["tc_market_selector"]).is_equal_to(AppConfig.get("market")["algerial"]["name"])
        # period 14
        self.comparison_page.select_period_from_dd(AppConfig.get("periods")["14d"]["name"])
        events = self.amplitude_helper.wait_and_get_amplitude_events(1)
        self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_page_filtered"])
        assert_that(events[0]["event_properties"]["tc_period_selector"]).is_equal_to(AppConfig.get("periods")["14d"]["name"])
        # period 28
        self.comparison_page.select_period_from_dd(AppConfig.get("periods")["28d"]["name"])
        events = self.amplitude_helper.wait_and_get_amplitude_events(1)
        self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_page_filtered"])
        assert_that(events[0]["event_properties"]["tc_period_selector"]).is_equal_to(AppConfig.get("periods")["28d"]["name"])
        # performance dsp
        for dsp in self.dsp_list:
            self.comparison_page.track_performance_select_dsp_from_dd(dsp)
            events = self.amplitude_helper.wait_and_get_amplitude_events(1)
            self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_page_filtered"])
            assert_that(events[0]["event_properties"]["tsp_dsp_selector"]).is_equal_to(dsp)
        # performance sources - album page
        self.comparison_page.track_performance_select_dsp_from_dd(AppConfig.get("dsp")["spotify"])
        self.comparison_page.track_performance_select_source(AppConfig.get("source")["album_page"])
        events = self.amplitude_helper.wait_and_get_amplitude_events(2)
        self.amplitude_helper.verify_for_event_type(events[1], self.amplitude_helper.COMPARISON_PAGE["event_type_page_filtered"])
        assert_that(events[1]["event_properties"]["tsp_source_selector"]).is_equal_to(self.album_source)
        # performance sources - artist page
        self.comparison_page.track_performance_select_source(AppConfig.get("source")["artist_page"])
        events = self.amplitude_helper.wait_and_get_amplitude_events(1)
        self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_page_filtered"])
        assert_that(events[0]["event_properties"]["tsp_source_selector"]).is_equal_to(self.artist_source)
        # performance sources - all
        self.comparison_page.track_performance_select_source(AppConfig.get("source")["all"])
        events = self.amplitude_helper.wait_and_get_amplitude_events(1)
        self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_page_filtered"])
        assert_that(events[0]["event_properties"]["tsp_source_selector"]).is_equal_to(self.all_sources)
        # by engagement dsp
        for dsp in self.dsp_list[:-1]:
            self.comparison_page.by_engagement_select_dsp_from_dd(dsp)
            events = self.amplitude_helper.wait_and_get_amplitude_events(1)
            self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_page_filtered"])
            assert_that(events[0]["event_properties"]["sd_engagement_dsp_selector"]).is_equal_to(dsp)
        # by audience dsp
        for dsp in self.dsp_list[1:-1]:
            self.comparison_page.audience_select_dsp_from_dd(dsp)
            events = self.amplitude_helper.wait_and_get_amplitude_events(1)
            self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_page_filtered"])
            assert_that(events[0]["event_properties"]["sd_audience_dsp_selector"]).is_equal_to(dsp)
        # by country dsp
        for dsp in self.dsp_list:
            self.comparison_page.country_select_dsp_from_dd(dsp)
            events = self.amplitude_helper.wait_and_get_amplitude_events(1)
            self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_page_filtered"])
            assert_that(events[0]["event_properties"]["sd_country_dsp_selector"]).is_equal_to(dsp)
        # country sources - album page
        self.comparison_page.country_select_dsp_from_dd(AppConfig.get("dsp")["spotify"])
        self.comparison_page.country_select_source(AppConfig.get("source")["album_page"])
        events = self.amplitude_helper.wait_and_get_amplitude_events(2)
        self.amplitude_helper.verify_for_event_type(events[1], self.amplitude_helper.COMPARISON_PAGE["event_type_page_filtered"])
        assert_that(events[1]["event_properties"]["sd_country_source_selector"]).is_equal_to(self.album_source)
        # performance sources - artist page
        self.comparison_page.country_select_source(AppConfig.get("source")["artist_page"])
        events = self.amplitude_helper.wait_and_get_amplitude_events(1)
        self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_page_filtered"])
        assert_that(events[0]["event_properties"]["sd_country_source_selector"]).is_equal_to(self.artist_source)
        # performance sources - all
        self.comparison_page.country_select_source(AppConfig.get("source")["all"])
        events = self.amplitude_helper.wait_and_get_amplitude_events(1)
        self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_page_filtered"])
        assert_that(events[0]["event_properties"]["sd_country_source_selector"]).is_equal_to(self.all_sources)
        # step 2
        self.comparison_page.open_playlist_details()
        events = self.amplitude_helper.wait_and_get_amplitude_events(1)
        self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_tab_changed"])
        assert_that(events[0]["event_properties"]["tab"]).is_equal_to(self.playlist_details_tab)
        # step 3
        # playlist details - dsp
        for dsp in [AppConfig.get("dsp")["apple"], AppConfig.get("dsp")["spotify"], AppConfig.get("dsp")["all_playlists"]]:
            self.comparison_page.playlist_details_select_dsp_from_dd(dsp)
            events = self.amplitude_helper.wait_and_get_amplitude_events(1)
            self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_page_filtered"])
            assert_that(events[0]["event_properties"]["ps_dsp_selector"]).is_equal_to(dsp)
        # step 4
        self.comparison_page.open_stream_details()
        events = self.amplitude_helper.wait_and_get_amplitude_events(1)
        self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_tab_changed"])
        assert_that(events[0]["event_properties"]["tab"]).is_equal_to(self.streams_details_tab)
        # step 5
        # by dsp position sorting
        self.comparison_page.select_market_from_dd(AppConfig.get("market")["global"]["name"])
        self.comparison_page.by_dsp_sort_by_default()
        values_order = self.comparison_page.get_by_dsp_table_values()["order"]
        assert_that(values_order).is_equal_to(sorted(values_order, reverse=True))
        events = self.amplitude_helper.wait_and_get_amplitude_events(2)
        self.amplitude_helper.verify_for_event_type(events[1], self.amplitude_helper.COMPARISON_PAGE["event_type_table_sorted"])
        assert_that(events[1]["event_properties"]["sort_direction"]).is_equal_to(self.order_descending)
        self.comparison_page.by_dsp_sort_by_default()
        values_order = self.comparison_page.get_by_dsp_table_values()["order"]
        assert_that(values_order).is_equal_to(sorted(values_order))
        events = self.amplitude_helper.wait_and_get_amplitude_events(1)
        self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_table_sorted"])
        assert_that(events[0]["event_properties"]["sort_direction"]).is_equal_to(self.order_ascending)
        # by dsp table sorting
        for dsp in self.by_dsp_titles_list:
            self.comparison_page.by_dsp_sort_by_column(column=dsp)
            if dsp == "track_name":
                values_order = self.comparison_page.get_by_dsp_table_values()[dsp.replace("track_", "")]
            else:
                values = self.comparison_page.get_by_dsp_table_values()[dsp]
                values_order = self.full_number_of_streams(values)
            self.comparison_page.log.info(dsp + str(values_order))
            assert_that(values_order).is_equal_to(sorted(values_order))
            events = self.amplitude_helper.wait_and_get_amplitude_events(1)
            self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_table_sorted"])
            assert_that(events[0]["event_properties"]["sort_direction"]).is_equal_to(self.order_ascending)
            self.comparison_page.by_dsp_sort_by_column(column=dsp)
            if dsp == "track_name":
                values_order = self.comparison_page.get_by_dsp_table_values()[dsp.replace("track_", "")]
            else:
                values = self.comparison_page.get_by_dsp_table_values()[dsp]
                values_order = self.full_number_of_streams(values)
            self.comparison_page.log.info("Name: " + str(values_order))
            assert_that(values_order).is_equal_to(sorted(values_order, reverse=True))
            events = self.amplitude_helper.wait_and_get_amplitude_events(1)
            self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_table_sorted"])
            assert_that(events[0]["event_properties"]["sort_direction"]).is_equal_to(self.order_descending)
        # step 6
        # by engagement table sorting
        # position
        self.comparison_page.by_engagement_sort_by_column_and_verify("position")
        values_order = self.comparison_page.get_by_engagement_table_values()["order"]
        assert_that(values_order).is_equal_to(sorted(values_order, reverse=True))
        events = self.amplitude_helper.wait_and_get_amplitude_events(1)
        self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_table_sorted"])
        assert_that(events[0]["event_properties"]["sort_direction"]).is_equal_to(self.order_descending)
        self.comparison_page.by_engagement_sort_by_column_and_verify("position")
        values_order = self.comparison_page.get_by_engagement_table_values()["order"]
        assert_that(values_order).is_equal_to(sorted(values_order))
        events = self.amplitude_helper.wait_and_get_amplitude_events(1)
        self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_table_sorted"])
        assert_that(events[0]["event_properties"]["sort_direction"]).is_equal_to(self.order_ascending)
        # by engagement table sorting
        for dsp in self.by_engagement_titles_list:
            self.comparison_page.by_engagement_sort_by_column_and_verify(dsp)
            if dsp == "name":
                eng_values_order = self.comparison_page.get_by_engagement_table_values()[dsp]
            else:
                values = self.comparison_page.get_by_engagement_table_values()[dsp.replace("lean-", "")]
                eng_values_order = self.full_number_of_streams(values)
            assert_that(eng_values_order).is_equal_to(sorted(eng_values_order))
            events = self.amplitude_helper.wait_and_get_amplitude_events(1)
            self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_table_sorted"])
            assert_that(events[0]["event_properties"]["sort_direction"]).is_equal_to(self.order_ascending)
            self.comparison_page.by_engagement_sort_by_column_and_verify(dsp)
            if dsp == "name":
                eng_values_order = self.comparison_page.get_by_engagement_table_values()[dsp]
            else:
                values = self.comparison_page.get_by_engagement_table_values()[dsp.replace("lean-", "")]
                eng_values_order = self.full_number_of_streams(values)
            assert_that(eng_values_order).is_equal_to(sorted(eng_values_order, reverse=True))
            events = self.amplitude_helper.wait_and_get_amplitude_events(1)
            self.amplitude_helper.verify_for_event_type(events[0], self.amplitude_helper.COMPARISON_PAGE["event_type_table_sorted"])
            assert_that(events[0]["event_properties"]["sort_direction"]).is_equal_to(self.order_descending)
        # step 7
        self.comparison_page.open_playlist_details()
        self.comparison_page.scroll_to_last_row()
        self.comparison_page.click_back_to_top_button()
        events = self.amplitude_helper.wait_and_get_amplitude_events(2)
        self.amplitude_helper.verify_for_event_type(events[1], self.amplitude_helper.COMPARISON_PAGE["event_type_back_to_top"])

    def full_number_of_streams(self, values):
        tens = dict(k=1e3, m=1e6, b=1e9)

        def f(x):
            return int(float(x[:-1]) * tens[x[-1].lower()])

        values_list = [f(s) for s in values]
        return values_list