from locators import *
from selenium.webdriver.common.keys import Keys
from selenium.common.exceptions import *
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium import webdriver
import time
from random import randint
from selenium.webdriver.common.action_chains import ActionChains


class Instagram:

    def __init__(self, username, password):
        chrome_options = webdriver.ChromeOptions()
        chrome_options.headless = False
        chrome_options.add_argument("--start-maximized")
        self.browser = webdriver.Chrome(chrome_options=chrome_options)
        self._login(username, password)
        self.loop()

    def loop(self):
        while True:
            self.go_to_pascal_followers()
            self.make_random_follow()
            self.go_to_pascal_followers()
            self.make_random_unfollow()

    def _login(self, username, password):
        self.browser.get("https://www.instagram.com/accounts/login/")
        password_field = self._wait_visibility(login_password)
        username_field = self._wait_visibility(login_username)
        username_field.send_keys(username)
        password_field.send_keys(password)
        login_field = self._wait_clickable(login_button)
        login_field.click()
        not_now_field = self._wait_clickable(login_not_now)
        not_now_field.click()

    def go_to_pascal_followers(self):
        home = self._wait_clickable(insta_main)
        home.click()

        searching = self._wait_clickable(search_field)
        searching.send_keys("pascal_vegas")

        pascal_vegas = self._wait_clickable(pascal_vegas_search)
        pascal_vegas.click()

        subbed_field = self._wait_clickable(subbed)
        subbed_field.click()

    def make_random_follow(self, count=0):
        followers = self._wait_visibility(follow_button_list, return_all=True)
        if followers is None:
            close = self._wait_clickable(close_button)
            close.click()
            return
        if count < len(followers):
            # scroll to load more of the list
            for x in range(3):
                scroll = self._wait_visibility(scroll_subbed)
                actions = ActionChains(self.browser)
                actions.move_to_element(scroll).perform()
                time.sleep(1)
            self.make_random_follow(count=len(followers))
        else:
            while len(followers) > 0:
                random_number = randint(0, len(followers) - 1)
                followers[random_number].click()
                del followers[random_number]
                time.sleep(randint(10, 20))
            close = self._wait_clickable(close_button)
            close.click()

    def make_random_unfollow(self, count=0):
        unfollowers = self._wait_visibility(subbed_button_list, return_all=True)
        if unfollowers is None:
            close = self._wait_clickable(close_button)
            close.click()
            return
        if count < len(unfollowers):
            # scroll to load more of the list
            for x in range(3):
                scroll = self._wait_clickable(scroll_subbed)
                actions = ActionChains(self.browser)
                actions.move_to_element(scroll).perform()
                time.sleep(1)
            self.make_random_unfollow(count=len(unfollowers))
        else:
            while len(unfollowers) > 0:
                random_number = randint(0, len(unfollowers) - 1)
                unfollowers[random_number].click()
                confirm = self._wait_clickable(unfollow_confirm_button)
                time.sleep(1)
                confirm.click()
                del unfollowers[random_number]
                time.sleep(randint(10, 20))
            close = self._wait_clickable(close_button)
            close.click()

    def _wait_visibility(self, element, waiting_time=15, return_all=False, not_visible=False):
        try:
            if return_all:
                x = WebDriverWait(self.browser, waiting_time).until(EC.visibility_of_all_elements_located(element))
                return x
            else:
                x = WebDriverWait(self.browser, waiting_time).until(EC.visibility_of_element_located(element))
                return x
        except WebDriverException:
            if not not_visible:
                return
            raise WebDriverException("Element was not visible!")

    def _wait_clickable(self, element, waiting_time=15):
        try:
            x = WebDriverWait(self.browser, waiting_time).until(EC.element_to_be_clickable(element))
            return x
        except WebDriverException:
            raise WebDriverException("Element was not clickable!")


if __name__ == "__main__":
    # usr = input("Please enter your username:")
    # pwd = input("Please enter your password:")
    auto = Instagram("maikikohle31", "raum230")
    # auto = Instagram(usr, pwd)