import random
import time

from selenium.common import InvalidArgumentException
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait

from elements.interface_1_elements import Interface_1_elements
from utils.element_related_methods import (
    get_clickable_element,
    get_element,
    get_invisible_element,
)
from utils.logger import get_logger


class Interface_1(Interface_1_elements):
    logger = get_logger()
    selected_batch = ""
    result_message = None
    p_element = None

    def __init__(self, driver, config):
        self.driver = driver
        self.config = config

    def select_client(self, client_name=""):
        client_name_dropdown = super().get_client_name_dropdown(
            self.driver, self.config
        )
        client_name_dropdown.click()
        client_list = super().get_client_list(self.driver)
        assert len(client_list) > 0
        if client_name == "":
            random_number = random.randint(0, len(client_list) - 1)
            time.sleep(1)
            self.logger.debug(
                f"Selected Client Name: {client_list[random_number].text}"
            )
            client_name = client_list[random_number].text
            client_list[random_number].click()
        else:
            for client in client_list:
                if client_name == client.text:
                    client.click()
                    self.logger.debug(f"Selected Client Name: {client_name}")
                    break
        time.sleep(20)
        return client_name

    def select_batch(self, batch_id_name=""):
        batch_id = super().get_batch_id(self.driver, self.config)
        batch_id.click()
        batch_id_list = super().get_batch_id_list(self.driver)
        assert len(batch_id_list) > 0
        if batch_id_name == "":
            random_number = random.randint(1, len(batch_id_list) - 1)
            self.selected_batch = batch_id_list[random_number].text
            time.sleep(1)
            self.logger.debug(f"Selected Batch: {batch_id_list[random_number].text}")
            batch_id_name = batch_id_list[random_number].text
            time.sleep(1)
            batch_id_list[random_number].click()
        else:
            for batch in batch_id_list:
                if batch.text == batch_id_name:
                    batch.click()
                    self.selected_batch = batch_id_name
                    self.logger.debug(f"Selected Batch: {batch_id_name}")
                    break
        time.sleep(5)
        return batch_id_name

    def check_group_no(self, group_checkbox=None):
        if group_checkbox is None:
            group_checkbox = []
        checkbox_list = super().get_checkbox_list(self.driver)
        assert len(checkbox_list) > 0
        if len(group_checkbox) > 0:
            checked_groups = ""
            for checkbox in checkbox_list:
                if checkbox.text in group_checkbox:
                    checkbox.click()
                    checked_groups = f"{checked_groups}{checkbox.text}, "
            self.logger.debug(f"checked Group No.: {checked_groups[:-2]}")
        else:
            random_number = random.randint(0, len(checkbox_list) - 1)
            random_elements = random.sample(checkbox_list, random_number)
            checked_groups = ""
            for checkbox in random_elements:
                time.sleep(1)
                checkbox.click()
                time.sleep(1)
                checked_groups = f"{checked_groups}{checkbox.text}, "
            self.logger.debug(f"checked Group No.: {checked_groups[:-2]}")
        time.sleep(5)

    def click_read_the_contracts_from_path(self):
        read_the_contracts_from_path_btn = super().get_read_the_contracts_from_path_btn(
            self.driver, self.config
        )
        read_the_contracts_from_path_btn.click()
        time.sleep(5)

    def check_table_contain(self):
        result_table = super().get_result_table(self.driver, self.config)
        rows = super().get_table_rows(result_table)
        for row in rows:
            print(row)
        if len(rows) > 0:
            self.logger.debug(
                f"{len(rows)} contracts are read from batch: {self.selected_batch}"
            )
            assert True
        else:
            assert False
        time.sleep(5)

    def click_run_doczy_ai_pipeline(self):
        run_doczy_ai_pipeline_btn = super().get_run_doczy_ai_pipeline_btn(
            self.driver, self.config
        )
        run_doczy_ai_pipeline_btn.click()
        time.sleep(3)
        self.result_message = super().get_error(self.driver, self.config)
        time.sleep(3)