#!/usr/bin/env python3
# © 2021-2026 TechnoLibre (http://www.technolibre.ca)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)

import datetime
import getpass
import json
import logging
import os
import random
import re
import subprocess
import sys
import tempfile
import time
import tkinter as tk
from pathlib import Path
from tkinter import filedialog

from pykeepass import PyKeePass
from randomwordfr import RandomWordFr
from selenium import webdriver
from selenium.common.exceptions import (
    ElementClickInterceptedException,
    TimeoutException,
)
from selenium.webdriver import ActionChains
from selenium.webdriver.common.actions.wheel_input import ScrollOrigin
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.firefox.options import Options
from selenium.webdriver.firefox.service import Service
from selenium.webdriver.remote.webelement import WebElement
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import Select, WebDriverWait

new_path = os.path.normpath(
    os.path.join(os.path.dirname(__file__), "..", "..")
)
sys.path.append(new_path)

from script.config import config_file

logging.basicConfig(
    format=(
        "%(asctime)s,%(msecs)d %(levelname)-8s [%(filename)s:%(lineno)d]"
        " %(message)s"
    ),
    datefmt="%Y-%m-%d:%H:%M:%S",
    level=logging.INFO,
)
_logger = logging.getLogger(__name__)


MONTHS_FR = {
    "janvier": 1,
    "février": 2,
    "fevrier": 2,
    "mars": 3,
    "avril": 4,
    "mai": 5,
    "juin": 6,
    "juillet": 7,
    "août": 8,
    "aout": 8,
    "septembre": 9,
    "octobre": 10,
    "novembre": 11,
    "décembre": 12,
    "decembre": 12,
}


class SeleniumLib(object):
    def __init__(self, config):
        self.config = config
        self.wait_human_time = config.human_time_speed
        self.config_file = config_file.ConfigFile()
        self.kdbx = None
        self.video_recorder = None
        self.default_copy_download_dir_path = None
        self.defaut_timeout = 60

        date_str = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
        tmp_dir = tempfile.mkdtemp(
            prefix=f"selenium_download_{date_str}_",
            # dir="/tmp/test/",
        )

        self.default_download_dir_path = tmp_dir

        if self.config.video_suffix:
            self.filename_recording = (
                f"video_{self.config.video_suffix}_"
                + time.strftime("%Y_%m_%d-%H_%M_%S")
                + ".webm"
            )
        else:
            self.filename_recording = (
                "video_" + time.strftime("%Y_%m_%d-%H_%M_%S") + ".webm"
            )
        dir_path_screencast = os.path.join(".", "screencasts")
        self.filename_recording = os.path.join(
            dir_path_screencast, self.filename_recording
        )
        self.dirname_recording = dir_path_screencast
        self.driver = None
        if os.path.isfile(".odoo-version"):
            with open(".odoo-version") as txt:
                self.odoo_version = txt.read()
        else:
            # Default version
            # TODO instead, need to detect the version from client and detection
            self.odoo_version = "18.0"

    def do_screenshot(self):
        if self.config.scenario_screenshot:
            dir_path = os.path.join(".", "screenshots")
            if not os.path.isdir(dir_path):
                os.mkdir(dir_path)
            file_path = os.path.join(
                dir_path,
                f"{self.config.scenario}_{str(int(time.time() * 10000))}.png",
            )
            self.driver.save_screenshot(file_path)

    def configure(self, ignore_open_web=False):
        # Configuration pour lancer Firefox en mode de navigation privée
        firefox_options = webdriver.FirefoxOptions()
        if not self.config.not_private_mode:
            firefox_options.add_argument("--private")

        if self.config.headless:
            firefox_options.add_argument("--headless")

        # firefox_options.set_preference("browser.link.open_newwindow", 3)
        # firefox_options.set_preference("browser.link.open_newwindow.restriction", 2)

        # Définissez la préférence pour les notifications de bureau
        # 1 signifie "autoriser", 2 signifie "bloquer"
        firefox_options.set_preference(
            "permissions.default.desktop-notification", 1
        )
        firefox_options.set_preference("browser.download.folderList", 2)
        firefox_options.set_preference("browser.download.useDownloadDir", True)
        firefox_options.set_preference(
            "browser.download.manager.showWhenStarting", False
        )
        if self.default_download_dir_path:
            firefox_options.set_preference(
                "browser.download.dir", self.default_download_dir_path
            )
        firefox_options.set_preference(
            "browser.helperApps.neverAsk.saveToDisk",
            "application/pdf,"
            "application/x-pdf,"
            "application/vnd.ms-excel,"
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet,"
            "text/csv,"
            "application/octet-stream",
        )
        # disable pdf viewer from firefox
        firefox_options.set_preference("pdfjs.disabled", True)
        firefox_services = None
        if self.config.firefox_binary_path:
            firefox_services = Service(
                executable_path=self.config.firefox_binary_path
            )
        if self.config.gecko_binary_path:
            firefox_options.binary_location = self.config.gecko_binary_path

        # Créez une instance du navigateur Firefox avec les options de navigation privée
        try:
            user = os.environ.get("USER", "Non défini")
            uid = os.getuid()
            gid = os.getgid()
            print(f"INFO: Execute by user: {user}, UID: {uid}, GID: {gid}")

            # Exécuter la commande 'whoami' pour confirmation
            whoami_result = subprocess.run(
                ["whoami"], capture_output=True, text=True
            )
            print(f"INFO: Result 'whoami': {whoami_result.stdout.strip()}")

        except Exception as e:
            print(f"ERROR when check user: {e}")

        driver_url = f"{self.config.use_network}/wd/hub"

        try:
            if self.config.use_chrome_driver:
                from selenium.webdriver.chrome.options import (
                    Options as ChromeOptions,
                )
                from selenium.webdriver.chrome.service import Service

                chrome_options = ChromeOptions()
                if self.config.window_size:
                    # chrome_options.add_argument("--window-size=1920,1080")
                    chrome_options.add_argument(
                        f"--window-size={self.config.window_size}"
                    )

                if self.config.use_network:
                    chrome_options.set_capability(
                        "se:name", "ERPLibre selenium"
                    )
                    chrome_options.enable_downloads = True
                    self.driver = webdriver.Remote(
                        options=chrome_options,
                        command_executor=driver_url,
                    )
                else:
                    from webdriver_manager.chrome import ChromeDriverManager

                    service = Service(
                        ChromeDriverManager().install(),
                        log_path="/tmp/chromedriver.log",
                    )
                    chrome_options.enable_downloads = True
                    self.driver = webdriver.Chrome(
                        options=chrome_options,
                        # options=firefox_options,
                        service=service,
                        keep_alive=True,
                    )
            elif self.config.use_firefox_driver:
                from selenium.webdriver.firefox.options import Options
                from selenium.webdriver.firefox.service import Service

                firefox_services = None
                # shutil.which("geckodriver")
                if self.config.gecko_binary_path:
                    firefox_services = Service(
                        executable_path=self.config.gecko_binary_path,
                        log_output=self.config.debug,
                    )
                firefox_options = webdriver.FirefoxOptions()
                if not self.config.not_private_mode:
                    firefox_options.add_argument("--private")

                if self.config.firefox_binary_path:
                    firefox_options.binary_location = (
                        self.config.firefox_binary_path
                    )
                elif not self.config.use_network:
                    # test snap firefox for Ubuntu first
                    snap_firefox_path = (
                        "/snap/firefox/current/usr/lib/firefox/firefox"
                    )
                    firefox_path_exist = Path(snap_firefox_path).exists()
                    if firefox_path_exist:
                        firefox_options.binary_location = snap_firefox_path
                    else:
                        status_location = subprocess.check_output(
                            ["which", "firefox"], text=True
                        ).strip()
                        firefox_options.binary_location = status_location

                firefox_profile = webdriver.FirefoxProfile()
                firefox_profile.set_preference(
                    "browser.cache.disk.enable", False
                )
                firefox_profile.set_preference(
                    "browser.cache.memory.enable", False
                )
                firefox_profile.set_preference(
                    "browser.cache.offline.enable", False
                )
                firefox_profile.set_preference("network.http.use-cache", False)
                firefox_options.set_preference(
                    "permissions.default.desktop-notification", 1
                )
                firefox_options.set_preference(
                    "browser.download.folderList", 2
                )
                firefox_options.set_preference(
                    "browser.download.manager.showWhenStarting", False
                )
                if self.default_download_dir_path:
                    firefox_options.set_preference(
                        "browser.download.dir", self.default_download_dir_path
                    )
                firefox_options.set_preference(
                    "browser.helperApps.neverAsk.saveToDisk",
                    "application/octet-stream,application/pdf,application/x-pdf",
                )
                firefox_options.set_preference("pdfjs.disabled", True)
                if self.config.window_size:
                    # chrome_options.add_argument("--window-size=1920,1080")
                    # firefox_options.add_argument(
                    #     f"--window-size={self.config.window_size}"
                    # )
                    width, height = self.config.window_size.split(",")
                    firefox_options.add_argument("--width=" + str(width))
                    firefox_options.add_argument("--height=" + str(height))

                if self.config.headless:
                    firefox_options.add_argument("--headless")
                    # firefox_options.add_argument("--disable-gpu")
                firefox_options.add_argument("--no-sandbox")
                firefox_options.add_argument("--disable-dev-shm-usage")
                firefox_options.add_argument("--disable-dbus")

                if self.config.use_network:
                    firefox_options.set_capability(
                        "se:name", "ERPLibre selenium"
                    )
                    firefox_options.enable_downloads = True
                    self.driver = webdriver.Remote(
                        options=firefox_options,
                        command_executor=driver_url,
                    )
                else:
                    firefox_options.add_argument("-remote-allow-system-access")
                    self.driver = webdriver.Firefox(
                        options=firefox_options,
                        service=firefox_services,
                        keep_alive=True,
                    )

        except Exception as e:
            print(
                "Cannot open Firefox profile, so will force firefox snap for"
                " Ubuntu users."
            )
            # TODO au lieu, faire une recherche de geckodriver avant de démarrer
            # firefox_services = Service(
            #     executable_path=getoutput(
            #         "find /snap/firefox -name geckodriver"
            #     ).split("\n")[-1], log_path='/tmp/geckodriver.log'
            # )
            # firefox_options.binary_location = getoutput(
            #     "find /snap/firefox -name firefox"
            # ).split("\n")[-1]
            # self.driver = webdriver.Firefox(
            #     options=firefox_options, service=firefox_services
            # )
            raise e
        print("The driver is launched!")

        # Ajout de l'enregistrement
        if self.config.record_mode:
            # Create recording
            from script.selenium.selenium_video import VideoRecorder

            if not os.path.isdir(self.dirname_recording):
                os.mkdir(self.dirname_recording)

            self.video_recorder = VideoRecorder(
                self.driver, filename=self.filename_recording
            )
            # import vlc

        # Install DarkReader to help my eyes
        # TODO do a script to check if it's the last version
        if self.config.use_firefox_driver and not self.config.use_network:
            if not self.config.no_dark_mode:
                self.driver.install_addon(
                    os.path.join(
                        new_path, "script/selenium/darkreader-firefox.xpi"
                    ),
                    temporary=True,
                )
                self.driver.install_addon(
                    os.path.join(
                        new_path, "script/selenium/odoo_debug-4.0.xpi"
                    ),
                    temporary=True,
                )

            if (
                not self.config.not_private_mode
                and not self.config.no_dark_mode
            ):
                # self.driver.set_context("chrome")
                self.driver.get("about:addons")
                # Enable Dark Reader into incognito
                # Click Extensions
                self.click('//button[@viewid="addons://list/extension"]')
                self.click(
                    "/html/body/div/div[2]/div/addon-list/section[1]/addon-card/div/div/div/div/button",
                )
                self.click(
                    "/html/body/div/div[2]/div/addon-list/section[1]/addon-card/div/addon-options/panel-list/panel-item[5]",
                )
                # Enable Run in Private Windows
                try:
                    self.click(
                        "/html/body/div/div[2]/div/addon-card/div/addon-details/named-deck/section/div[6]/div/label[1]/input",
                    )
                except Exception:
                    # For old version before Firefox 138
                    self.click(
                        "/html/body/div/div[2]/div/addon-card/div/addon-details/named-deck/section/div[5]/div/label[1]/input",
                    )

                # Enable Odoo_debug into incognito
                # Back
                self.click(
                    "/html/body/div/div[2]/addon-page-header/div/div[2]/button"
                )
                self.click(
                    "/html/body/div/div[2]/div/addon-list/section[1]/addon-card[2]/div/div/div/div/button",
                )
                self.click(
                    "/html/body/div/div[2]/div/addon-list/section[1]/addon-card[2]/div/addon-options/panel-list/panel-item[5]",
                )
                # Enable Run in Private Windows
                try:
                    self.click(
                        "/html/body/div/div[2]/div/addon-card/div/addon-details/named-deck/section/div[6]/div/label[1]/input",
                    )
                except Exception:
                    # For old version before Firefox 138
                    self.click(
                        "/html/body/div/div[2]/div/addon-card/div/addon-details/named-deck/section/div[5]/div/label[1]/input",
                    )

        # Ouvrez la page web
        if not ignore_open_web:
            self.driver.get(f"{self.config.url}/web")

        # Close tab opening by DarkReader
        if self.config.use_firefox_driver and not self.config.use_network:
            if self.config.not_private_mode and not self.config.no_dark_mode:
                self.driver.switch_to.window(self.driver.window_handles[-1])
                self.driver.close()
                self.driver.switch_to.window(self.driver.window_handles[0])

    def get_kdbx(self):
        if self.kdbx:
            return self.kdbx
        print("Open KDBX")
        # Open file
        chemin_fichier_kdbx = self.config_file.get_config_value(
            ["kdbx", "path"]
        )
        if not chemin_fichier_kdbx:
            root = tk.Tk()
            root.withdraw()  # Hide the main window
            chemin_fichier_kdbx = filedialog.askopenfilename(
                title="Select a File",
                filetypes=(("KeepassX files", "*.kdbx"),),
            )
        if not chemin_fichier_kdbx:
            # _logger.error(f"KDBX is not configured, please fill {CONFIG_FILE}")
            return

        mot_de_passe_kdbx = self.config_file.get_config_value(
            ["kdbx", "password"]
        )
        if not mot_de_passe_kdbx:
            mot_de_passe_kdbx = getpass.getpass(
                prompt="Entrez votre mot de passe : "
            )

        kp = PyKeePass(chemin_fichier_kdbx, password=mot_de_passe_kdbx)

        if kp:
            self.kdbx = kp
        return kp

    @staticmethod
    def get_french_word_no_space_no_accent():
        word = ""
        rw = RandomWordFr()
        while not word or " " in word:
            word = rw.get().get("word")
            if not re.match("^[a-zA-Z_]+$", word):
                word = ""
        return word

    def click(self, xpath, timeout=None):
        if timeout is None:
            timeout = self.defaut_timeout
        wait = WebDriverWait(self.driver, timeout)
        button = wait.until(
            EC.element_to_be_clickable(
                (
                    By.XPATH,
                    xpath,
                )
            )
        )
        button.click()
        return button

    def get_elements(self, by: str = By.ID, value: str = None, timeout=None):
        if timeout is None:
            timeout = self.defaut_timeout
        wait = WebDriverWait(self.driver, timeout)
        elements = wait.until(
            EC.visibility_of_any_elements_located(
                (
                    by,
                    value,
                )
            )
        )
        return elements

    def get_element(
        self,
        by: str = By.ID,
        value: str = None,
        timeout=None,
        wait_clickable=False,
        wait_is_invisible=False,
        is_visible=True,
    ):
        if timeout is None:
            timeout = self.defaut_timeout
        only_one = False
        wait = WebDriverWait(self.driver, timeout)
        if wait_clickable:
            ele = wait.until(
                EC.element_to_be_clickable(
                    (
                        by,
                        value,
                    )
                )
            )
            only_one = True
        elif is_visible:
            ele = wait.until(
                EC.visibility_of_any_elements_located(
                    (
                        by,
                        value,
                    )
                )
            )
        elif wait_is_invisible:
            ele = wait.until(
                EC.invisibility_of_element_located(
                    (
                        by,
                        value,
                    )
                )
            )
        else:
            only_one = True
            ele = wait.until(
                EC.presence_of_element_located(
                    (
                        by,
                        value,
                    )
                )
            )
        if only_one:
            return ele
        return ele[0]

    def get_element_not_visible(
        self, by: str = By.ID, value: str = None, timeout=None
    ):
        if timeout is None:
            timeout = self.defaut_timeout
        wait = WebDriverWait(self.driver, timeout)
        ele = wait.until(
            EC.presence_of_element_located(
                (
                    by,
                    value,
                )
            )
        )

        return ele

    def get_elements_not_visible(
        self, by: str = By.ID, value: str = None, timeout=None
    ):
        if timeout is None:
            timeout = self.defaut_timeout
        wait = WebDriverWait(self.driver, timeout)
        ele = wait.until(
            EC.presence_of_all_elements_located(
                (
                    by,
                    value,
                )
            )
        )

        return ele

    def get_text_from_element(
        self, by: str = By.ID, value: str = None, timeout: int = None
    ):
        if timeout is None:
            timeout = self.defaut_timeout
        ele = self.get_element(by, value, timeout=timeout)
        return ele.text

    def get_all_element(
        self, by: str = By.ID, value: str = None, timeout=None
    ):
        if timeout is None:
            timeout = self.defaut_timeout
        wait = WebDriverWait(self.driver, timeout)
        ele = wait.until(
            EC.visibility_of_all_elements_located(
                (
                    by,
                    value,
                )
            )
        )

        return ele

    def wait_new_element_and_click(
        self,
        by: str = By.ID,
        value: str = None,
        delay_wait=1,
        timeout=None,
        inject_cursor=False,
    ):
        if timeout is None:
            timeout = self.defaut_timeout
        new_element = self.wait_new_element(
            by=by, value=value, delay_wait=delay_wait, timeout=timeout
        )
        if new_element:
            if inject_cursor:
                self.inject_cursor()
            self.click_with_mouse_move(element=new_element, no_scroll=True)
        return new_element

    def wait_new_element(
        self,
        by: str = By.ID,
        value: str = None,
        delay_wait=1,
        timeout=None,
        timeout_wait=None,
    ):
        if timeout is None:
            timeout = self.defaut_timeout
        element = None
        # TODO support timeout_wait
        while element is None:
            time.sleep(delay_wait)
            try:
                element = self.get_element(by, value, timeout)
            except TimeoutException as e:
                pass
            print(f"Waiting {delay_wait} seconds after value '{value}'")
        return element

    def wait_add_new_element_and_click(
        self,
        by: str = By.ID,
        value: str = None,
        delay_wait=1,
        timeout=None,
    ):
        if timeout is None:
            timeout = self.defaut_timeout
        new_element = self.wait_add_new_element(
            by=by, value=value, delay_wait=delay_wait, timeout=timeout
        )
        self.click_with_mouse_move(element=new_element, no_scroll=True)
        return new_element

    def wait_add_new_element(
        self,
        by: str = By.ID,
        value: str = None,
        delay_wait=1,
        timeout=None,
    ):
        if timeout is None:
            timeout = self.defaut_timeout
        all_element_init = self.get_all_element(by=by, value=value)
        len_all_element_init = len(all_element_init)
        len_all_element = len_all_element_init
        all_element = []
        while len_all_element_init == len_all_element:
            time.sleep(delay_wait)
            all_element = self.get_all_element(by=by, value=value)
            len_all_element = len(all_element)
            print(f"Waiting {delay_wait} seconds after value '{value}'")
        new_element = all_element[-1]
        return new_element

    def wait_increment_number_text_and_click(
        self,
        by: str = By.ID,
        value: str = None,
        delay_wait=1,
        timeout=None,
    ):
        if timeout is None:
            timeout = self.defaut_timeout
        element_init = self.get_element(by=by, value=value, timeout=timeout)
        actual_number = int(element_init.text)
        number_goal = actual_number + 1
        while actual_number < number_goal:
            time.sleep(delay_wait)
            element_goal = self.get_element(
                by=by, value=value, timeout=timeout
            )
            actual_number = int(element_goal.text)
            print(f"Waiting {delay_wait} seconds after value '{value}'")
        self.click_with_mouse_move(element=element_init, no_scroll=True)
        return element_init

    def click_with_mouse_move(
        self,
        by: str = By.ID,
        value: str = None,
        timeout: int = None,
        no_scroll: bool = False,
        viewport_ele_by: str = By.ID,
        viewport_ele_value: str = None,
        element: WebElement = None,
        with_index: bool = False,
        is_visible=True,
        index_of_list: int = 0,
        support_multiple_click: bool = False,
    ):
        if timeout is None:
            timeout = self.defaut_timeout
        # Exemple Detect button by text value
        # Replace CLASS_NAME
        # By.CSS_SELECTOR, "input.CLASS_NAME[value='Fermer']"

        # ele = self.driver.find_element(by, value)
        if element:
            ele = element
        else:
            if support_multiple_click:
                ele = self.get_elements(by, value, timeout)
            else:
                ele = self.get_element(
                    by, value, timeout, is_visible=is_visible
                )
        if not no_scroll:
            viewport_ele = None
            if viewport_ele_value:
                viewport_ele = self.get_element(
                    viewport_ele_by, viewport_ele_value, timeout
                )
            if support_multiple_click:
                for one_ele in ele:
                    self.scrollto_element(one_ele, viewport_ele=viewport_ele)
                    # ActionChains(self.driver).move_to_element(one_ele).click().perform()
                    ActionChains(self.driver).move_to_element(
                        one_ele
                    ).perform()
            else:
                self.scrollto_element(ele, viewport_ele=viewport_ele)
                # ActionChains(self.driver).move_to_element(ele).click().perform()
                ActionChains(self.driver).move_to_element(ele).perform()
        time.sleep(self.config.selenium_default_delay)
        wait = WebDriverWait(self.driver, timeout)
        if element:
            button = wait.until(EC.element_to_be_clickable(element))
        else:
            if with_index:
                buttons = wait.until(
                    EC.presence_of_all_elements_located(
                        (
                            by,
                            value,
                        )
                    )
                )
                button = buttons[index_of_list]
            else:
                if support_multiple_click:
                    button = wait.until(
                        # EC.visibility_of_all_elements_located(
                        EC.presence_of_all_elements_located(
                            (
                                by,
                                value,
                            )
                        )
                    )
                else:
                    button = wait.until(
                        EC.element_to_be_clickable(
                            (
                                by,
                                value,
                            )
                        )
                    )

        try:
            if support_multiple_click:
                for btn in button:
                    try:
                        btn.click()
                        # This button work!
                        return btn
                    except Exception as e:
                        pass
            else:
                button.click()
        except ElementClickInterceptedException as e:
            try:
                print(e)
                if support_multiple_click:
                    for btn in button:
                        self.driver.execute_script(
                            "arguments[0].scrollIntoView(true);", btn
                        )
                        btn.click()
                else:
                    self.driver.execute_script(
                        "arguments[0].scrollIntoView(true);", button
                    )
                    button.click()
            except ElementClickInterceptedException as e:
                print(e)
                if support_multiple_click:
                    for btn in button:
                        self.driver.execute_script(
                            "arguments[0].click();", btn
                        )
                else:
                    self.driver.execute_script("arguments[0].click();", button)
        return button

    def click_canvas_form(
        self,
        by: str = By.ID,
        value: str = None,
        timeout: int = None,
        form="carre",
    ):
        if timeout is None:
            timeout = self.defaut_timeout
        # ele = self.driver.find_element(by, value)
        ele = self.get_element(by, value, timeout)
        actions = ActionChains(self.driver)
        actions.move_to_element_with_offset(ele, -50, -50)
        actions.click_and_hold()
        if form == "carre":
            actions.move_by_offset(50, 0)
            actions.move_by_offset(0, 50)
            actions.move_by_offset(-50, 0)
            actions.move_by_offset(0, -50)

        actions.release()
        actions.perform()

    def input_text_with_mouse_move(
        self,
        by: str = By.ID,
        value: str = None,
        text_value: str = "",
        delay_after: int = -1,
        timeout: int = None,
        no_scroll: bool = False,
        viewport_ele_by: str = By.ID,
        viewport_ele_value: str = None,
        clear_before: bool = False,
        click_before: bool = False,
    ):
        if timeout is None:
            timeout = self.defaut_timeout
        # ele = self.driver.find_element(by, value)
        ele = self.get_element(by, value)
        if not no_scroll:
            viewport_ele = None
            if viewport_ele_value:
                viewport_ele = self.get_element(
                    viewport_ele_by, viewport_ele_value, timeout
                )
            self.scrollto_element(ele, viewport_ele=viewport_ele)
            ActionChains(self.driver).move_to_element(ele).perform()

        # Write content
        if click_before:
            # Need this to update a datetimepicker
            ele.click()
            time.sleep(0.3)
        if clear_before:
            ele.clear()
            if click_before:
                # Need this to update a datetimepicker
                ele.click()
                time.sleep(0.3)
        ele.send_keys(text_value)
        if delay_after > 0:
            time.sleep(delay_after)
        elif self.config.selenium_default_delay > 0:
            time.sleep(self.config.selenium_default_delay)

    def scrollto_element1(self, element_name):
        # ele = self.driver.find_element(By.TAG_NAME, element_name)
        ele = self.get_element(By.TAG_NAME, element_name)
        # delta_y = ele.rect["y"]
        ActionChains(self.driver).scroll_to_element(ele).perform()
        # ele = self.get_element(By.TAG_NAME, element_name)
        # delta_y = ele.rect["y"]
        # ActionChains(self.driver).scroll_by_amount(0, delta_y).perform()
        time.sleep(0.5)

    def scrollto_xpath5(self, xpath):
        footer = self.driver.find_element(By.XPATH, xpath)
        # footer = self.get_element(By.XPATH, xpath)
        delta_y = footer.rect["y"]
        ActionChains(self.driver).scroll_by_amount(0, int(delta_y)).perform()
        time.sleep(0.5)

    def scrollto_xpath2(self, xpath):
        footer = self.driver.find_element(By.XPATH, xpath)
        # footer = self.get_element(By.XPATH, xpath)
        scroll_origin = ScrollOrigin.from_element(footer)
        ActionChains(self.driver).scroll_from_origin(
            scroll_origin, 0, 100
        ).perform()
        time.sleep(0.5)

    def scrollto_xpath3(self, xpath):
        footer = self.driver.find_element(By.XPATH, xpath)
        # footer = self.get_element(By.XPATH, xpath)
        scroll_origin = ScrollOrigin.from_element(footer)
        ActionChains(self.driver).scroll_to_element(scroll_origin).perform()
        time.sleep(0.5)

    def scrollto_xpath(
        self,
        xpath,
        offset_middle=True,
        smooth_scroll=True,
        smooth_speed=50,
        smooth_fps=1 / 25,
    ):
        footer = self.driver.find_element(By.XPATH, xpath)
        # footer = self.get_element(By.XPATH, xpath)
        scroll_origin = ScrollOrigin.from_viewport(10, 10)
        delta_y = footer.rect["y"]
        if offset_middle:
            # TODO check size windows and divide by 2
            delta_y -= 400
        print(f"scroll to xpath at y:{delta_y} position")
        if smooth_scroll:
            actual_pos = 0
            while delta_y > actual_pos:
                actual_pos += smooth_speed
                print(actual_pos)
                ActionChains(self.driver).scroll_from_origin(
                    scroll_origin, 0, int(smooth_speed)
                ).perform()
                print(f"Wait {smooth_fps} seconds")
                time.sleep(smooth_fps)
            print("end")
        else:
            ActionChains(self.driver).scroll_from_origin(
                scroll_origin, 0, int(delta_y)
            ).perform()

        time.sleep(0.5)

    def scrollto_element(
        self,
        element,
        smooth_scroll=True,
        smooth_speed=50,
        smooth_fps=1 / 25,
        viewport_ele=None,
    ):
        window_y = self.driver.execute_script(
            "return window.scrollY || window.pageYOffset;"
        )
        window_height = self.driver.get_window_size().get("height")
        element_height = element.rect["height"]
        viewport_height = self.driver.execute_script(
            "return window.innerHeight || document.documentElement.clientHeight;"
        )
        if viewport_ele:
            scroll_origin = ScrollOrigin.from_element(viewport_ele, 10, 10)
        else:
            scroll_origin = ScrollOrigin.from_viewport(10, 10)
        delta_y = element.rect["y"]
        target_distance = (
            delta_y - (viewport_height - element_height) / 2 - window_y
        )
        if window_y < delta_y < window_y + viewport_height - 50:
            # No need to scroll
            return
        print(f"scroll to xpath at y:{delta_y} position")
        if smooth_scroll:
            actual_pos = 0
            # Detect go top or bot
            if delta_y > window_y:
                step = abs(int(smooth_speed))  # to the top
                condition = lambda a, d: a < d
                go_down = True
            else:
                step = -abs(int(smooth_speed))  # to the bot
                condition = lambda a, d: a > d
                go_down = False
            while condition(actual_pos, target_distance):
                # TODO detect when cannot scroll, stop scrolling
                actual_pos += step
                if go_down and actual_pos > target_distance:
                    step = actual_pos - target_distance
                elif not go_down and actual_pos < target_distance:
                    step = actual_pos - target_distance

                ActionChains(self.driver).scroll_from_origin(
                    scroll_origin, 0, int(step)
                ).perform()
                print(f"Wait {smooth_fps} seconds")
                time.sleep(smooth_fps)
            print("end")
        else:
            ActionChains(self.driver).scroll_from_origin(
                scroll_origin, 0, int(target_distance)
            ).perform()

        # action = ActionChains(self.driver)
        # action.click_and_hold(element).move_by_offset(0, 1).perform()
        # # Don't forget to release the click_and_hold, for example with:
        # action.reset_actions()
        time.sleep(0.5)

    def inject_cursor(self):
        cursor_script = """
        var cursor = document.createElement('div');
        cursor.style.position = 'absolute';
        cursor.style.zIndex = '9999';
        cursor.style.width = '30px';
        cursor.style.height = '30px';
        cursor.style.borderRadius = '50%';
        cursor.style.backgroundColor = 'red';
        cursor.style.pointerEvents = 'none';
        document.body.appendChild(cursor);

        document.addEventListener('mousemove', function(e) {
          cursor.style.left = e.pageX - 5 + 'px';
          cursor.style.top = e.pageY - 5 + 'px';
        });
        """
        try:
            try:
                self.driver.execute_script(cursor_script)
            except Exception as e:
                time.sleep(1)
                print("Error execute script cursor, wait 1 second")
                self.driver.execute_script(cursor_script)
        except Exception as e:
            time.sleep(3)
            print("Error execute script cursor, wait 3 second")
            self.driver.execute_script(cursor_script)

    def scenario_create_new_account_with_random_user(
        self, show_cursor=False, def_action_before_submit=None
    ):
        # Click no account
        if show_cursor:
            self.inject_cursor()
        self.click_with_mouse_move(
            By.XPATH, "/html/body/div[1]/main/div/form/div[3]/div[1]/a[1]"
        )

        # Trouvez les éléments du formulaire
        if show_cursor:
            self.inject_cursor()

        # Remplissez le courriel et le mot de passe
        first_name = self.get_french_word_no_space_no_accent()
        password = first_name.lower()
        second_name = self.get_french_word_no_space_no_accent()
        full_name = f"{first_name} {second_name}"
        domain = self.get_french_word_no_space_no_accent().lower()

        self.input_text_with_mouse_move(
            By.NAME, "login", f"{password}@{domain}.com"
        )
        self.input_text_with_mouse_move(By.NAME, "name", full_name)
        self.input_text_with_mouse_move(By.NAME, "password", password)
        self.input_text_with_mouse_move(By.NAME, "confirm_password", password)
        if def_action_before_submit:
            def_action_before_submit()
        self.click_with_mouse_move(
            By.XPATH, "/html/body/div[1]/main/div/form/div[6]/button"
        )

    def open_tab(self, url):
        # Open a new window
        self.driver.execute_script("window.open('');")
        # Switch to the new window and open new URL
        self.driver.switch_to.window(self.driver.window_handles[1])
        self.driver.get(url)

    def switch_tab(self, index):
        # Switch to the new window and open new URL
        self.driver.switch_to.window(self.driver.window_handles[index])

    def refresh(self, wait_ready=False):
        self.driver.refresh()
        if wait_ready:
            WebDriverWait(self.driver, 15).until(
                lambda d: d.execute_script("return document.readyState")
                == "complete"
            )

    def check_bot_chat_and_close(self):
        try:
            xpath_button = "/html/body/div[3]/div[1]/span[2]/a[2]"
            button = self.driver.find_element(By.XPATH, xpath_button)
            # button = self.get_element(By.XPATH, xpath_button)
            self.click(self.driver, xpath_button)
        except Exception:
            print("Chatbot cannot be found, stop searching it.")

    # Website
    def odoo_show_robot_message(
        self, msg="Ho no!", hide_message_after_x_seconds=0, robot_base64=None
    ):
        # Injecter l'animation SVG dans la page
        script_text = ""
        if msg:
            msg_to_print = msg.replace("'", "\\'")
            lst_mst_to_print = msg_to_print.split("\n")
            script_text = ""
            for index, line in enumerate(lst_mst_to_print):
                script_text += f"""
                    // Ajouter le texte
                    const textElement_{index} = document.createElement('div');
                    textElement_{index}.textContent = '{line}';
                    textElement_{index}.style.color = '#FFFFFF';
                    textElement_{index}.style.fontSize = '24px';
                    textElement_{index}.style.marginBottom = '20px';
                    textElement_{index}.style.fontWeight = 'bold';

                    overlay.appendChild(textElement_{index});
                """
        if robot_base64:
            script_robot = ""
            script_add_robot = f"""
            const img = new Image();
            img.alt = 'Robot';
            img.className = 'cute-robot';
            img.style.width = '150px';
            img.style.cursor = 'pointer';

            img.src = '{robot_base64}';
            overlay.appendChild(img);
"""
        else:
            script_robot = """
                // Contenu SVG du robot
                const svgContent = `
                    <svg class="cute-robot" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 150" style="width: 150px; cursor: pointer;">
                        <!-- Corps du robot -->
                        <rect x="25" y="50" width="50" height="70" rx="10" ry="10" fill="#4CAF50"/>

                        <!-- Tête du robot -->
                        <circle cx="50" cy="30" r="20" fill="#4CAF50"/>

                        <!-- Yeux du robot -->
                        <circle cx="42" cy="25" r="3" fill="#FFFFFF"/>
                        <circle cx="58" cy="25" r="3" fill="#FFFFFF"/>

                        <!-- Bouche du robot -->
                        <path d="M44 38 Q 50 42 56 38" stroke="#FFFFFF" stroke-width="2" fill="transparent"/>

                        <!-- Bras du robot -->
                        <rect x="15" y="60" width="15" height="50" rx="5" ry="5" fill="#388E3C"/>
                        <rect x="70" y="60" width="15" height="50" rx="5" ry="5" fill="#388E3C"/>

                        <!-- Jambes du robot -->
                        <rect x="35" y="120" width="15" height="30" rx="5" ry="5" fill="#388E3C"/>
                        <rect x="50" y="120" width="15" height="30" rx="5" ry="5" fill="#388E3C"/>
                    </svg>
                `;
"""
            script_add_robot = """
            // Ajouter le contenu SVG au div
            overlay.innerHTML += svgContent;
            """
        script = (
            """
            (function() {
                // Créer un div pour l'overlay
                const overlay = document.createElement('div');
                overlay.id = 'uniqueOverlay'; // Ajout de l'ID
                overlay.style.position = 'fixed';
                overlay.style.top = '0';
                overlay.style.left = '0';
                overlay.style.width = '100%';
                overlay.style.height = '100%';
                overlay.style.backgroundColor = 'rgba(0, 0, 0, 0.7)';
                overlay.style.display = 'flex';
                overlay.style.justifyContent = 'center';
                overlay.style.alignItems = 'center';
                overlay.style.zIndex = '9999';
                """
            + script_robot
            + script_text
            + script_add_robot
            + """

                // Ajouter un gestionnaire de clic pour supprimer l'overlay
                overlay.onclick = function() {
                    overlay.style.display = 'none';
                };

                // Ajouter l'overlay au corps du document
                document.body.appendChild(overlay);
            })();
        """
        )

        # Exécuter le script pour injecter l'animation
        self.driver.execute_script(script)
        if hide_message_after_x_seconds:
            time.sleep(hide_message_after_x_seconds)
            delete_script = """(function() {
    // Sélectionner l'overlay par ses attributs de style uniques
    const overlay = document.getElementById('uniqueOverlay');

    // Vérifier si l'overlay existe et le supprimer
    if (overlay) {
        overlay.remove();
    }
})();"""
            self.driver.execute_script(delete_script)
        print(f"Script inject robot svg with msg '{msg}'")

    def odoo_website_menu_click(self, from_text=""):
        if not from_text:
            raise Exception(
                "Cannot click, empty parameter from method"
                " odoo_website_menu_click"
            )
        button = self.click_with_mouse_move(
            By.LINK_TEXT, from_text, timeout=self.defaut_timeout
        )
        return button

    # Web
    def odoo_fill_widget_char(self, field_name, text):
        # Type input
        text_field = WebDriverWait(self.driver, 10).until(
            EC.presence_of_element_located((By.NAME, field_name))
        )
        text_field.send_keys(text)
        return text_field

    def odoo_web_click_principal_menu(self):
        # Click menu button
        if self.odoo_version in ["16.0", "17.0", "18.0"]:
            button = self.click_with_mouse_move(
                By.XPATH,
                "//button[contains(@class, 'dropdown-toggle') and"
                " .//i[contains(@class, 'oi-apps')]]",
            )
        elif self.odoo_version == "14.0":
            button = self.click_with_mouse_move(
                By.CSS_SELECTOR, "a.full[data-toggle='dropdown']"
            )
        return button

    def odoo_web_click_item_list(self, index=0, field_name="name"):
        # Click item list
        all_row = self.get_all_element(
            by=By.XPATH,
            value=f"//tr[contains(@class, 'o_data_row')]/td[contains(@name, '{field_name}')]",
        )
        row = all_row[index] if index < len(all_row) else all_row[-1]
        button = self.click_with_mouse_move(element=row)
        return button

    def odoo_web_click_open_search(self):
        # Click search button
        button = self.click_with_mouse_move(
            By.XPATH,
            "//button[contains(@class, 'o_searchview_dropdown_toggler')]",
        )
        return button

    def odoo_web_click_open_search_add_group_custom(self, group_name):
        # Add personalize group
        button = self.click_with_mouse_move(
            By.XPATH,
            value="//select[contains(@class, 'o_add_custom_group_menu')]",
        )
        if self.wait_human_time:
            time.sleep(1)
        select_elem = self.get_element(
            By.XPATH,
            value="//select[contains(@class, 'o_add_custom_group_menu')]",
            wait_clickable=False,
        )

        select_obj = Select(select_elem)
        # (ex: <option value="customer">Client</option>)
        select_obj.select_by_value(group_name)
        return select_elem

    def odoo_web_click_open_search_filter(
        self,
        filter_label=None,
        filter_sub_label=None,
        lst_update_condition=None,
    ):
        if not lst_update_condition:
            lst_update_condition = []
        if filter_label:
            button = self.click_with_mouse_move(
                By.XPATH,
                value=f"//button[contains(@class,'o_menu_item') and contains(normalize-space(.), '{filter_label}')]",
            )
        if filter_sub_label:
            button = self.click_with_mouse_move(
                By.XPATH,
                value=f"//span[contains(@class,'o_item_option') and contains(normalize-space(.), '{filter_sub_label}')]",
            )
        if lst_update_condition:
            filter_text = f"{filter_label}: {filter_sub_label}"
            button = self.click_with_mouse_move(
                By.XPATH,
                value=f"//small[contains(@class,'o_facet_value') and contains(normalize-space(.), '{filter_text}')]/../..//i[contains(@class,'fa-cog')]",
                is_visible=False,
            )
            time.sleep(1)
            for item_update_condition in lst_update_condition:
                condition_value = item_update_condition.get("condition")
                if condition_value:
                    select_elem = self.click_with_mouse_move(
                        By.XPATH,
                        value=f"//div[contains(@class,'modal-content')]//select[contains(@class,'pe-3')]",
                        is_visible=False,
                    )
                    select_obj = Select(select_elem)
                    # (ex: <option value="customer">Client</option>)
                    select_obj.select_by_value(condition_value)
                else:
                    _logger.error(
                        f"Not supported item_update_condition '{item_update_condition}'"
                    )
            # Save
            button = self.click_with_mouse_move(
                By.XPATH,
                value=f"//footer[contains(@class,'modal-footer')]//button[contains(@class,'btn-primary') and contains(normalize-space(.), 'Confirmer')]",
            )

    def odoo_fill_search_input(self, text, selection_research=None):
        input_elem = self.click_with_mouse_move(
            By.XPATH,
            value="//input[contains(@class, 'o_searchview_input')]",
        )
        input_elem.send_keys(text)
        time.sleep(1)
        if not selection_research:
            input_elem.send_keys(Keys.ENTER)
        else:
            input_autocomplete_elem = self.click_with_mouse_move(
                By.XPATH,
                value="//ul[contains(@class,'o_searchview_autocomplete')]"
                f"//li[contains(@class,'o_menu_item') and .//b[normalize-space(.)='{selection_research}']]"
                "//a[not(contains(@class,'o_expand'))]",
            )

        return input_elem

    def odoo_web_principal_menu_click_root_menu(self, from_text=""):
        if not from_text:
            raise Exception(
                "Cannot click, empty parameter from method"
                " odoo_web_principal_menu_click_root_menu"
            )
        button = self.click_with_mouse_move(By.LINK_TEXT, from_text)
        # If not work, force it
        # selenium_tool.driver.execute_script("arguments[0].click();", button)
        return button

    def odoo_web_form_click_statusbar_button_status(
        self, status_label, timeout=None
    ):
        if timeout is None:
            timeout = self.defaut_timeout
        try:
            status_button = self.click_with_mouse_move(
                By.XPATH,
                "//button[contains(@class, 'o_arrow_button') and"
                f" contains(text(), '{status_label}')]",
                timeout=timeout,
            )
        except Exception as e:
            status_button = self.click_with_mouse_move(
                By.XPATH,
                "//button[contains(@class, 'o_arrow_button') and"
                f" text()='{status_label}']",
                timeout=timeout,
            )
        print(f"Bouton du statusbar avec le label '{status_label}' cliqué.")
        return status_button

    def odoo_profile_click(self, enable_dark_mode=False, enable_tour=False):

        def toggle_data_menu(key, enable):
            profile_button = self.click_with_mouse_move(
                By.XPATH,
                "//div[contains(@class, 'o_user_menu')]/button[contains(@class, 'py-1')]",
            )
            element = self.get_element(
                By.XPATH,
                f"//div[contains(@class, 'o_popover')]//span[@data-menu=\"{key}\"]//input",
            )
            if element.is_selected() != enable:
                self.click_with_mouse_move(
                    By.XPATH,
                    f"//div[contains(@class, 'o_popover')]//span[@data-menu=\"{key}\"]//input",
                )
            else:
                # close it
                self.click_with_mouse_move(
                    By.XPATH,
                    "//div[contains(@class, 'o_user_menu')]/button[contains(@class, 'py-1')]",
                )

        toggle_data_menu("web_tour.tour_enabled", enable_tour)
        toggle_data_menu("color_scheme.switch", enable_dark_mode)

    def odoo_web_form_click_statusbar_button_status_floating(
        self, status_label, timeout=None
    ):
        if timeout is None:
            timeout = self.defaut_timeout
        status_button = self.click_with_mouse_move(
            By.XPATH,
            "//span[contains(@class, 'o_arrow_button') and contains(text(),"
            f" '{status_label}')]",
            timeout=timeout,
        )
        print(f"Bouton du statusbar avec le label '{status_label}' cliqué.")
        return status_button

    def odoo_web_form_click_statusbar_button_status_plus(
        self, status_label, timeout=None
    ):
        if timeout is None:
            timeout = self.defaut_timeout
        status_button = self.click_with_mouse_move(
            By.XPATH,
            "//button[contains(@class, 'o_arrow_button') and"
            f" text()='{status_label}']",
            timeout=timeout,
        )
        print(f"Bouton du statusbar avec le label '{status_label}' cliqué.")
        return status_button

    def odoo_web_form_click_button_statusbar(
        self, btn_label, btn_class="btn-primary"
    ):
        status_button = self.click_with_mouse_move(
            By.XPATH,
            f"//button[contains(@class, '{btn_class}') and contains(span,"
            f" '{btn_label}')]",
        )
        print(f"Bouton du statusbar avec le label '{btn_label}' cliqué.")
        return status_button

    def odoo_web_form_click_button_action(self, btn_action):
        status_button = self.click_with_mouse_move(
            By.NAME,
            btn_action,
        )
        print(f"Bouton avec l'action '{btn_action}' cliqué.")
        return status_button

    def odoo_web_form_click_save_action(self):
        return self.odoo_web_form_click_by_classname_action(
            "o_form_button_save"
        )

    def odoo_web_change_view(self, view_name="list", raise_error=False):
        if view_name not in ["list", "kanban", "timeline"]:
            msg = f"odoo_web_change_view view_name '{view_name}' invalid"
            if raise_error:
                raise Exception(msg)
            _logger.error(msg)
            return None

        status_button = self.click_with_mouse_move(
            by=By.XPATH,
            value=f"//nav[contains(@class, 'o_cp_switch_buttons')]/button[contains(@class, 'o_{view_name}')]",
        )
        print(f"Change view '{view_name}' cliqué.")
        return status_button

    def odoo_web_form_click_web_publish_action(self):
        return self.odoo_web_form_click_button_action("website_publish_button")

    def odoo_web_form_click_by_classname_action(self, custom_class_name):
        status_button = self.click_with_mouse_move(
            By.CLASS_NAME,
            custom_class_name,
        )
        print(f"Bouton avec l'action '{custom_class_name}' cliqué.")
        return status_button

    def odoo_web_kanban_card(self, card_label):
        # From web view kanban, list
        kanban_card = self.click_with_mouse_move(
            By.XPATH,
            "//div[contains(@class,"
            f" 'o_kanban_record')]//span[contains(text(), '{card_label}')]",
        )
        # kanban_card = self.driver.find_element(By.XPATH,
        #                                        f"//div[contains(@class, 'o_kanban_record')]//span[contains(text(), '{card_label}')]")
        # kanban_card.click()
        print(f"Carte Kanban avec le label '{card_label}' cliquée.")
        return kanban_card

    def odoo_web_action_button_new(self):
        # From web view kanban, list
        return self.click_with_mouse_move(By.CLASS_NAME, "o-kanban-button-new")

    def odoo_web_kanban_click(self, button_text, btn_class="btn-primary"):
        # From web view kanban, list
        return self.click_with_mouse_move(
            By.XPATH,
            f"//button[contains(@class, 'btn {btn_class} o_kanban_edit') and"
            f" text()='{button_text}']",
        )

    def odoo_web_form_notebook_tab_click(self, tab_text):
        return self.click_with_mouse_move(
            By.XPATH,
            f"//a[text()='{tab_text}']",
        )

    # Web
    def odoo_fill_widget_char(self, field_name, text, is_label=False):
        # Type input
        if self.odoo_version == "14.0":
            text_field = WebDriverWait(self.driver, 10).until(
                EC.presence_of_element_located((By.NAME, field_name))
            )
        elif self.odoo_version == "16.0":
            text_field = WebDriverWait(self.driver, 10).until(
                EC.presence_of_element_located((By.ID, field_name))
            )

        text_field.send_keys(text)
        return text_field

    def odoo_fill_widget_selection(self, field_name, text):
        return self.odoo_fill_widget_many2one(field_name, text)

    def odoo_fill_widget_boolean(self, field_name, value):
        self.driver.implicitly_wait(10)
        checkbox_div = self.driver.find_element(
            By.XPATH, f"//div[@name='{field_name}']"
        )
        checkbox = checkbox_div.find_element(
            By.CSS_SELECTOR, 'input[type="checkbox"]'
        )
        is_selected = checkbox.get_attribute("selected")
        # Check if already set
        if is_selected == "true" and value:
            return checkbox
        elif is_selected is None and not value:
            return checkbox
        parent_element = checkbox.find_element(By.XPATH, "..")
        parent_element.click()
        return checkbox

    def odoo_fill_widget_many2one(self, field_name, text):
        # TODO read this file odoo/addons/web/static/src/js/fields/field_registry.js
        div_field = WebDriverWait(self.driver, 10).until(
            EC.presence_of_element_located((By.NAME, field_name))
        )

        input_field = div_field.find_element(By.XPATH, ".//input")
        input_field.send_keys(text)
        # TODO improve speed by observation of comportement
        time.sleep(1)
        input_field.send_keys(Keys.ENTER)

        return input_field

    def odoo_fill_widget_date(self, field_name, date_to_select):
        # Type date
        self.driver.implicitly_wait(10)
        checkbox_div = self.driver.find_element(
            By.XPATH, f"//div[@name='{field_name}']"
        )
        checkbox_div.click()
        # TODO improve speed by observation of comportement
        time.sleep(0.5)
        str_date_today = date_to_select.strftime("%Y-%m-%d")
        if self.odoo_version in ["17.0", "18.0"]:
            checkbox_date_div = self.driver.find_element(
                By.CSS_SELECTOR, ".o_datetime_picker"
            )
            new_value = self.select_date(self.driver, date_to_select)
        else:
            checkbox_date_div = self.driver.find_element(
                By.CSS_SELECTOR, ".bootstrap-datetimepicker-widget"
            )
            # time.sleep(0.5)
            new_value = checkbox_date_div.find_element(
                By.XPATH, f"//td[@data-day='{str_date_today}']"
            )
        new_value.click()
        return new_value

    def start_record(self):
        # Démarrer l'enregistrement
        if self.config.record_mode:
            if self.config.record_wait_before_start_time:
                time.sleep(int(self.config.record_wait_before_start_time))
            # Sync before record
            has_sync_error = False
            if self.config.sync_file_record_read:
                if not self.config.sync_file_record_write:
                    print(
                        "Error, cannot sync, missing 'sync_file_record_write'"
                    )
                    has_sync_error = True
            if self.config.sync_file_record_write:
                if not self.config.sync_file_record_read:
                    print(
                        "Error, cannot sync, missing 'sync_file_record_read'"
                    )
                    has_sync_error = True
            if (
                not has_sync_error
                and self.config.sync_file_record_read
                and self.config.sync_file_record_write
            ):
                # Do sync
                file_name_1 = f"/tmp/erplibre_sync_temp_file{self.config.sync_file_record_write}"
                file_name_2 = f"/tmp/erplibre_sync_temp_file{self.config.sync_file_record_read}"
                with open(file_name_1, "w") as file:
                    file.write(f"Recording {self.filename_recording}\n")
                while not os.path.exists(file_name_2):
                    var_wait_time = 0.001
                    print(
                        f"File {self.filename_recording} wait"
                        f" {var_wait_time} seconds"
                    )
                    time.sleep(var_wait_time)
            self.video_recorder.start()

    def quit(self):
        self.driver.quit()

    def stop_record(self):
        time.sleep(self.config.selenium_default_delay_presentation)

        # Arrêter l'enregistrement
        if self.config.record_mode:
            time.sleep(self.config.selenium_video_time_waiting_end)
            self.video_recorder.stop()
            print("End of recording video")
            print(self.filename_recording)

            filename_recording_mp4 = self.filename_recording.replace(
                ".webm", ".mp4"
            )
            if self.config.selenium_video_auto_convert_mp4:
                with_auto_fix = True
                if with_auto_fix:
                    cmd = f'ffmpeg -i {self.filename_recording} -vf "scale=trunc(iw/2)*2:trunc(ih/2)*2" -c:v libx264 -pix_fmt yuv420p -crf 23 -preset veryfast -c:a aac -b:a 160k -movflags +faststart {filename_recording_mp4}'
                else:
                    cmd = f"ffmpeg -i {self.filename_recording} {filename_recording_mp4}"
                print(cmd)
                os.popen(cmd)

            if self.config.selenium_video_auto_play_video:
                print(f"Play video {self.filename_recording}")
                # By python-vlc
                # media_player = vlc.MediaPlayer(filename)
                # media = vlc.Media(filename)
                # media_player.set_media(media)
                # media_player.play()
                # time.sleep(15)
                # By external process
                if self.config.selenium_video_auto_convert_mp4:
                    os.popen(f"vlc {filename_recording_mp4}")
                else:
                    os.popen(f"vlc {self.filename_recording}")

    def generer_code_postal_quebec(self):
        # Zip code from quebec canada
        premieres_lettres = ["G", "H", "J"]

        premiere_lettre = random.choice(premieres_lettres)

        deuxieme_lettre = chr(random.randint(65, 90))
        chiffre = str(random.randint(0, 9))
        troisieme_lettre = chr(random.randint(65, 90))

        code_postal = f"{premiere_lettre}{chiffre}{deuxieme_lettre} {chiffre}{troisieme_lettre}{chiffre}"

        return code_postal

    def generer_numero_telephone_quebec(self):
        # Number from quebec canada
        indicateurs_regionaux = [
            "418",
            "438",
            "450",
            "514",
            "579",
            "581",
            "819",
            "873",
        ]

        indicatif = random.choice(indicateurs_regionaux)

        numero = "".join(random.choices("0123456789", k=7))

        numero_telephone = f"({indicatif}) {numero[:3]}-{numero[3:]}"

        return numero_telephone

    def generer_date_naissance(self, age_minimum=16):
        annee_actuelle = datetime.datetime.now().year
        annee_maximale = annee_actuelle - age_minimum

        annee_minimale = 1900

        annee_naissance = random.randint(annee_minimale, annee_maximale)

        mois_naissance = random.randint(1, 12)
        jour_naissance = random.randint(1, 28)

        date_naissance = datetime.datetime(
            annee_naissance, mois_naissance, jour_naissance
        )

        return date_naissance.strftime("%Y-%m-%d")

    def _get_visible_month_year(self, picker):
        header = picker.find_element(
            By.CSS_SELECTOR, ".o_datetime_picker_header .o_header_part"
        )
        text = header.text.strip().lower()  # ex: "octobre 2025"
        parts = text.split()
        # s'il y a des espaces insécables ou formats bizarres
        mois_txt = parts[0].replace("\xa0", " ")
        annee = int(parts[-1])
        mois = MONTHS_FR[mois_txt]
        return (
            mois,
            annee,
            header.text,
        )  # on retourne aussi le texte exact pour attendre le changement

    # def wait_is_invisible(self, by, value):
    #     div_field = WebDriverWait(self.driver, 10).until(
    #         EC.presence_of_element_located((By.NAME, field_name))
    #     )
    #     wait = WebDriverWait(driver, 10)
    #     wait.until(
    #         EC.invisibility_of_element_located((By.ID, "ui-datepicker-div"))
    #     )

    def select_date(self, driver, date_to_select):
        # 1) ouvrir/viser le datepicker (si besoin, clique l'input avant)
        picker = WebDriverWait(driver, 10).until(
            EC.visibility_of_element_located(
                (By.CSS_SELECTOR, ".o_datetime_picker")
            )
        )

        # 2) naviguer au bon mois
        max_hops = 24  # sécurité (2 ans)
        for _ in range(max_hops):
            mois_vis, annee_vis, header_txt = self._get_visible_month_year(
                picker
            )
            if (annee_vis, mois_vis) == (
                date_to_select.year,
                date_to_select.month,
            ):
                break

            # bouton suivant/précédent dans l'entête du picker courant
            if (annee_vis, mois_vis) < (
                date_to_select.year,
                date_to_select.month,
            ):
                btn = picker.find_element(
                    By.CSS_SELECTOR, ".o_datetime_picker_header .o_next"
                )
            else:
                btn = picker.find_element(
                    By.CSS_SELECTOR, ".o_datetime_picker_header .o_previous"
                )

            btn.click()
            # attendre que l'en-tête change pour éviter les doubles clics trop rapides
            WebDriverWait(driver, 10).until(
                EC.text_to_be_present_in_element(
                    (
                        By.CSS_SELECTOR,
                        ".o_datetime_picker_header .o_header_part",
                    ),
                    "",
                )
            )
            WebDriverWait(driver, 10).until(
                lambda d: picker.find_element(
                    By.CSS_SELECTOR, ".o_datetime_picker_header .o_header_part"
                ).text
                != header_txt
            )
        else:
            raise RuntimeError(
                "Impossible d'atteindre le mois voulu dans le délai imparti."
            )

        # 3) cliquer le jour (les jours cliquables sont des <button> avec un <span> = numéro)
        day = str(int(date_to_select.day))  # sans zéro en tête
        day_xpath = f".//button[contains(@class,'o_date_item_cell') and .//span[normalize-space(text())='{day}']]"

        day_btn = WebDriverWait(picker, 10).until(
            EC.element_to_be_clickable((By.XPATH, day_xpath))
        )

        return day_btn

    def extraire_svg_graphique_by_3d(
        self,
        container_id: str = "svgbox627",
    ) -> Optional[str]:
        """
        Récupère le code SVG du graphique D3 tel que rendu dans le DOM.

        Le SVG est généré dynamiquement par D3.js après chargement de la page,
        donc on récupère le HTML *après* exécution, pas la source initiale.

        Returns:
            Le code SVG complet (avec namespace et styles inline) ou None si absent.
        """
        try:
            # Récupérer le <svg> rendu via execute_script (outerHTML inclut les
            # attributs et le contenu généré dynamiquement par D3).
            svg_html = self.driver.execute_script(
                """
                var container = document.getElementById(arguments[0]);
                if (!container) return null;
                var svg = container.querySelector('svg');
                return svg ? svg.outerHTML : null;
            """,
                container_id,
            )

            if not svg_html:
                return None

            return self._svg_autonome(svg_html)
        except Exception:
            return None

    def _svg_autonome(self, svg_html: str) -> str:
        """
        Transforme un fragment SVG en document SVG autonome, viewable hors navigateur.

        - Garantit le namespace xmlns
        - Ajoute la déclaration XML
        - Nettoie les attributs spécifiques à darkreader (extension de navigateur)
        """
        # import re

        # Nettoyer les attributs injectés par l'extension Dark Reader, qui polluent
        # le SVG sans valeur ajoutée et peuvent contenir des --darkreader-* invalides.
        svg_html = re.sub(r'\s*--darkreader-[^;"]*;?', "", svg_html)
        svg_html = re.sub(r'\s*data-darkreader-[^=]*="[^"]*"', "", svg_html)
        svg_html = re.sub(
            r'<style class="darkreader[^"]*"[^>]*>.*?</style>',
            "",
            svg_html,
            flags=re.DOTALL,
        )

        # S'assurer du namespace SVG (D3 le met normalement, mais on vérifie)
        if 'xmlns="http://www.w3.org/2000/svg"' not in svg_html:
            svg_html = svg_html.replace(
                "<svg ",
                '<svg xmlns="http://www.w3.org/2000/svg" ',
                1,
            )

        # Préfixer avec la déclaration XML pour un fichier .svg standalone
        return (
            '<?xml version="1.0" encoding="UTF-8" standalone="no"?>\n'
            + svg_html
        )

    def convertir_svg_en_png_via_selenium(
        self,
        container_id: str,
        chemin_png: str,
    ) -> bool:
        """
        Alternative : capture le SVG via screenshot Selenium, sans cairosvg.
        Avantage : pas de dépendance native.
        Inconvénient : qualité dépend de la résolution du navigateur.
        """

        try:
            svg_element = self.get_element(
                by=By.ID, value=container_id, timeout=5
            )
        except Exception as e:
            return False

        if not svg_element:
            return False

        # Scroller pour s'assurer que le SVG est visible
        self.driver.execute_script(
            "arguments[0].scrollIntoView({block: 'center'});", svg_element
        )

        time.sleep(0.3)
        svg_element.screenshot(chemin_png)

        return True

    def telecharger_svg_graphique(
        self,
        chemin_sortie: str,
        container_id: str = "svgbox627",
    ) -> bool:
        """
        Télécharge le graphique en SVG dans un fichier.

        Args:
            driver: WebDriver positionné sur la page.
            chemin_sortie: chemin du fichier .svg à créer.
            container_id: id du conteneur du graphique (par défaut svgbox627).

        Returns:
            True si le fichier a été écrit, False si le graphique est absent.
        """
        svg = self.extraire_svg_graphique_by_3d(container_id)
        if not svg:
            return False

        os.makedirs(
            os.path.dirname(os.path.abspath(chemin_sortie)) or ".",
            exist_ok=True,
        )
        with open(chemin_sortie, "w", encoding="utf-8") as f:
            f.write(svg)
        return True

    def get_init_list_file_unique(self):
        # init_list_file = set(os.listdir(self.default_download_dir_path))
        if self.config.use_network:
            init_list_file = set(self.driver.get_downloadable_files())
        else:
            if os.path.isdir(self.default_download_dir_path):
                init_list_file = set(
                    os.listdir(self.default_download_dir_path)
                )
            else:
                init_list_file = set()
        return init_list_file

    def download_file_unique(
        self, init_list_file, lst_unique_file, dct_document, filename
    ):
        finish_download = False
        fichiers = []
        # 1 hour max
        new_file_name = ""
        max_time_to_wait = 60 * 60
        i_wait = 0
        while not finish_download:
            if self.config.use_network:
                fichiers = set(
                    self.driver.get_downloadable_files()
                ).difference(init_list_file)
            else:
                fichiers = set(
                    os.listdir(self.default_download_dir_path)
                ).difference(init_list_file)
            diff_list_fichiers = list(fichiers.difference(lst_unique_file))
            if diff_list_fichiers:
                new_file_name = diff_list_fichiers[-1]
                if not new_file_name.endswith(".part"):
                    # finish_download = True
                    break
            i_wait += 1
            if i_wait < max_time_to_wait:
                time.sleep(1)
            else:
                return set()
        lst_unique_file = fichiers
        dct_document[filename] = os.path.join(
            self.default_download_dir_path, new_file_name
        )
        print(len(fichiers))
        print(fichiers)
        print("--")
        print(dct_document)
        if self.config.use_network:
            self.driver.download_file(
                new_file_name, target_directory=self.default_download_dir_path
            )

        return lst_unique_file

    def print_download_file_unique(self, dct_document, detect_error=False):
        dct_output = {"document": dct_document, "has_error": detect_error}
        print()
        print("=DATA=")
        print(json.dumps(dct_output))
        print("=ENDDATA=")
        print()


def get_args(parser):
    args = parser.parse_args()
    if args.use_chrome_driver:
        args.use_firefox_driver = False
    return args


def fill_parser(parser):
    parser.add_argument(
        "--url",
        default="http://127.0.0.1:8069",
        help="First URL to open.",
    )

    group_animation = parser.add_argument_group(title="Animation")
    group_animation.add_argument(
        "--selenium_default_delay",
        default=0.4,
        type=float,
        help="Pause at the end of an action.",
    )

    group_animation.add_argument(
        "--human_time_speed",
        action="store_true",
        help="Will wait after each action to help human to follow",
    )

    group_browser = parser.add_argument_group(title="Browser")
    group_browser.add_argument(
        "--not_private_mode",
        action="store_true",
        help="Default is private mode.",
    )
    group_browser.add_argument(
        "--use_chrome_driver",
        action="store_true",
        help="Switch to chrome instead of great Firefox.",
    )
    group_browser.add_argument(
        "--use_firefox_driver",
        action="store_true",
        default=True,
        help="The default is firefox.",
    )
    group_browser.add_argument(
        "--use_network",
        help="Specify the address, example: http://localhost:4444",
    )
    group_browser.add_argument(
        "--use_download_path_default",
        action="store_true",
        help="Actually, the download path is a temporary directory. "
        "This will enable default path to /home/seluser/Downloads, "
        "need this with Selenium Grid by network. "
        "Will delete all file into /home/seluser/Downloads at startup.",
    )
    group_browser.add_argument(
        "--window_size",
        help="Example 1920,1080",
    )
    group_browser.add_argument(
        "--headless",
        action="store_true",
        help="For automation without GUI.",
    )
    group_browser.add_argument(
        "--no_dark_mode",
        action="store_true",
        help=(
            "By default, will be in dark mode, because the main developer"
            " like it!"
        ),
    )
    group_browser.add_argument(
        "--firefox_binary_path",
        help="Can specify firefox path to open selenium.",
    )
    group_browser.add_argument(
        "--gecko_binary_path",
        help="Can specify firefox path to open selenium.",
    )

    group_record = parser.add_argument_group(title="Recording")
    group_record.add_argument(
        "--record_mode",
        action="store_true",
        help="Start recording (not finish to be implemented).",
    )
    group_record.add_argument(
        "--record_wait_before_start_time",
        help="Time to wait in second before start recording.",
    )
    parser.add_argument(
        "--video_suffix",
        default="",
        help="Will modify video name.",
    )
    parser.add_argument(
        "--sync_file_record_read",
        default="",
        help=(
            "Will sync and check file from tmp before record, write before"
            " read."
        ),
    )
    parser.add_argument(
        "--sync_file_record_write",
        default="",
        help=(
            "Will sync and check file from tmp before record, write before"
            " read."
        ),
    )
    group_record.add_argument(
        "--selenium_video_time_waiting_end",
        default=5,
        type=int,
        help="Pause at the end before close video.",
    )
    group_record.add_argument(
        "--selenium_default_delay_presentation",
        default=2,
        type=float,
        help="Pause at the end before close video.",
    )
    group_record.add_argument(
        "--selenium_video_auto_play_video",
        action="store_true",
        help="Autoplay the video when done.",
    )
    group_record.add_argument(
        "--selenium_video_auto_convert_mp4",
        action="store_true",
        default=True,
        help="Will convert .webm to .mp4 when done.",
    )