import logging
from contextlib import suppress
import allure
from ui_automation_framework.utils import logger as cl
from waiting import TimeoutExpired

from src.helpers.waiting_wrapper import wait
from src.locators.track_comparison_locators import TrackComparisonLocators
from src.pages.track_view_page import TrackViewPage
from src.ui_elements.button_ui_element import ButtonUIElement
from src.ui_elements.input_ui_element import InputUIElement
from src.ui_elements.label_ui_element import LabelUIElement, LabelUIByText
from src.ui_elements.list_ui_element import ListUIElement


class TrackComparisonPage(TrackViewPage):
    log = cl.Logger(logging.DEBUG)

    def __init__(self, driver):
        super().__init__(driver)
        self.driver = driver

    @property
    def bn_edit_tracks(self):
        return ButtonUIElement(self.driver, TrackComparisonLocators.EDIT_TRACKS_BN, "Edit Tracks")

    @property
    def lb_compare(self):
        return LabelUIElement(self.driver, TrackComparisonLocators.COMPARE_LB, "Select up to five tracks")

    @property
    def bn_compare(self):
        return ButtonUIElement(self.driver, TrackComparisonLocators.COMPARE_BN, "Compare on Artist page")

    @property
    def track_comparison_list(self):
        return ListUIElement(self.driver, by_position_locator=TrackComparisonLocators.TRACKS_TO_COMPARE_BY_POSITION,
                             by_text_locator=TrackComparisonLocators.TRACKS_TO_COMPARE_BY_NAME,
                             all_elements_locator=TrackComparisonLocators.TRACKS_TO_COMPARE_LIST)

    @property
    def in_search_by_name_to_compare(self):
        return InputUIElement(self.driver, TrackComparisonLocators.SEARCH_TRACK_TO_COMPARE, "Search tracks by name")

    @property
    def bn_try_again(self):
        return ButtonUIElement(self.driver, TrackComparisonLocators.TRY_AGAIN_BN, "Try Again")

    @property
    def bn_track_screen(self):
        return ButtonUIElement(self.driver, TrackComparisonLocators.TRACK_SCREEN_BN, "Tack Screen")

    @property
    def lb_track_bar(self):
        return LabelUIByText(self.driver, TrackComparisonLocators.TRACK_BAR_BY_NAME, "Track bar")

    @allure.step("Artist name checking")
    def chosen_artist_name(self):
        self.bn_artist_selection.wait()
        artist_name = self.bn_artist_selection.value.split(', ')[1]
        print("Artist is {}".format(artist_name))
        return artist_name

    @allure.step("Track Comparison opened")
    def is_track_comparison_opened(self):
        with suppress(TimeoutExpired):
            return wait(self.lb_compare.is_visible)
        return False

    @allure.step("Try Again")
    def click_try_again(self):
        self.bn_try_again.click()
        return self

    @allure.step("Click to Compare")
    def click_to_compare(self):
        self.bn_compare.click()
        return self

    def print_all_track_to_compare(self):
        tracks = self.track_comparison_list.elements
        for el in tracks:
            print(el.text)

    def get_track_name_from_list(self):
        fullname_track_list = self.track_comparison_list.texts
        for full_track_name in fullname_track_list:
            split_name = full_track_name.split(' ')
            if split_name[-1] == '0%':
                cut_name = split_name[:-2]  # cut digits like '26.7M 0%'
            else:
                cut_name = split_name[:-3]  # cut digits like '188.5M  8%'
            filtered_name = [x for x in cut_name if
                             len(x) == 1 or (len(x) > 1 and not x.isupper()) and x != 'Explicit']
            name = ' '.join(filtered_name)
            yield name

    @allure.step("Search and Select track by name: {name}")
    def search_and_select_track_to_compare_by_name(self, name):
        # self.in_search_by_name_to_compare.click()
        self.in_search_by_name_to_compare.send_text(name)
        self.press_return_to_hide_keyboard()
        self.click_to_hide_keyboard()
        self.track_comparison_list.select_by_text(name)
        return self

    @allure.step("Click track {track_name} bar")
    def click_track_bar(self, track_name):
        with suppress(TimeoutExpired):
            bar = self.lb_track_bar.get_item_by_text(track_name)
            bar._element.click()