import time
import datetime
import importlib
from faker import Faker
from selenium import webdriver
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.ui import Select
from selenium.webdriver.common.alert import Alert
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import NoAlertPresentException, \
    ElementNotVisibleException, TimeoutException, ElementNotInteractableException

from core import sets
from .sut import SimplifiedUnitTest


class Base(SimplifiedUnitTest):

    WARNING = "div[class='swal2-popup swal2-modal swal2-show']"

    def __setup__(self):
        super(Base, self).__setup__()
        chrome_options = webdriver.ChromeOptions()
        chrome_options.add_argument("--disable-infobars")
        chrome_options.add_argument("--headless")
        chrome_options.add_argument("window-size=1920,1080")
        self.driver = webdriver.Chrome(options=chrome_options)
        self.options = None
        self.fake = Faker()
        self.date_today = datetime.datetime.strftime(datetime.datetime.now(), '%d/%m/%y')

    def refresh_page(self):
        """
        Open home page
        """
        self.driver.get(self.options.BASE_URL)
        self.wait_till_requests_done_and_document_ready()

    def test_login(self):
        """
        Test for login into client
        """
        if self.options is None:
            raise ValueError("Options are not defined")
        self.driver.get(self.options.BASE_URL)
        WebDriverWait(self.driver, 10).until(
            EC.presence_of_element_located((By.NAME, "submit")),
            "Couldn't load main page to log in"
        )
        Select(self.driver.find_element_by_name("db")).select_by_value(
            self.options.DATABASE
        )
        login = self.driver.find_element_by_name("login")
        password = self.driver.find_element_by_name("password")
        login.send_keys(self.options.USER)
        password.send_keys(self.options.PASSWORD)
        password.submit()
        self.wait_till_requests_done_and_document_ready()
        assert not self.is_error()
        return True

    def is_error(self):
        """
        Check if Enapps error is present
        """
        errors = self.driver.find_elements_by_class_name('ui-dialog-title')
        if len(errors) > 0 and errors[0].text.strip() == "Enapps":
            return True
        return False

    def close_popup(self):
        """
        Close any pop-up
        """
        self.driver.find_element_by_css_selector("button[class*='ui-dialog-titlebar-close']").click()
        self.wait_till_requests_done_and_document_ready()
        return True

    def save_and_close_popup(self):
        """
        Click button Save and Close into popup
        """
        self.driver.find_element_by_css_selector("button[class='oe_button oe_formopenpopup-form-save-close']").click()
        self.wait_till_requests_done_and_document_ready()

    def save_and_close_second_popup(self):
        """
        Click button Save and Close into second popup
        """
        self.driver.find_element_by_xpath("(//button[@class='oe_button oe_formopenpopup-form-save-close'])[2]").click()
        self.wait_till_requests_done_and_document_ready()

    def get_popup(self, name):
        """
        Focus on popup
        """
        spans = self.driver.find_elements_by_class_name("ui-dialog-title")
        for span in spans:
            if span.text == name:
                break
        return self.driver.find_element_by_css_selector(
            "div[aria-labelledby='{}']".format(span.get_attribute("id"))
        )

    def trigger_menu(self, menu_chains):
        """
        Example:
            1. to open Activities: ["CRM", "Activities", "TODO List"]

        :param menu_chains: {list} sequence of menu items
        :return: {boolean} True, False
        """
        main_menu = WebDriverWait(self.driver, 3).until(
            EC.presence_of_element_located((By.ID, "oe_header")),
            "Couldn't load main menu"
        )
        for chain in menu_chains:
            WebDriverWait(main_menu, 1).until(
                EC.presence_of_all_elements_located((By.LINK_TEXT, chain)),
                "Couldn't find menu item {}".format(chain)
            )[-1].click()
        self.wait_till_requests_done_and_document_ready()
        assert not self.is_error() and not self.is_warning()

    def select_view(self, view_type=None):
        """
        Open specified view

        :param view_type: {srt} (list/form/kanban/graph/calendar/map/pivot)
        """
        if view_type is None:
            return None
        view = self.driver.find_element_by_css_selector(
            "button[data-view-type='{}']".format(view_type)
        )
        # check if needed view already chosen
        if view.get_attribute("disabled") == "disabled":
            return True
        view.click()
        return self.wait_till_requests_done_and_document_ready()

    def select_tab(self, name):
        """
        Go to o2many tab
        """
        self.scroll_page_to_top()
        self.driver.find_element_by_partial_link_text(name).click()
        return True

    def close_tab(self, index=0):
        """
        Close tab or tabs
        """
        self.scroll_page_to_top()
        tabs = self.driver.find_elements_by_css_selector(
            "span[class^='close'][class$='icon-remove']"
        )
        if index == -1:
            for tab in tabs:
                tab.click()
                self._handle_alert()
        elif tabs:
            tabs[index].click()
            self._handle_alert()
        return True

    def press_button_on_form_view(self, name, element=None, block=False, max_time=10):
        """
        Press button by name
        """
        form = element if element else self.driver
        warning = f"Could not find button {name}"
        self.scroll_page_to_top()
        WebDriverWait(form, 1).until(
            EC.presence_of_element_located((By.NAME, name)), warning
        ).click()
        self.wait_till_requests_done_and_document_ready(max_time)

    def press_create_button_on_tree_view(self):
        """
        Press button "Create New" on list view
        """
        self.wait_till_requests_done_and_document_ready()
        create_buttons = self.driver.find_elements_by_xpath(
            "//button[@type='button']"
            "[@class='oe_button oe-list-add']"
            "[@original-title='Create New']"
        )
        action = ActionChains(self.driver)
        element = self.driver.find_element_by_xpath("//div[@class='user_content']")
        action.move_to_element(element).perform()
        for button in create_buttons:
            try:
                button.click()
                continue
            except (ElementNotVisibleException, ElementNotInteractableException):
                pass
        self.wait_till_requests_done_and_document_ready()
        msg = "ERROR OR WARNING DETECTED"
        assert not self.is_error() and not self.is_warning(), msg
        return True

    def press_button_on_form_header(self, button_name):
        """
        Allowed buttons: save/cancel/new/copy/delete
        """
        button_class_names = {
            "save": "oe_form_button_save",
            "cancel": "oe_form_button_cancel",
            "new": "oe_form_button_create",
            "copy": "oe_form_button_duplicate",
            "delete": "oe_form_button_delete",
        }
        self.scroll_page_to_top()
        self.driver.find_element_by_css_selector(
            "div[class^='oe_form_buttons'][class$='oe_button_group']"
        ).find_element_by_css_selector(
            "button[class*='{}']".format(button_class_names[button_name])
        ).click()
        self._handle_alert()
        self.wait_till_requests_done_and_document_ready()
        assert not self.is_error() and not self.is_warning()

    def press_search_button(self, element=None):
        """
        Press button "Search"
        """
        self.scroll_page_to_top()
        driver = element if element else self.driver
        driver.find_element_by_name("search").click()
        self.wait_till_requests_done_and_document_ready()

    def _handle_alert(self, action="accept"):
        """
        Allowed actions: [accept/dismiss]
        """
        alert = Alert(self.driver)
        try:
            getattr(alert, action)()
        except NoAlertPresentException:
            pass
        return True

    def is_warning(self):
        """
        Check if warning is present
        """
        return bool(
            self.driver.find_elements_by_css_selector(self.WARNING)
        )

    def wait_till_requests_done_and_document_ready(self, max_time=15, poll_frequency=1):
        """
        Wait when all web processes will be done
        """
        end_time = time.time() + max_time
        while True:
            WebDriverWait(self.driver, max_time, poll_frequency).until(
                lambda driver: driver.execute_script(
                    "return document.readyState"
                ) == "complete",
                "It takes too long to load page"
            )
            WebDriverWait(self.driver, max_time, poll_frequency).until(
                lambda driver: driver.execute_script(
                    "return jQuery.active"
                ) == 0,
                "It takes too long to load page"
            )
            WebDriverWait(self.driver, max_time).until(
                EC.invisibility_of_element_located((
                    By.CSS_SELECTOR,
                    "div[class^='blockUI'][class$='blockOverlay']"
                ))
            )
            if self.driver.execute_script("return jQuery.active") == 0:
                break
            if time.time() > end_time:
                raise TimeoutException("Time out")
        return True

    def trigger_filters(self, enable=None, disable=None, element=None):
        """
        Work with filters on list view
        """
        element = element if element else self.driver
        if enable is None:
            enable = set()
        if disable is None:
            disable = set()
        search_view = WebDriverWait(element, 1).until(
            EC.presence_of_element_located((By.CLASS_NAME, "search_view")),
            "Couldn't locate search view on form"
        )
        if "all" in disable:
            search_view.find_element_by_name("reset").click()
            disable = set()
        filtered_filters = (f for f in disable if f not in enable)
        # disable filters
        for filter_name in filtered_filters:
            f = element.find_element_by_name(filter_name)
            # skip if filter already disabled
            if f.get_attribute("class") == "filter_label":
                continue
            f.click()
        # enable filters
        for filter_name in enable:
            f = element.find_element_by_name(filter_name)
            if f.get_attribute("class") == "filter_label enabled":
                continue
            f.click()
        return self.wait_till_requests_done_and_document_ready()

    def fill_in_field(self, name, field_type, value, element=None):
        """
        Fill data into field
        """
        if element:
            form_view = element
        else:
            form_view = self.driver.find_element_by_css_selector(
                "div[id^='widget'][id$='view_form']"
            )
        if field_type in ("char", "text", "integer", "float", "date"):
            self.wait_till_requests_done_and_document_ready()
            self.clear_field(name, field_type, element=element)
            form_view.find_element_by_name(name).send_keys(value)
        elif field_type == "selection":
            Select(form_view.find_element_by_name(name)).select_by_value(
                value
            )
        elif field_type == "many2one":
            self.clear_field(name, field_type, element=element)
            field = form_view.find_element_by_name(name)
            field.send_keys(Keys.HOME + Keys.SHIFT + Keys.END + Keys.DELETE)
            field.send_keys(value)
            self.wait_till_requests_done_and_document_ready(3)
            field.send_keys(Keys.ARROW_DOWN + Keys.TAB)
        elif field_type == "boolean":
            checkbox = form_view.find_elements_by_css_selector(
                "label[for='{}']".format(
                    form_view.find_element_by_name(name).get_attribute("id")
                )
            )[-1]
            span_class = checkbox.find_element_by_tag_name(
                "span"
            ).get_attribute("class")
            if value is True and span_class == "boolean_icon icon-ok":
                checkbox.click()
            elif value is False and span_class == "boolean_icon icon-ok on":
                checkbox.click()
        return True

    def fill_in_fields(self, fields, save=True, element=None):
        """
        Fill data into fields
        """
        for field in fields:
            self.fill_in_field(*field, element=element)
        assert not self.is_error() and not self.is_warning()
        if save:
            self.press_button_on_form_header("save")
            self.wait_till_requests_done_and_document_ready()
            assert not self.is_error() and not self.is_warning()

    def fill_in_o2m(self, name, records):
        """
        Fill data into field type=o2many
        """
        o2m = self.driver.find_element_by_name(name)
        create = o2m.find_element_by_css_selector(
            "button[class*='oe-list-add']"
        )
        fake_row = "div[class='form-cont']"
        for record in records:
            create.click()
            self.wait_till_requests_done_and_document_ready()
            time.sleep(0.5)
            WebDriverWait(o2m, 7).until(
                EC.element_to_be_clickable((By.CSS_SELECTOR, fake_row)),
                "fake row not found :D"
            )
            self.fill_in_fields(record, save=False, element=o2m)
        return True

    def fill_in_header_on_tree_view(self, name, field_type, value, method="by_text"):
        """
        Fill data into field on list view
        """
        search_header = self.driver.find_elements_by_css_selector(
            "tr[class^='oe-listview-header-columns']"
        )[-1]
        if field_type in ("char", "text", "integer", "float"):
            search_header.find_element_by_name(name).send_keys(value)
        elif field_type == "many2one":
            pass
        elif field_type in ["selection", "boolean"]:
            search_header.find_element_by_css_selector(
                "th[data-id='{}']".format(name)
            ).click()
            select = Select(search_header.find_element_by_name(name))
            if method == "by_text":
                select.select_by_visible_text(value)
                select.select_by_visible_text(value)
            else:
                select.select_by_index(value)
                select.select_by_index(value)

    def read_from_list_view(self, start=0, stop=1, o2m=False):
        """
        Read data from list view
        """
        driver = o2m or self.driver
        content = driver.find_element_by_css_selector(
            "tbody[class*='ui-widget-content']"
        )
        records = []
        for tr in content.find_elements_by_tag_name("tr")[:stop]:
            if not tr.get_attribute("data-id"):
                continue
            values = {}
            for td in tr.find_elements_by_tag_name("td"):
                if "oe-field-cell" not in td.get_attribute("class"):
                    continue
                if "oe_boolean" in td.get_attribute("class"):
                    span = td.find_element_by_tag_name("span")
                    span_class = span.get_attribute("class")
                    if "boolean_icon icon-ok on" in span_class:
                        values[td.get_attribute("data-field")] = True
                    else:
                        values[td.get_attribute("data-field")] = False
                else:
                    values[td.get_attribute("data-field")] = td.text
            records.append(values)
        return records[start:stop]

    def read_from_o2m(self, name, start=0, stop=1):
        """
        Read data from o2many field
        """
        o2m = self.driver.find_element_by_name(name)
        return self.read_from_list_view(start, stop, o2m)

    def clear_field(self, name, field_type, element=None):
        """
        Clear data from field
        """
        if element:
            form_view = element
        else:
            form_view = self.driver.find_element_by_css_selector(
                "div[id^='widget'][id$='view_form']"
            )
        if field_type in ("char", "text", "integer", "float", "date"):
            form_view.find_element_by_name(name).clear()
        elif field_type == "many2one":
            field = form_view.find_element_by_name(name)
            field.send_keys(Keys.SHIFT + Keys.HOME + Keys.DELETE)
        return True

    def get_info_from_field(self, name, attribute, element=None):
        """
        Read data from field on form view
        """
        if element:
            form_view = element
        else:
            form_view = self.driver.find_element_by_css_selector(
                "div[id^='widget'][id$='view_form']"
            )
        if attribute == "editable":
            return form_view.find_element_by_name(name).get_attribute("value")
        return form_view.find_element_by_name(name).text()

    def open_record_from_o2many(self, name, index=0):
        """
        Open record from o2name by index
        """
        o2m = self.driver.find_element_by_name(name)
        o2m.find_elements_by_css_selector("button[name='edit']")[index].click()
        self.wait_till_requests_done_and_document_ready()

    def press_reload_button(self):
        """
        Press button "Reload" on form view
        """
        self.scroll_page_to_top()
        self.driver.find_element_by_css_selector("button[class='oe_vm_switch_reload']").click()
        self.wait_till_requests_done_and_document_ready()

    def select_all_lines_in_o2many(self, name, ):
        """
        Select all records in o2many by button "Select Content"
        """
        self.driver.find_element_by_css_selector(
            "div[name='{}'] button[title='Select Content']".format(name)
        ).click()

    def context_menu(self, name):
        """
        Press context menu on record into o2many
        """
        first_line = self.driver.find_element_by_xpath(name)
        actions = ActionChains(self.driver)
        return actions.context_click(first_line).perform()

    def get_state(self):
        """
        Get state from view
        """
        return self.driver.find_element_by_css_selector(
            "li[class=oe-arrow-list-selected]").text

    def click_button_by_text(self, button_name, block=False):
        """
         Click button by label if button hasn't method
        """
        self.driver.find_element_by_xpath(
            "//*[contains(text(), '')]"
        ).find_element_by_xpath(
            "//*[contains(text(), '{}')]".format(button_name)
        ).click()
        self.wait_till_requests_done_and_document_ready()

    def close_warning(self):
        """
        Click on button Ok for 'Warning!'
        """
        self.driver.find_element_by_css_selector("button[class='swal2-confirm swal_warning_red swal2-styled']").click()
        self.wait_till_requests_done_and_document_ready()

    def click_search_more(self, name, element=None):
        if element:
            form_view = element
        else:
            form_view = self.driver.find_element_by_css_selector(
                "div[id^='widget'][id$='view_form']"
            )
        field = form_view.find_element_by_name(name)
        self.wait_till_requests_done_and_document_ready(3)
        field.send_keys(Keys.ARROW_UP)
        time.sleep(0.2)
        field.send_keys(Keys.ARROW_UP)
        time.sleep(0.2)
        field.send_keys(Keys.ARROW_UP + Keys.ENTER)
        self.wait_till_requests_done_and_document_ready()

    def press_by_action_right_side_bar(self, button_name):
        """
        Click by button from right side bar
        """
        self.driver.find_element_by_xpath(
            "//*[contains(text(), '')]"
        ).find_element_by_xpath(
            "//div[@name='Actions']//*[contains(text(), '{}')]".format(button_name)
        ).click()
        self.wait_till_requests_done_and_document_ready()

    def make_editable_o2many_field(self, field_name, index):
        """
        Click by the line for o2many
        """
        self.driver.find_element_by_xpath(
            "(//td[@data-field='product_id'])"
        ).find_element_by_xpath(
            "(//td[@data-field='{}'])[{}]".format(field_name, index)
        ).click()
        self.wait_till_requests_done_and_document_ready()

    def scroll_page_to_top(self):
        """
        Scroll page to top
        """
        self.driver.execute_script("scroll(0, 0);")
        self.wait_till_requests_done_and_document_ready()

    def press_button_next(self):
        """
        Press Next button on form header
        """
        self.driver.find_element_by_xpath("(//button[@data-pager-action='next'])[last()]").click()
        self.wait_till_requests_done_and_document_ready()

    def click_sidebar(self):
        """
        Open sidebar or close
        """
        self.driver.find_element_by_xpath("//a[@class='toggle-sidebar']").click()
        self.wait_till_requests_done_and_document_ready()

    def wait_records_on_tree_view(self):
        """
        Wait when will be visible records on tree view
        """
        self.ret = False
        try:
            WebDriverWait(self.driver, 10).until(
                EC.element_to_be_clickable((By.XPATH, "(//button[@name='edit'])[last()]")))
        except:
            self.ret = True
        if self.ret ==True:
            try:
                WebDriverWait(self.driver, 10).until(
                    EC.element_to_be_clickable((By.XPATH, "(//th[@class='oe-record-edit-link'])[last()]")))
            except ElementNotVisibleException:
                "Error, element not visible"