from itertools import chain

import allure
import pytest
from assertpy import assert_that

from app.src.helpers import uniq
from app.src.helpers.waiting_wrapper import wait


def get_first_track_name_by_playlist(api, playlist_id):
    track_isrc = api.apollo.get_spotify_playlist_tracklist(playlist_id, order_by="current_position")["body"]["items"][0]["isrc"]
    return api.apollo.get_list_of_spotify_tracks(f"isrc:{track_isrc}")["body"]["tracks"]["items"][0]["name"]


def get_title(title):
    return title[2 : title.find(" By ")]


@allure.testcase("https://data-analytics.atlassian.net/browse/AG-7642")
@allure.severity(allure.severity_level.NORMAL)
@allure.description("Playlist card items at the search result")
@pytest.mark.smoke
def test_playlist_card_item_in_search_results(login_page, search_page, authorized_api):
    search_query = "Daily Lift"
    playlists = authorized_api.apollo.get_playlist_search_results(search_query)
    login_page.login_as_regular_user()
    search_page.click_playlists_tab().search_for(search_query)
    ui_items = wait(lambda: search_page.lt_playlist_search_results.visible_elements)
    assert_that(len(ui_items)).is_greater_than(4)
    for api_item, ui_item in zip(playlists, ui_items):
        assert_that(ui_item.text).contains(api_item.name)
        assert_that(ui_item.text).contains(api_item.owner)


# @allure.testcase("https://data-analytics.atlassian.net/browse/AG-7641")
# @allure.severity(allure.severity_level.NORMAL)
# @allure.description("Navigation to Playlist screen via clicking on search result")
# @pytest.mark.smoke
# def test_navigation_to_playlist_via_clicking_on_search_result(login_page, search_page, playlist_page):
#     search_query = "Top 100"
#     login_page.login_as_regular_user()
#     search_page.click_playlists_tab().search_for(search_query)
#     first_result = search_page.lt_playlist_search_results.get_item_by_position(1)
#     first_result_text = get_title(first_result.text)
#     first_result.click()
#     assert_that(playlist_page.is_playlist_page_opened_for_name(first_result_text)).is_true()


@allure.testcase("https://data-analytics.atlassian.net/browse/AG-7637")
@allure.severity(allure.severity_level.NORMAL)
@allure.description("Search results according to the search query")
@pytest.mark.smoke
def test_results_according_to_search_query(login_page, search_page, authorized_api):
    search_query = "Top 100"
    first_part, second_part = search_query[:4], search_query[4:]
    playlists_first = authorized_api.apollo.get_playlist_search_results(first_part, vendor=["spotify", "apple", "amazon"])
    playlists_second = authorized_api.apollo.get_playlist_search_results(search_query, vendor=["spotify", "apple", "amazon"])
    assert_that(list(filter(lambda x: x.vendor == "apple", playlists_first))).is_length(10)
    assert_that(list(filter(lambda x: x.vendor == "spotify", playlists_first))).is_length(10)
    assert_that(list(filter(lambda x: x.vendor == "amazon", playlists_first))).is_length(10)
    assert_that(list(filter(lambda x: x.vendor == "apple", playlists_second))).is_length(10)
    assert_that(list(filter(lambda x: x.vendor == "spotify", playlists_second))).is_length(10)
    assert_that(list(filter(lambda x: x.vendor == "amazon", playlists_second))).is_length(10)

    login_page.login_as_regular_user()
    search_page.click_playlists_tab().in_search.send_text(first_part)
    search_page.filter_playlists_by_dsp({"Spotify", "Apple"})
    ui_texts = search_page.lt_playlist_search_results.texts
    assert_that(ui_texts).is_length(30)
    for ui, api in zip(ui_texts, playlists_first):
        if api.owner:
            assert_that(ui).contains(f"{api.name} By\xa0{api.owner}")
        else:
            assert_that(ui).contains(f"{api.name}")

    # assert_that(search_page.driver.is_keyboard_shown()).is_true()
    search_page.in_search.send_text(second_part)

    ui_texts = search_page.lt_playlist_search_results.texts
    assert_that(ui_texts).is_length(30)
    for ui, api in zip(ui_texts, playlists_second):
        if api.owner:
            assert_that(ui).contains(f"{api.name} By\xa0{api.owner}")
        else:
            assert_that(ui).contains(f"{api.name}")
        # according to the bug the search by entry result is not necessary (AG-9265)
        # the logic is more complex than just checking that ui contains search_query
        # assert_that(ui.lower()).contains(search_query.lower().split()[0])
        # assert_that(ui.lower()).contains(search_query.lower().split()[1])


@allure.testcase("https://data-analytics.atlassian.net/browse/AG-2135")
@allure.severity(allure.severity_level.NORMAL)
@allure.description("Search logic is match to A Portal")
@pytest.mark.smoke
def test_portal_matching_1(login_page, search_page, authorized_api):
    search_query = "Top"
    track_portal = authorized_api.common.get_search_results_portal(search_query, ["track"]).tracks.items
    uniq_tracks_portal = uniq(track_portal, lambda x: x.external_ids["isrc"])
    login_page.login_as_regular_user()
    search_page.search_for(search_query)
    ui_tracks = wait(lambda: search_page.lt_track_search_results.texts)[:10]
    for portal_track, ui_track in zip(uniq_tracks_portal, ui_tracks):
        assert_that(ui_track).contains(portal_track.name)


@allure.testcase("https://data-analytics.atlassian.net/browse/AG-2135")
@allure.severity(allure.severity_level.NORMAL)
@allure.description("Search logic is match to A Portal")
@pytest.mark.smoke
def test_portal_matching_2(login_page, search_page, authorized_api):
    search_query = "Top"
    playlists_spotify = authorized_api.common.get_playlists_spotify(search_query).playlists
    playlists_apple = authorized_api.common.get_playlists_apple(search_query).playlists
    playlists_portal = list(chain(*zip(playlists_spotify, playlists_apple)))
    assert_that(len(playlists_portal)).is_greater_than(10)
    login_page.login_as_regular_user()
    search_page.click_playlists_tab().search_for(search_query)
    search_page.filter_playlists_by_dsp({"Spotify", "Apple"})
    ui_playlists = wait(lambda: search_page.lt_playlist_search_results.texts)[:10]
    for portal_track, ui_track in zip(playlists_portal, ui_playlists):
        assert_that(ui_track).contains(portal_track.name)