import datetime
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):
    track34 = json.loads(json.dumps(AppConfig.get("track34")), object_hook=lambda d: Namespace(**d))
    track14 = json.loads(json.dumps(AppConfig.get("track14")), object_hook=lambda d: Namespace(**d))
    us = json.loads(json.dumps(AppConfig.get("market")["us"]), object_hook=lambda d: Namespace(**d))
    global_m = json.loads(json.dumps(AppConfig.get("market")["global"]), 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-2756")
    @allure.severity(allure.severity_level.NORMAL)
    @allure.title("""[AP-2539] Verification of 'By engagement' graph+table calculation""")
    @allure.description(
        """TC verifies bar chart calculation for Spotify DSP. Each bar on the Bar Chart represents a number of lean
        forward and lean back streams in the defined period of time for the selected market (both controls are placed
        in the Track Cards area) for a DSP specified in the drop list next to the graph. Tooltip is shown on hover on
        a particular bar in the chart. Period end date in the hint must be replaced with the latest date for which we
        have data in the case when the track doesn’dashboard_page_elements.json have data for a whole period (tracks that were released not so
        far ago). Tracks with zero streams are shown in the tooltip on hover. If BE responses with an error while
        requesting streams data then:"""
    )
    def test_by_engagement_calculation(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.track34, self.track14]:
            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.select_market_from_dd(self.global_m.name)
        self.comparison_page.select_period_from_dd(AppConfig.get("periods")["14d"]["name"])
        self.comparison_page.open_new_tab()
        dsps = [AppConfig.get("dsp")["spotify"], AppConfig.get("dsp")["apple"], AppConfig.get("dsp")["amazon"]]
        for dsp in dsps:
            self.comparison_page.switch_to_tab(1)
            self.comparison_page.by_engagement_select_dsp_from_dd(dsp)
            tooltips = self.comparison_page.by_engagement_get_graph_tooltips_parsed()
            table = self.comparison_page.get_by_engagement_table_values()
            url_open = "{base}/spotify/track/{id}?market={market}&str_gr_dsp={dsp}&str_gr_start_date={start}&str_gr_end_date={end}"
            self.comparison_page.switch_to_tab(2)
            end_date = self.comparison_page.get_end_date_for_track_period(period=AppConfig.get("periods")["14d"]["count"], track=self.track34)
            range_expected = "{}–{}".format(
                datetime.datetime.strptime(self.track34.dates.f_date, "%Y-%m-%d").strftime(self.trackPage.get_date_format_from_locale()),
                datetime.datetime.strptime(str(end_date), "%Y-%m-%d").strftime(self.trackPage.get_date_format_from_locale()),
            )
            self.comparison_page.open_url(
                url_open.format(
                    base=CoreConfig.ENV_BASE_URL,
                    id=self.track34.id,
                    market=self.global_m.url,
                    start=self.track34.dates.f_date,
                    end=end_date,
                    dsp=(dsps.index(dsp) + 1),
                )
            )
            tp_values = self.trackPage.get_lean_values()
            self.ts.markFinal(tooltips[0]["track_name"] == self.track34.name, "track name is correct in tooltip, dsp: {}".format(dsp))
            self.ts.markFinal(tooltips[0]["track_date"] == range_expected, "track date is correct in tooltip")
            for v in ["lean_forward_count", "lean_back_count", "lean_forward_percent", "lean_back_percent", "total"]:
                self.ts.markFinal(
                    tooltips[0][v] == tp_values[v],
                    "{} is correct: tooltip: {}, tp: {}".format(v, tooltips[0][v], tp_values[v]),
                )
                if v in ["lean_forward_count", "lean_back_count"]:
                    self.ts.markFinal(
                        self.trackPage.apply_rounding(tooltips[0][v]) == table[v][0],
                        "{} is correct: tooltip: {}, table: {}".format(v, self.trackPage.apply_rounding(tooltips[0][v]), table[v]),
                    )
                if v in ["lean_forward_percent", "lean_back_percent"]:
                    self.ts.markFinal(
                        self.trackPage.apply_rounding_percentage(tooltips[0][v]) == table[v][0],
                        "{} is correct: tooltip: {}, table: {}".format(v, self.trackPage.apply_rounding(tooltips[0][v]), table[v][0]),
                    )