import pytest
import random
import re
import allure
from assertpy import assert_that
from src.data.entities_data import entity_types


@pytest.mark.usefixtures("app")
class TestSearchByNameFromHome:

    @allure.title("[Search by name] Artist – from Home page - {entity_type}")
    @allure.description("As user I want to search for artists by name.")
    @allure.testcase("https://data-analytics.atlassian.net/browse/DNAD-1613")
    @pytest.mark.smoke
    @pytest.mark.parametrize('entity_type', entity_types)
    def test_search_by_name(self, entity_type):
        self.app.go_to('')
        self.home_page.is_page_loaded()
        search_word = ['beatles', 'hello'][entity_types.index(entity_type)]
        self.home_page.placeholder_search.click()
        with self.app.page.expect_response(self.home_page.api_search_by_name[entity_type]) as search_response:
            self.home_page.placeholder_search.input_text(search_word)
        self.home_page.verify_found_cards_response_vs_page(search_word, entity_type, search_response)
        #
        self.app.page.keyboard.press("Enter")
        self.search_page.is_page_loaded()
        assert_that(self.search_page.placeholder_search.get_attribute('value')).is_equal_to(search_word)
        self.search_page.verify_found_cards_response_vs_page(search_word, entity_type, search_response)
        # Return back
        self.search_page.btn_return.click()
        self.home_page.is_page_loaded()

    @allure.title("[Search by name] Artist – proceed to entity page - {entity_type}")
    @allure.description("As user I want to search for artists/tracks by name.")
    @allure.testcase("https://data-analytics.atlassian.net/browse/DNAD-1613")
    @pytest.mark.smoke
    @pytest.mark.parametrize('entity_type', entity_types)
    def test_search_and_proceed_to(self, entity_type):
        self.app.go_to('')
        self.home_page.is_page_loaded()
        search_word = 'dua lipa'
        self.home_page.placeholder_search.input_text(search_word)
        self.home_page.search_cards_title.get_by(f"{entity_type.capitalize()}s").exists()
        entity_name = self.home_page.search_card_name.get_by(f"{entity_type.capitalize()}s", 1).get_text()
        self.home_page.search_card_name.get_by(f"{entity_type.capitalize()}s", 1).click()
        assert_that(self.app.page.url).contains(entity_type)
        assert_that(self.artist_page.entity_name.get_text()).is_equal_to(entity_name)
        self.common_page.btn_return.click()
        self.home_page.is_page_loaded()

    @allure.title("[Search by name] – from Home page - add to category - {entity_type}")
    @allure.description("As user I want to search for artists and tracks by name from Home page.")
    @allure.testcase("https://data-analytics.atlassian.net/browse/DNAD-1613")
    @pytest.mark.smoke
    @pytest.mark.parametrize('entity_type', entity_types)
    def test_search_and_add_to_category(self, entity_type):
        search_word = 'coldplay'
        category_name = f"autotest category for {entity_type}"
        self.app.api.insert_category(category_name, True)
        self.app.go_to('')
        self.home_page.placeholder_search.input_text(search_word)

        # Get artist name
        entity_name = self.home_page.search_card_name.get_by(f"{entity_type.capitalize()}s", 1).get_text()
        self.home_page.search_card_bn_bookmark.get_by(f"{entity_type.capitalize()}s", 1).click()

        # Save artist to category
        self.common_page.modal_lb_add_to_category.exists()
        self.common_page.modal_category_dropdown.select_option(category_name)
        self.common_page.modal_btn_save.click()

        alert_msg = self.common_page.alert_msg.get_text()
        assert_that(alert_msg).is_equal_to(
            f'{entity_name}  is added to the {category_name} category.')

        self.home_page.search_card_green_mark.get_by(f"{entity_type.capitalize()}s", 1).exists()
        # Check artist is saved in appropriate category
        category = [cat for cat in self.app.api.get_user_categories() if cat['name'] == category_name]
        category_entities = self.app.api.get_category_entities(category[0]['id'])
        saved_to_category_item = category_entities[0]
        assert_that(saved_to_category_item["entity_type"]).is_equal_to(entity_type)
        assert_that(saved_to_category_item["data"]["name"]).is_equal_to(entity_name)


@pytest.mark.usefixtures("app")
class TestSearchByNameRecentResults:

    @allure.title("[Search by name] - Recent Search - Entity added")
    @allure.description("As user I want to search for artists by name.")
    @allure.testcase("https://data-analytics.atlassian.net/browse/DNAD-728")
    @pytest.mark.smoke
    @pytest.mark.parametrize('entity_type', entity_types)
    def test_recent_search_appears(self, entity_type):
        search_word = 'dua lipa'
        self.app.go_to('')
        self.home_page.is_page_loaded()
        self.home_page.placeholder_search.input_text(search_word)

        # Get entity name and id
        entity_name_1 = self.home_page.search_card_name.get_by(f"{entity_type.capitalize()}s", 1).get_text()

        self.home_page.search_card_name.get_by(f"{entity_type.capitalize()}s", 1).click()
        assert_that(self.artist_page.entity_name.get_text()).is_equal_to(entity_name_1)
        # Add entity to category to check green mark
        entity_id = re.findall(r'[0-9]+', self.app.page.url)[0]
        category_id = self.app.api.insert_category('recent search category')
        self.app.api.insert_entity_to_category(category_id, entity_id, entity_type)
        assert_that(self.app.api.get_category_entities(category_id)).is_not_none()

        self.common_page.btn_return.click()
        # self.app.go_to('')
        self.home_page.is_page_loaded()
        self.app.page.reload()

        # Check Recent Results section items:
        self.home_page.placeholder_search.click()
        recent_search_name_1 = self.home_page.search_card_name.get_by("Recent Results", 1).get_text()
        assert_that(recent_search_name_1).is_equal_to(entity_name_1)
        # + added to category
        self.home_page.search_card_green_mark.get_by("Recent Results", 1).exists()

    @allure.title("[Search by name] - Recent Search - Count limit and sorting")
    @allure.description("As user I want to search for artists by name.")
    @allure.testcase("https://data-analytics.atlassian.net/browse/DNAD-728")
    @pytest.mark.smoke
    @pytest.mark.parametrize('entity_type', entity_types)
    def test_search_appears_limit_and_sorting(self, entity_type):
        # Add 21 entities to Recent Results
        entities = self.app.api.get_entities(entity_type, 21)
        recent_results = []
        for entity in entities:
            print(entity['id'], entity['name'])
            recent_results.append(entity['name'])
            self.app.api.add_to_recent_searches(entity['id'], entity_type)

        self.app.go_to('')
        self.home_page.is_page_loaded()
        self.home_page.placeholder_search.click()

        # Check limitations
        assert_that(self.home_page.search_card_item.get_by("Recent Results").get_count()).is_equal_to(20)
        # Check entities as shown in Recent Results section with DESC sorting
        for i in range(1, 21):
            assert_that(self.home_page.search_card_name.get_by("Recent Results", i).get_text()).is_equal_to(
                recent_results[-i])

        # Add random entity to Recent Results
        random_n = random.choice(range(20))
        random_entity_id = entities[random_n]['id']
        random_entity_name = entities[random_n]['name']
        self.app.api.add_to_recent_searches(random_entity_id, entity_type)
        # ...and check it's no top
        self.app.go_to('')
        self.home_page.is_page_loaded()
        self.home_page.placeholder_search.click()
        assert_that(self.home_page.search_card_name.get_by("Recent Results", 1).get_text()).is_equal_to(
            random_entity_name)