from allure import step
from playwright.sync_api import Page, expect

from src.helpers.logger import Logger
from src.locators.track_page.performance_section.youtube_tab_locators import TrackPagePerformanceYoutubeLocators
from src.pages.track_page.header.track_page_header import TrackPageHeader
from src.ui_elements.dropdown_ui_element import DropDownUIElement

log = Logger()
tab_name = "Youtube Tab - "


class TrackPagePerformanceYoutubeTab(TrackPageHeader):

    def __init__(self, page: Page):
        super().__init__(page)
        self.page = page
        self.choose_videos_link = DropDownUIElement(self.page, TrackPagePerformanceYoutubeLocators.CHOOSE_VIDEOS_LINK,
                                                    tab_name + 'choose videos link')
        self.views_dd = DropDownUIElement(self.page, TrackPagePerformanceYoutubeLocators.VIEWS_DD,
                                          tab_name + 'dsp dd')
        self.views_dd_chosen = DropDownUIElement(self.page, TrackPagePerformanceYoutubeLocators.VIEWS_CHOSEN,
                                                 tab_name + 'dsp dd chosen')
        self.source_dd = DropDownUIElement(self.page,
                                           TrackPagePerformanceYoutubeLocators.SOURCE_DD,
                                           tab_name + 'source dd')
        self.market_dd = DropDownUIElement(self.page, TrackPagePerformanceYoutubeLocators.MARKET_DD,
                                           tab_name + 'market dd')
        self.dd_apply_button = DropDownUIElement(self.page,
                                                 TrackPagePerformanceYoutubeLocators.DD_APPLY_BUTTON,
                                                 tab_name + 'market item')
        self.region_item = DropDownUIElement(self.page,
                                             TrackPagePerformanceYoutubeLocators.REGION_ITEM,
                                             tab_name + 'region item')
        self.graph_type_dd = DropDownUIElement(self.page, TrackPagePerformanceYoutubeLocators.GRAPH_TYPE_DD,
                                               tab_name + 'graph type dd chosen')
        self.graph_type_dd_chosen = DropDownUIElement(self.page,
                                                      TrackPagePerformanceYoutubeLocators.GRAPH_TYPE_DD_CHOSEN,
                                                      tab_name + 'graph type dd chosen')
        self.day_count_label = DropDownUIElement(self.page,
                                                 TrackPagePerformanceYoutubeLocators.DAY_COUNT_LABEL,
                                                 tab_name + 'day count label')
        self.export_dd = DropDownUIElement(self.page, TrackPagePerformanceYoutubeLocators.EXPORT_DD,
                                           tab_name + 'export dd')
        self.export_as_png = DropDownUIElement(self.page, TrackPagePerformanceYoutubeLocators.EXPORT_AS_PNG,
                                               tab_name + 'export as png')

    @step(tab_name + "choose view {item}")
    def choose_by_source(self, item):
        if self.views_dd_chosen.get_text() != item:
            self.views_dd.click()
            self.views_dd._element.get_by_text(item).click()
            self.verify_chosen_by_source(item)

    @step(tab_name + "verify chosen view {item}")
    def verify_chosen_by_source(self, item):
        expect(self.views_dd_chosen._element).to_contain_text(item)

    @step(tab_name + "choose sources {items}")
    def choose_sources(self, items):
        loc = "//*[contains(@id, '{}')]"
        key_sources = "Key Sources"
        other_sources = "Other Sources"
        self.source_dd.click()
        for sources in [key_sources, other_sources]:
            self.page.locator(loc.format(sources)).click()
            if self.page.locator(loc.format(sources)).get_attribute("data-checked") == "checked":
                self.page.locator(loc.format(sources)).click()
        for item in items:
            self.page.locator(loc.format(item)).click()
        self.dd_apply_button.click()
        self.verify_sources(items)

    @step(tab_name + "verify chosen sources {items}")
    def verify_sources(self, items):
        if len(items) == 1:
            expect(self.source_dd._element).to_have_text(items[0])
        else:
            expect(self.source_dd._element).to_have_text(f"{len(items)} Sources")

    @step(tab_name + "choose markets {items}")
    def choose_markets(self, items):
        self.is_loaded()
        loc = "//*[contains(@id, '{}')]"
        all_markets = "All Markets"
        self.market_dd.click()
        self.page.locator(loc.format(all_markets)).click()
        if self.page.locator(loc.format(all_markets)).get_attribute("data-checked") == "checked":
            self.page.locator(loc.format(all_markets)).click()
        for item in items:
            self.page.locator(loc.format(item)).check()
        self.dd_apply_button.click()
        self.verify_markets(items)

    @step(tab_name + "choose region {item}")
    def choose_region(self, item):
        self.market_dd.click()
        self.region_item.get_by(item).click()
        self.verify_markets([item])

    def choose_graph(self, graph):
        if self.graph_type_dd_chosen.get_text() != graph:
            self.graph_type_dd.click()
            self.graph_type_dd._element.get_by_text(text=graph, exact=True).click()
            expect(self.graph_type_dd_chosen._element).to_have_text(graph)

    @step(tab_name + "choose line graph")
    def choose_line_graph(self):
        graph = "Line Graph"
        self.choose_graph(graph)

    @step(tab_name + "choose are graph")
    def choose_area_graph(self):
        graph = "Area Graph"
        self.choose_graph(graph)

    @step(tab_name + "choose area percentage graph")
    def choose_percentage_graph(self):
        graph = "Area Graph, %"
        self.choose_graph(graph)

    @step(tab_name + "verify chosen markets {items}")
    def verify_markets(self, items):
        if len(items) == 1:
            expect(self.market_dd._element).to_have_text(items[0])
        else:
            expect(self.market_dd._element).to_have_text(f"{len(items)} Markets")

    @step(tab_name + "export as png")
    def download_png(self):
        self.is_loaded()
        self.page.wait_for_load_state('domcontentloaded')
        self.export_dd._element.dispatch_event('click')
        with self.page.expect_download() as download_info:
            self.export_as_png.click()
        download = download_info.value
        download.save_as(download.suggested_filename)
        return download

    @step(tab_name + "is loaded")
    def is_loaded(self):
        self.day_count_label.exists()