import os
import random
import time
from time import sleep

from loguru import logger
from selenium.common.exceptions import NoSuchElementException, StaleElementReferenceException, \
    InvalidArgumentException
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By
from selenium.webdriver.remote.webelement import WebElement
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

from emulate_user_live.generate_user_data import GenerateUser
from emulate_user_live.mobile_pages import selector_mobile_page as sl
from emulate_user_live.start_base import BaseLoginPage


class UserAction(BaseLoginPage):
    """ User Action Cases """

    def scroll_to_element_page(self, element: WebElement):
        """ Action to move element """
        actions = ActionChains(self.driver)
        actions.move_to_element(element)
        actions.perform()

    @staticmethod
    def get_post_params(element):
        """ Get count (like, comment, share )"""
        count_params = element.get_attribute('aria-label')
        return int(count_params.split()[0])

    def random_action(self):
        action_list = [
            'scroll_like_share_back',
            'scroll_comment_back',
            'scroll_read_more_text_back',
            'scroll_like_back',
            'scroll_wall_back'
        ]
        rand_attr = random.choice(action_list)
        return getattr(self, rand_attr)()

    def scroll_wall_back(self, selector_page = None, len_posts: int=random.randint(25, 85)):
        """
        For day session scroll random post without condition
        if page have a list post
        :param len_posts: count scroll posts
        :param selector_page: XPATH selector of page
        """
        logger.info('start scroll_wall_back')
        sleep(1)
        if selector_page:
            groups_page = self.driver.find_element(By.XPATH, selector_page)
            self.click_human_like(groups_page)

        for i in range(len_posts):
            try:
                post = self.driver.find_elements(By.XPATH, sl.GROUP_POST_LIST)[i]
                self.scroll_to_element_page(post)
            except IndexError:
                self.driver.refresh()
                post = self.driver.find_elements(By.XPATH, sl.GROUP_POST_LIST)[i]
            # time to watch posts
            sleep(random.uniform(0.5, 0.9))

        location_last_post = post.location['y']

        for j in range(location_last_post, 0, -random.randint(300, 650)):
            self.driver.execute_script(f"window.scrollTo(0, {j});")
            sleep(random.uniform(0.5, 3.7))

        self.driver.execute_script(f"window.scrollTo(0, 0);")

        logger.info('end scroll_wall_back')

    def scroll_like_back(self, selector_page = None, len_posts: int=random.randint(35, 70)):
        """ Scroll like post and back to page """
        logger.info('start scroll_like_back')
        sleep(1)
        if selector_page:
            groups_page = self.driver.find_element(By.XPATH, selector_page)
            self.click_human_like(groups_page)

        posts = self.driver.find_elements(By.XPATH, sl.GROUP_POST_LIST)
        count_post_on_page = len(posts)

        for i in range(len_posts):

            if i == count_post_on_page:
                self.driver.refresh()

            post = self.driver.find_elements(By.XPATH, sl.GROUP_POST_LIST)[i]
            self.scroll_to_element_page(post)

            # try:
            #     post = self.driver.find_elements(By.XPATH, sl.GROUP_POST_LIST)[i]
            #     self.scroll_to_element_page(post)
            # except IndexError:
            #     self.driver.refresh()
            #     post = self.driver.find_elements(By.XPATH, sl.GROUP_POST_LIST)[i]
            # time to watch posts
            sleep(random.uniform(0.9, 1.7))

            # condition like
            try:
                like_on_post = post.find_element_by_class_name("item_like")
                liked = "item_sel" in like_on_post.get_attribute("class")
                if liked:
                    self.scroll_to_element_page(post)
                    continue
                else:
                    like_count = self.get_post_params(like_on_post)
                    if like_count > random.randint(4500, 10000):
                        # scroll to like on post
                        self.scroll_to_element_page(like_on_post)
                        like_on_post.click()
                        sleep(random.uniform(0.5, 1.5))
            except NoSuchElementException:
                pass

        location_last_post = post.location['y']

        for j in range(location_last_post, 0, -random.randint(750, 2000)):
            self.driver.execute_script(f"window.scrollTo(0, {j});")
            sleep(random.uniform(0.5, 0.9))

        self.driver.execute_script(f"window.scrollTo(0, 0);")

        logger.info('end scroll_like_back')

    def scroll_read_more_text_back(self, selector_page = None, len_posts: int=random.randint(25, 60)):
        logger.info('start scroll_read_more_text_back')
        sleep(1)
        if selector_page:
            groups_page = self.driver.find_element(By.XPATH, selector_page)
            self.click_human_like(groups_page)

        posts = self.driver.find_elements(By.XPATH, sl.GROUP_POST_LIST)
        count_post_on_page = len(posts)

        for i in range(len_posts):

            if i == count_post_on_page:
                self.driver.refresh()

            post = self.driver.find_elements(By.XPATH, sl.GROUP_POST_LIST)[i]
            self.scroll_to_element_page(post)
            # time to watch posts
            sleep(random.uniform(0.4, 1.1))

            # condition for more text in post
            try:
                big_post = post.find_element_by_class_name("pi_text_more")
                big_post_mark = 'pi_text_more' in big_post.get_attribute('class')
                if big_post_mark:
                    big_post.click()
                    sleep(random.uniform(3.2, 7.6))
            except NoSuchElementException:
                pass

        location_last_post = post.location['y']

        for j in range(location_last_post, 0, -random.randint(400, 2500)):
            self.driver.execute_script(f"window.scrollTo(0, {j});")
            sleep(random.uniform(0.5, 2.7))

        self.driver.execute_script(f"window.scrollTo(0, 0);")
        logger.info('end scroll_read_more_text_back')

    def scroll_comment_back(self, selector_page=None, len_posts: int=random.randint(45, 70)):
        logger.info('start scroll_comment_back')
        condition_to_comment = random.randint(290, 350)
        sleep(1)
        if selector_page:
            groups_page = self.driver.find_element(By.XPATH, selector_page)
            self.click_human_like(groups_page)

        posts = self.driver.find_elements(By.XPATH, sl.GROUP_POST_LIST)
        count_post_on_page = len(posts)

        for i in range(len_posts):

            if i == count_post_on_page:
                self.driver.refresh()

            post = self.driver.find_elements(By.XPATH, sl.GROUP_POST_LIST)[i]
            self.scroll_to_element_page(post)
            # time to watch posts
            sleep(random.uniform(0.7, 3.1))

            # condition to comments
            try:
                comments_on_post = post.find_element_by_class_name('item_replies')
                comments_count = self.get_post_params(comments_on_post)
                if comments_count > condition_to_comment:
                    # scroll to comments on post
                    comments_on_post.click()
                    sleep(4)
                    comments_users = self.driver.find_elements(By.XPATH, sl.WATCH_COMMENT)
                    view_some_comments = int(len(comments_users) / 4)
                    for j in range(view_some_comments):
                        scroll_comments = comments_users[j]
                        self.scroll_to_element_page(scroll_comments)
                        sleep(random.uniform(0.4, 2.3))

                    # send sticker in comments
                    send_sticker = self.driver.find_element(By.XPATH, sl.STICKER)
                    self.click_human_like(send_sticker)

                    selected_random_sticker = self.driver.find_elements(By.XPATH, sl.SELECT_EMOJI)[
                        random.randint(0, 25)]
                    self.scroll_to_element_page(selected_random_sticker)
                    self.click_human_like(selected_random_sticker)
                    sleep(random.uniform(0.5, 1.7))

                # return to group post
                self.driver.execute_script("window.history.go(-1)")
            except NoSuchElementException:
                pass

        location_last_post = post.location['y']

        for j in range(location_last_post, 0, -random.randint(300, 900)):
            self.driver.execute_script(f"window.scrollTo(0, {j});")
            sleep(random.uniform(0.5, 1.7))

        self.driver.execute_script(f"window.scrollTo(0, 0);")

        logger.info('end scroll_comment_back')

    def scroll_like_share_back(self, selector_page=None, len_posts: int=random.randint(45, 70)):
        logger.info('start scroll_like_share_back')
        condition_to_like = random.randint(4500, 15000)
        condition_to_share = random.randint(290, 450)
        sleep(1)
        if selector_page:
            groups_page = self.driver.find_element(By.XPATH, selector_page)
            self.click_human_like(groups_page)

        posts = self.driver.find_elements(By.XPATH, sl.GROUP_POST_LIST)
        count_post_on_page = len(posts)

        for i in range(len_posts):

            if i == count_post_on_page:
                self.driver.refresh()

            post = self.driver.find_elements(By.XPATH, sl.GROUP_POST_LIST)[i]
            self.scroll_to_element_page(post)
            # time to watch posts
            sleep(random.uniform(0.4, 1.1))

            # condition like and share post
            try:
                like_on_post = post.find_element(By.CLASS_NAME, 'item_like')
                share_on_post = post.find_element(By.CLASS_NAME, 'item_share')
                liked = "item_sel" in like_on_post.get_attribute("class")
                shared = "item_sel" in share_on_post.get_attribute("class")
                if not liked:
                    like_count = self.get_post_params(like_on_post)
                    share_count = self.get_post_params(share_on_post)
                    # condition_to_share = random.randint(250, 300)
                    if like_count > condition_to_like:
                        # scroll to like on post
                        self.scroll_to_element_page(like_on_post)
                        like_on_post.click()
                        sleep(random.uniform(0.4, 3.1))
                        logger.info('like this post')

                    if share_count > condition_to_share:
                        if not shared:
                            self.click_human_like(share_on_post)
                            share_on_page = self.driver.find_element(By.XPATH,
                                                                     sl.SHARE_POST_ON_USER_PAGE)
                            self.click_human_like(share_on_page)
                            publish_share = self.driver.find_element(By.XPATH, sl.PUBLISH_SHARE)
                            self.scroll_to_element_page(publish_share)
                            self.click_human_like(publish_share)
                            sleep(4)
                            self.driver.refresh()

                else:
                    logger.info('post liked')
                    self.scroll_to_element_page(post)
                    continue
            except NoSuchElementException:
                pass

        location_last_post = post.location['y']

        for j in range(location_last_post, 0, -random.randint(300, 650)):
            self.driver.execute_script(f"window.scrollTo(0, {j});")
            sleep(random.uniform(0.5, 1.7))

        self.driver.execute_script(f"window.scrollTo(0, 0);")

        logger.info('end scroll_like_share_back')

    def condition_to_join_group(self, len_posts: int=random.randint(45, 70)) -> int:
        """
        Check condition on post in group
        else back to group find new group
        """
        condition_to_like = random.randint(4500, 15000)
        condition_to_comment = random.randint(290, 350)
        condition_to_share = random.randint(290, 450)
        condition_to_join_group = random.randint(1200000, 1500000)
        random_sticker = random.randint(0, 25)

        join_group = 0
        sum_views_in_post = 0

        # if group has post
        if self.check_element_on_page(sl.GROUP_POST_LIST):

            posts = self.driver.find_elements(By.XPATH, sl.GROUP_POST_LIST)
            count_post_on_page = len(posts)

            for i in range(len_posts):
                # update driver to check new posts
                if i == count_post_on_page:
                    self.driver.refresh()

                # condition for len post in group
                if i > count_post_on_page:
                    try:
                        post = self.driver.find_elements(By.XPATH, sl.GROUP_POST_LIST)[i]
                        self.scroll_to_element_page(post)
                        # time to watch posts
                        sleep(random.uniform(0.4, 1.1))
                    except IndexError:
                        location_last_post = post.location['y']
                        for j in range(location_last_post, 0, -random.randint(420, 1050)):
                            self.driver.execute_script(f"window.scrollTo(0, {j});")
                            sleep(random.uniform(0.5, 1.7))
                        self.driver.execute_script(f"window.scrollTo(0, 0);")
                        self.driver.execute_script("window.history.go(-1)")
                        # todo: return to group list add action to next group
                        break
                try:
                    post = self.driver.find_elements(By.XPATH, sl.GROUP_POST_LIST)[i]
                    self.scroll_to_element_page(post)
                except IndexError:
                    self.driver.refresh()
                    post = self.driver.find_elements(By.XPATH, sl.GROUP_POST_LIST)[i]
                    self.scroll_to_element_page(post)
                # time to watch posts
                sleep(random.uniform(0.4, 0.7))

                # try:
                #     big_post = post.find_element_by_class_name("pi_text_more")
                #     big_post_mark = 'pi_text_more' in big_post.get_attribute('class')
                #     if big_post_mark:
                #         sleep(random.uniform(0.2, 1.7))
                #         WebDriverWait(post, 5).until(EC.presence_of_element_located((By.CLASS_NAME, "pi_text_more")))
                #         big_post.click()
                #         sleep(random.uniform(5.2, 6.7))
                # except NoSuchElementException:
                #     pass

                # condition for views to join group
                try:
                    views = post.find_element_by_class_name("item_views ")
                    sum_views_in_post += self.get_post_params(views)
                except AttributeError:
                    sum_views_in_post += 0

                # condition like and share post
                try:
                    like_on_post = post.find_element(By.CLASS_NAME, 'item_like')
                    share_on_post = post.find_element(By.CLASS_NAME, 'item_share')
                    liked = "item_sel" in like_on_post.get_attribute("class")
                    shared = "item_sel" in share_on_post.get_attribute("class")
                    if not liked:
                        like_count = self.get_post_params(like_on_post)
                        share_count = self.get_post_params(share_on_post)
                        # condition_to_share = random.randint(250, 300)
                        if like_count > condition_to_like:
                            # scroll to like on post
                            self.scroll_to_element_page(like_on_post)
                            like_on_post.click()
                            sleep(random.uniform(0.4, 1.1))
                            logger.info('like this post')

                        # if share_count > condition_to_share:
                        #     if not shared:
                        #         self.click_human_like(share_on_post)
                        #         share_on_page = self.driver.find_element(By.XPATH,
                        #                                                  sl.SHARE_POST_ON_USER_PAGE)
                        #         self.click_human_like(share_on_page)
                        #         publish_share = self.driver.find_element(By.XPATH, sl.PUBLISH_SHARE)
                        #         self.scroll_to_element_page(publish_share)
                        #         self.click_human_like(publish_share)
                        #         sleep(4)
                        #         self.driver.refresh()
                        #     else:
                        #         logger.info('post shared')
                    else:
                        logger.info('post liked')
                        self.scroll_to_element_page(post)
                        continue
                except NoSuchElementException:
                    pass

                # condition comments on post
                # try:
                #     comments_on_post = post.find_element_by_class_name('item_replies')
                #     comments_count = self.get_post_params(comments_on_post)
                #     if comments_count > condition_to_comment:
                #         # scroll to comments on post
                #         comments_on_post.click()
                #         sleep(4)
                #         comments_users = self.driver.find_elements(By.XPATH, sl.WATCH_COMMENT)
                #         view_some_comments = int(len(comments_users) / 5)
                #         for j in range(view_some_comments):
                #             scroll_comments = comments_users[j]
                #             self.scroll_to_element_page(scroll_comments)
                #             sleep(random.uniform(0.4, 2.3))
                #
                #         # send sticker in comments
                #         send_sticker = self.driver.find_element(By.XPATH, sl.STICKER)
                #         self.click_human_like(send_sticker)
                #
                #         selected_random_sticker = self.driver.find_elements(By.XPATH, sl.SELECT_EMOJI)[random_sticker]
                #         self.scroll_to_element_page(selected_random_sticker)
                #         self.click_human_like(selected_random_sticker)
                #         sleep(random.uniform(0.5, 1.7))
                #
                #     # return to group post
                #     self.driver.execute_script("window.history.go(-1)")
                # except NoSuchElementException:
                #     pass

            # condition to join group of views
            if sum_views_in_post > condition_to_join_group:
                location_last_post = post.location['y']
                # scroll to top
                for number in range(location_last_post, 0, -random.randint(500, 1250)):
                    self.driver.execute_script(f"window.scrollTo(0, {number});")
                    sleep(random.uniform(0.5, 0.7))

                # scrolled on top
                self.driver.execute_script("window.scrollTo(0, 0);")

                # join to group and communities and return to main page
                if self.check_element_on_page(sl.JOIN_GROUP):
                    self.join_group(sl.JOIN_GROUP)
                    join_group += 1
                    return join_group

                if self.check_element_on_page(sl.GR_COMMUNITY_JOIN):
                    self.join_group(sl.GR_COMMUNITY_JOIN)
                    join_group += 1
                    return join_group

                if self.check_element_on_page(sl.FOLLOWS_BUTTON):
                    self.join_group(sl.FOLLOWS_BUTTON)
                    join_group += 1
                    return join_group

            else:
                # todo: action to next step
                # return to group list
                self.driver.execute_script("window.history.go(-1)")
                return join_group
        else:
            # return to group list
            # todo: action to next step
            self.driver.execute_script("window.history.go(-1)")
            return join_group

    def search_group_in_group_list(self, group_name: str, default_group: int=random.randint(0, 3)) -> WebElement:
        """
        search field the group check on group elements on page
        and select random group with recursion
        :return group
        """
        field_find_group = self.driver.find_element(By.XPATH, sl.SEARCH_GROUP)
        self.send_keys_human_like(field_find_group, group_name)
        sleep(4)
        group_list = self.driver.find_elements(By.XPATH, sl.GROUP_LIST)

        if len(group_list) > 5:
            group = self.driver.find_elements(By.XPATH, sl.GROUP_LIST)[default_group]
            self.scroll_to_element_page(group)
            return group
        else:
            self.send_keys_human_like(field_find_group, ' ')
            group_list = self.driver.find_elements(By.XPATH, sl.GROUP_LIST)
            if len(group_list) > 5:
                group = self.driver.find_elements(By.XPATH, sl.GROUP_LIST)[default_group]
                self.scroll_to_element_page(group)
                return group
            else:
                field_find_group.clear()
                # group = GenerateUser.create_group()
                return self.search_group_in_group_list(group_name)

    def get_list_group(self):
        """ Condition for user groups """
        sleep(3)
        search_group = GenerateUser.create_group()
        len_search_group = len(search_group.split(' '))
        # typing_group = ''
        # create_random_search_group = random.randint(2, 4)
        if len_search_group > 3:
            typing_group = str(search_group.split(' ')[0] + ' ' + search_group.split(' ')[1])
        elif len_search_group == 1:
            typing_group = str(search_group)
        else:
            typing_group = search_group

        logger.info('search group start')
        groups_page = self.driver.find_element(By.XPATH, sl.GROUPS_PAGE)
        self.click_human_like(groups_page)

        if self.check_element_on_page(sl.USER_GROUP_EMPTY):
            group = self.search_group_in_group_list(typing_group)
            self.click_human_like(group)
            join_group = self.condition_to_join_group()
            if join_group:
                logger.info("join the group")
        else:
            # count group to join
            group = self.search_group_in_group_list(typing_group)
            self.click_human_like(group)
            join_group = self.condition_to_join_group()
            if join_group:
                logger.info("join the group")

    def action_in_group(self):
        groups_page = self.driver.find_element(By.XPATH, sl.GROUPS_PAGE)
        self.click_human_like(groups_page)
        self.work_in_groups()

    def get_group(self, group_list: list) -> WebElement:
        group = group_list[random.randint(0, 5)]
        self.scroll_to_element_page(group)
        return group

    def join_group(self, selector):
        """ JOIN group, community, follows page and return to main page """
        sleep(random.randint(1, 3))
        join = self.driver.find_element(By.XPATH, selector)
        self.scroll_to_element_page(join)
        join.click()
        sleep(random.randint(1, 5))

        # return main page

        # self.driver.execute_script('window.history.go(-1)')
        try:
            self.driver.refresh()
            news_page = self.driver.find_element('//a[@role="button" and @aria-label="Новости "]')
            self.click_human_like(news_page)
        except InvalidArgumentException:
            self.driver.execute_script('window.history.go(-1)')

    def work_in_groups(self):
        logger.info('start work with group')
        self.driver.refresh()
        top_group = GenerateUser.create_group()
        # go to group page # todo: output action

        field_find_group = self.driver.find_element(By.XPATH, sl.SEARCH_GROUP)
        self.send_keys_human_like(field_find_group, top_group)
        sleep(4)

        group_list = self.driver.find_elements(By.XPATH, sl.GROUP_LIST)

        if len(group_list) > 5:
            group = self.get_group(group_list)
            self.click_human_like(group)
            join_group = self.condition_to_join_group()
            if not join_group:
                self.driver.refresh()
                field_find_group = self.driver.find_element(By.XPATH, sl.SEARCH_GROUP)
                field_find_group.clear()
                self.send_keys_human_like(field_find_group, top_group)
                group_list = self.driver.find_elements(By.XPATH, sl.GROUP_LIST)
                group = self.get_group(group_list)
                self.click_human_like(group)
                self.random_action()
            else:
                logger.info('join the group')
        else:
            self.send_keys_human_like(field_find_group, ' ')
            group_list = self.driver.find_elements(By.XPATH, sl.GROUP_LIST)
            if len(group_list) > 5:
                self.send_keys_human_like(field_find_group, top_group)
                group_list = self.driver.find_elements(By.XPATH, sl.GROUP_LIST)
                group = self.get_group(group_list)
                self.click_human_like(group)
                join_group = self.condition_to_join_group()
                if not join_group:
                    group = self.get_group(group_list)
                    self.click_human_like(group)
                    self.random_action()
                else:
                    logger.info('join the group')
            else:
                # field_find_group.clear()
                self.driver.refresh()
                return self.work_in_groups()

        # # if self.check_element_on_page(sl.USER_GROUP_EMPTY):
        # self.random_action()
        # join_group = self.condition_to_join_group()
        # if not join_group:
        #     group_list = self.driver.find_elements(By.XPATH, sl.GROUP_LIST)
        #     self.get_group(group_list)


    def morning_session(self):
        # todo: add comment for morning session
        deadline = time.monotonic() + random.randint(200, 300)
        while time.monotonic() < deadline:
            self.scroll_wall_back(sl.NEWS_PAGE)
            # self.scroll_wall_back(sl.NEWS_PAGE)
            time.sleep(random.randint(3, 10))

            if time.monotonic() < deadline:
                self.close_session()
                self.driver.close()

            self.scroll_wall_back(sl.RECOMMENDATIONS_PAGE)
            time.sleep(random.randint(7, 13))

        self.close_session()
        self.driver.close()

    # def day_session(self):
    #     deadline = time.monotonic() + random.randint(500, 1000)
    #     while time.monotonic() < deadline:
    #         time.sleep(random.randint(1, 2))
    #         self.scroll_and_analysis_news_wall()
    #
    #         time.sleep(random.randint(3, 7))
    #         self.get_list_group()
    #
    # def night_session(self):
    #     deadline = time.monotonic() + random.randint(500, 1000)
    #     while time.monotonic() < deadline:
    #         time.sleep(random.randint(1, 2))
    #         self.scroll_and_analysis_news_wall()
    #         time.sleep(random.randint(3, 7))
    #         self.get_list_group()


if __name__ == '__main__':
    vk_login_1 = os.environ.get("LOGIN")
    vk_password_1 = os.environ.get('PASS')
    a = UserAction(vk_login_1, vk_password_1)
    a.get_list_group()
    a.scroll_wall_back(sl.NEWS_PAGE)
    a.scroll_wall_back(sl.RECOMMENDATIONS_PAGE)
    a.get_list_group()

    # a.get_list_group()