import json
import unittest
from argparse import Namespace

import allure
import pytest
from ui_automation_framework.core import TestStatus
from ui_automation_framework.utils import AppConfig, CoreConfig

from app.api_client import ApiClient
from app.mysql_db_client_custom import MySqlClient

from ...pages.add_track_popup import AddTrackPopup
from ...pages.audience_graph import AudienceGraphChart
from ...pages.comparison_page import TrackComparisonPage
from ...pages.left_navigation_panel import LeftNavigationPanel
from ...pages.login_page import LoginPage
from ...pages.track_page import TrackPage


@pytest.mark.usefixtures("set_up", "one_time_set_up")
class ComparisonPlaylistSupportTest(unittest.TestCase):
    track29 = json.loads(json.dumps(AppConfig.get("track29")), object_hook=lambda d: Namespace(**d))
    global_m = json.loads(json.dumps(AppConfig.get("market")["global"]), object_hook=lambda d: Namespace(**d))
    us = json.loads(json.dumps(AppConfig.get("market")["us"]), object_hook=lambda d: Namespace(**d))

    @pytest.fixture(autouse=True)
    def classSetup(self):
        self.loginPage = LoginPage(self.driver)
        self.trackPage = TrackPage(self.driver)
        self.add_track_popup = AddTrackPopup(self.driver)
        self.comparison_page = TrackComparisonPage(self.driver)
        self.left_panel = LeftNavigationPanel(self.driver)
        self.audience_graph = AudienceGraphChart(self.driver)
        self.api_client = ApiClient()
        self.sql_client = MySqlClient()
        self.ts = TestStatus(self.driver)

    @allure.story("AP-749")
    @allure.severity(allure.severity_level.NORMAL)
    @allure.title("""Streams Graph. Data streaming calculation.""")
    @allure.description(
        """TC verifies that calculation of the streaming values is correct and streaming charts are displayed in the
        right way on the Track Performance section on Comparison Tool page. """
    )
    def test_stream_graph_calculation_data_streaming(self):
        self.comparison_page.remove_tracks_if_present_with_worker(self.us.market)
        user = self.loginPage.get_user_email_with_worker()
        token = self.api_client.authorize(user=user)
        for track in [self.track29]:
            self.api_client.add_track_to_comparison(token=token, market=self.us.market, isrc=track.isrc, id=track.id)
        self.loginPage.login_with_worker()
        self.loginPage.is_logged_in()
        self.left_panel.open_comparison_page()
        self.trackPage.select_market(self.global_m.name)
        self.comparison_page.open_new_tab()

        for period in [AppConfig.get("periods")["14d"], AppConfig.get("periods")["8w"], AppConfig.get("periods")["1y"]]:
            self.comparison_page.select_period_from_dd(period["name"])
            url_open = "{base}/spotify/track/{id}?market={market}&str_gr_dsp=5&str_gr_view=1&str_gr_start_date={start}&str_gr_end_date={end}"
            self.comparison_page.switch_to_tab(2)
            for track in [self.track29]:
                end_date = self.comparison_page.get_end_date_for_track_period(period=period["count"], track=track)
                self.comparison_page.open_url(
                    url_open.format(
                        base=CoreConfig.ENV_BASE_URL,
                        id=track.id,
                        market=self.global_m.url,
                        start=track.dates.f_date,
                        end=end_date,
                    )
                )
                track_page_s = self.trackPage.get_streams_values_by_dsp()
                if period == AppConfig.get("periods")["14d"]:
                    tooltips = self.trackPage.get_tooltip_info_track_performance((int(period["count"]) + 2) * 2)
                    for value_name in ["spotify", "apple", "amazon", "total"]:
                        self.ts.markFinal(
                            sum(tooltips[value_name]) == track_page_s["{}_value".format(value_name)],
                            "STEP 5: tooltips and legend data is equal: tooltips: {}, legend: {}".format(sum(tooltips[value_name]), track_page_s["{}_value".format(value_name)]),
                        )

                track_page_streams = track_page_s
            self.comparison_page.switch_to_tab(1)
            tp_legend_values = {}
            for dsp in ["spotify", "apple", "amazon", "total_streams"]:
                self.comparison_page.track_performance_select_dsp_from_dd(AppConfig.get("dsp")[dsp])
                if dsp == "total_streams":
                    dsp = "total"
                tp_legend_values[dsp] = self.comparison_page.get_track_performance_legend_streams()

            for value_name in ["spotify", "apple", "amazon", "total"]:
                legend_values = [float(str(v).replace("N/A", "0")) for v in tp_legend_values[value_name]]
                track_page_values = track_page_streams
                self.ts.markFinal(
                    track_page_values["{}_value".format(value_name)] == legend_values[0],
                    "period: {}, values: {} in track page and graph are equal: tp: {}, " "legend: {} ".format(period["name"], value_name, track_page_values["{}_value".format(value_name)], legend_values[0]),
                )