BuiltInFunctions.py

# -*- coding: utf-8 -*-
# -*- coding: cp1252 -*-
"""
Created on May 15, 2016

@author: Built_In_Automation Solutionz Inc.
Name: Built In Functions - Selenium
Description: Sequential Actions for controlling Web Browsers - All main Web Browsers supported on Linux/Windows/Mac
"""

#########################
#                       #
#        Modules        #
#                       #
#########################
import platform
import sys, os, time, inspect, shutil, subprocess, json, re
import socket
import requests
import psutil
import pyperclip
import base64, imghdr
from pathlib import Path
from urllib.parse import urlparse

sys.path.append("..")
from selenium import webdriver

if "linux" in platform.system().lower():
    from xvfbwrapper import Xvfb
from webdriver_manager.chrome import ChromeDriverManager
from webdriver_manager.firefox import GeckoDriverManager
from webdriver_manager.microsoft import IEDriverManager
from webdriver_manager.microsoft import EdgeChromiumDriverManager
from webdriver_manager.opera import OperaDriverManager
from selenium.webdriver.remote.webelement import WebElement
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
from selenium.webdriver.firefox.firefox_binary import FirefoxBinary
from selenium.webdriver.support.ui import Select
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.common.action_chains import ActionChains
from selenium.common.exceptions import (
    ElementClickInterceptedException,
    WebDriverException,
    SessionNotCreatedException,
    TimeoutException,
    NoSuchFrameException,
    StaleElementReferenceException,
    TimeoutException,
)
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.by import By
from selenium.webdriver.common.alert import Alert
from selenium.webdriver.support import expected_conditions as EC
import selenium

from bs4 import BeautifulSoup
import xml.etree.ElementTree as ET

from Framework.Utilities import CommonUtil, ConfigModule
from Framework.Built_In_Automation.Shared_Resources import (
    BuiltInFunctionSharedResources as Shared_Resources,
)
from Framework.Utilities.decorators import logger, deprecated
from Framework.Built_In_Automation.Shared_Resources import LocateElement
from Framework.Utilities.CommonUtil import (
    passed_tag_list,
    failed_tag_list,
    skipped_tag_list,
)
from Framework.AI.NLP import binary_classification
from .utils import ChromeForTesting, ChromeExtensionDownloader

#########################
#                       #
#    Global Variables   #
#                       #
#########################

MODULE_NAME = inspect.getmodulename(__file__)

temp_config = os.path.join(
    os.path.join(
        os.path.abspath(__file__).split("Framework")[0],
        os.path.join(
            "AutomationLog", ConfigModule.get_config_value("Advanced Options", "_file")
        ),
    )
)
temp_config = str(
    Path(os.path.abspath(__file__).split("Framework")[0])
    / "AutomationLog"
    / ConfigModule.get_config_value("Advanced Options", "_file")
)
aiplugin_path = str(
    Path(os.path.abspath(__file__).split("Framework")[0]) / "Apps" / "Web" / "aiplugin"
)
ai_recorder_path = str(
    Path(os.path.abspath(__file__).split("Framework")[0])
    / "Apps"
    / "Web"
    / "AI_Recorder_2"
    / "dist"
)
ai_recorder_public_path = str(
    Path(os.path.abspath(__file__).split("Framework")[0])
    / "Apps"
    / "Web"
    / "AI_Recorder_2"
    / "public"
)

# Disable WebdriverManager SSL verification.
os.environ["WDM_SSL_VERIFY"] = "0"

current_driver_id = None
selenium_driver = None
selenium_details = {}
default_x, default_y = 1920, 1080
vdisplay = None
initial_download_folder = None

browser_map = {
    "Microsoft Edge Chromium": "microsoftedge",
    "Chrome": "chrome",
    "FireFox": "firefox",
    "Opera": "opera",
    "ChromeHeadless": "chrome",
    "FirefoxHeadless": "firefox",
    "EdgeChromiumHeadless": "microsoftedge",
    "Safari": "safari",
}
options_map = {
    "Microsoft Edge Chromium": "edge",
    "Chrome": "chrome",
    "FireFox": "firefox",
    "Opera": "opera",
    "ChromeHeadless": "chrome",
    "FirefoxHeadless": "firefox",
    "EdgeChromiumHeadless": "edge",
    "Safari": "safari",
}

from typing import Literal, TypedDict, Any, Union, NotRequired

Dataset = list[tuple[str, str, str]]
ReturnType = Literal["passed", "zeuz_failed"]


class DefaultChromiumArguments(TypedDict):
    add_argument: list[str]
    add_experimental_option: dict[str, Any]
    add_extension: list[str]
    add_encoded_extension: list[str]
    page_load_strategy: NotRequired[Literal["normal", "eager", "none"]]


class FirefoxArguments(TypedDict):
    add_argument: list[str]
    set_preference: dict[str, Any]


class SafariArguments(TypedDict):
    add_argument: list[str]


class BrowserOptions(TypedDict):
    capabilities: dict[str, Any]
    chrome: DefaultChromiumArguments
    edge: DefaultChromiumArguments
    firefox: FirefoxArguments
    safari: SafariArguments


from selenium.webdriver.common.options import ArgOptions

# JavaScript for collecting First Contentful Paint value.
JS_FCP = """
return performance.getEntriesByName("first-contentful-paint")[0].startTime
"""

# JavaScript for collecting Largest Contentful Paint value.
JS_LCP = """
var args = arguments;
const po = new PerformanceObserver(list => {
    const entries = list.getEntries();
    const entry = entries[entries.length - 1];
    // Process entry as the latest LCP candidate
    // LCP is accurate when the renderTime is available.
    // Try to avoid this being false by adding Timing-Allow-Origin headers!
    const accurateLCP = entry.renderTime ? true : false;
    // Use startTime as the LCP timestamp. It will be renderTime if available, or loadTime otherwise.
    const largestPaintTime = entry.startTime;
    // Send the LCP information for processing.

    console.log("[ZeuZ Node] Largest Contentful Paint: ", largestPaintTime);
    args[0](largestPaintTime);
});
po.observe({ type: 'largest-contentful-paint', buffered: true });
"""

# if Shared_Resources.Test_Shared_Variables('selenium_driver'): # Check if driver is already set in shared variables
#    selenium_driver = Shared_Resources.Get_Shared_Variables('selenium_driver') # Retreive appium driver

# Recall dependency, if not already set
dependency = None
if Shared_Resources.Test_Shared_Variables(
    "dependency"
):  # Check if driver is already set in shared variables
    dependency = Shared_Resources.Get_Shared_Variables(
        "dependency"
    )  # Retreive appium driver
else:
    raise ValueError("No dependency set - Cannot run")


@logger
def get_driver():
    return selenium_driver

@logger
def is_headless_environment():
    """
    Detect if the current environment is headless (no display available).
    This includes cloud instances, Docker containers, CI/CD environments, etc.
    
    Returns:
        bool: True if headless environment is detected, False otherwise
    """
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    
    try:
        # Check for common headless environment indicators
        headless_indicators = [
            # Environment variables commonly set in headless environments
            os.getenv('CI') is not None,  # CI/CD environments
            os.getenv('GITHUB_ACTIONS') is not None,  # GitHub Actions
            os.getenv('JENKINS_URL') is not None,  # Jenkins
            os.getenv('BUILDKITE') is not None,  # Buildkite
            os.getenv('TRAVIS') is not None,  # Travis CI
            os.getenv('CIRCLECI') is not None,  # CircleCI
            os.getenv('GITLAB_CI') is not None,  # GitLab CI
            os.getenv('TEAMCITY_VERSION') is not None,  # TeamCity
            os.getenv('TF_BUILD') is not None,  # Azure DevOps
            os.getenv('CODEBUILD_BUILD_ID') is not None,  # AWS CodeBuild
            os.getenv('DOCKER_CONTAINER') is not None,  # Docker container
            os.path.exists('/.dockerenv'),  # Docker container indicator
            os.getenv('KUBERNETES_SERVICE_HOST') is not None,  # Kubernetes
            os.getenv('HEADLESS') == '1',  # Explicit headless flag
            os.getenv('DISPLAY') is None and platform.system() == 'Linux',  # No display on Linux
        ]
        
        # Check if any headless indicator is present
        if any(headless_indicators):
            CommonUtil.ExecLog(sModuleInfo, "Headless environment detected based on environment variables", 1)
            return True
        
        display_vars = ['DISPLAY', 'WAYLAND_DISPLAY', 'XAUTHORITY']
        for var in display_vars:
            if os.environ.get(var) is not None:
                CommonUtil.ExecLog(sModuleInfo, "Headless environment detection failed on environment variables", 2)
                return False
        CommonUtil.ExecLog(sModuleInfo, "Headless environment detected based on environment variables", 1)
        return True
            
    except Exception as e:
        CommonUtil.ExecLog(sModuleInfo, f"Error detecting headless environment: {str(e)}", 2)
        # If we can't determine, assume non-headless to be safe
        return False


@logger
def find_exe_in_path(exe):
    """Search the path for an executable"""

    try:
        path = os.getenv("PATH")  # Linux/Windows path

        if ";" in path:  # Windows delimiter
            dirs = path.split(";")
        elif ":" in path:  # Linux delimiter
            dirs = path.split(":")
        else:
            return "zeuz_failed"

        for directory in dirs:  # Try each directory
            filename = os.path.join(directory, exe)  # Create full path
            if os.path.isfile(filename):  # If it exists, return it and stop
                return filename

        # No matches
        return "zeuz_failed"

    except Exception:
        errMsg = "Error searching PATH"
        return CommonUtil.Exception_Handler(sys.exc_info(), None, errMsg)


@logger
def find_appium():
    """Do our very best to find the appium executable"""

    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME

    # Expected locations
    appium_list = [
        "/usr/bin/appium",
        os.path.join(str(os.getenv("HOME")), ".linuxbrew/bin/appium"),
        os.path.join(str(os.getenv("ProgramFiles")), "APPIUM", "Appium.exe"),
        os.path.join(
            str(os.getenv("USERPROFILE")), "AppData", "Roaming", "npm", "appium.cmd"
        ),
        os.path.join(str(os.getenv("ProgramFiles(x86)")), "APPIUM", "Appium.exe"),
    ]  # getenv() must be wrapped in str(), so it doesn't fail on other platforms

    # Try to find the appium executable
    appium_binary = ""

    for binary in appium_list:
        if os.path.exists(binary):
            appium_binary = binary
            break

    # Try to find the appium executable in the PATH variable
    if appium_binary == "":  # Didn't find where appium was installed
        CommonUtil.ExecLog(sModuleInfo, "Searching PATH for appium", 0)
        for exe in ("appium", "appium.exe", "appium.bat", "appium.cmd"):
            result = find_exe_in_path(exe)  # Get path and search for executable with in
            if result != "zeuz_failed":
                appium_binary = result
                break

    # Verify if we have the binary location
    if appium_binary == "":  # Didn't find where appium was installed
        CommonUtil.ExecLog(
            sModuleInfo, "Appium not found. Trying to locate via which", 0
        )
        try:
            appium_binary = subprocess.check_output(
                "which appium", encoding="utf-8", shell=True
            ).strip()
        except:
            pass

        if appium_binary == "":  # Didn't find where appium was installed
            appium_binary = "appium"  # Default filename of appium, assume in the PATH
            CommonUtil.ExecLog(
                sModuleInfo, "Appium still not found. Assuming it's in the PATH.", 2
            )
        else:
            CommonUtil.ExecLog(sModuleInfo, "Found appium: %s" % appium_binary, 1)
    else:  # Found appium's path
        CommonUtil.ExecLog(sModuleInfo, "Found appium: %s" % appium_binary, 1)

    return appium_binary


@logger
def start_appium_server():
    """Starts the external Appium server.

    Returns appium_port on success.
    """
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME

    appium_binary = find_appium()

    def is_port_in_use(port):
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
            return s.connect_ex(("localhost", port)) == 0

    try:
        appium_port = 4723
        tries = 0
        while is_port_in_use(appium_port) and tries < 20:
            appium_port += 2

        if tries >= 20:
            CommonUtil.ExecLog(
                sModuleInfo,
                "Failed to find a free port for running appium after 20 tries.",
                1,
            )
            return "zeuz_failed"

        try:
            appium_server = None
            if (
                sys.platform == "win32"
            ):  # We need to open appium in it's own command dos box on Windows
                cmd = (
                    'start "Appium Server" /wait /min cmd /c %s --allow-insecure chromedriver_autodownload -p %d'
                    % (appium_binary, appium_port)
                )  # Use start to execute and minimize, then cmd /c will remove the dos box when appium is killed
                appium_server = subprocess.Popen(
                    cmd, shell=True
                )  # Needs to run in a shell due to the execution command
            elif sys.platform == "darwin":
                appium_server = subprocess.Popen(
                    "%s --allow-insecure chromedriver_autodownload -p %s"
                    % (appium_binary, str(appium_port)),
                    shell=True,
                )
            elif sys.platform == "linux" or sys.platform == "linux2":
                appium_server = subprocess.Popen(
                    "%s --allow-insecure chromedriver_autodownload -p %s"
                    % (appium_binary, str(appium_port)),
                    shell=True,
                )
            else:
                try:
                    appium_binary_path = os.path.normpath(appium_binary)
                    appium_binary_path = os.path.abspath(
                        os.path.join(appium_binary_path, os.pardir)
                    )
                    env = {"PATH": str(appium_binary_path)}
                    appium_server = subprocess.Popen(
                        "%s --allow-insecure chromedriver_autodownload -p %s"
                        % (appium_binary, str(appium_port)),
                        shell=True,
                        env=env,
                    )
                except:
                    CommonUtil.ExecLog(
                        sModuleInfo,
                        "Couldn't launch appium server, please do it manually by typing 'appium &' in the terminal",
                        2,
                    )
        except Exception as returncode:  # Couldn't run server
            return CommonUtil.Exception_Handler(
                sys.exc_info(),
                None,
                "Couldn't start Appium server. May not be installed, or not in your PATH: %s"
                % returncode,
            )

        # Wait for server to startup and return
        CommonUtil.ExecLog(
            sModuleInfo,
            "Waiting for server to start on port %d: %s" % (appium_port, appium_binary),
            0,
        )
        maxtime = time.time() + 10  # Maximum time to wait for appium server
        while True:  # Dynamically wait for appium to start by polling it
            if time.time() > maxtime:
                break  # Give up if max time was hit
            try:  # If this works, then stop waiting for appium
                r = requests.get(
                    "http://localhost:%d/sessions" % appium_port
                )  # Poll appium server
                if r.status_code:
                    break
            except:
                time.sleep(0.1)  # sleep for 0.1 sec before retrying.

        if appium_server:
            CommonUtil.ExecLog(sModuleInfo, "Server started", 1)
            return appium_port
        else:
            CommonUtil.ExecLog(sModuleInfo, "Server failed to start", 3)
            return "zeuz_failed"
    except Exception:
        return CommonUtil.Exception_Handler(
            sys.exc_info(), None, "Error starting Appium server"
        )


@logger
def Open_Electron_App(data_set):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    global selenium_details
    global current_driver_id

    try:
        desktop_app_path = ""
        driver_id = ""
        for left, _, right in data_set:
            left = left.replace(" ", "").replace("_", "").replace("-", "").lower()
            if "windows" in left and platform.system() == "Windows":
                desktop_app_path = right.strip()
            elif "mac" in left and platform.system() == "Darwin":
                desktop_app_path = right.strip()
            elif "linux" in left and platform.system() == "Linux":
                desktop_app_path = right.strip()
            elif left == "driverid":
                driver_id = right.strip()

        if not desktop_app_path:
            CommonUtil.ExecLog(
                sModuleInfo,
                "You did not provide an Electron app path for %s OS"
                % platform.system(),
                3,
            )
            return "zeuz_failed"

        if not driver_id:
            driver_id = "default"

        desktop_app_path = CommonUtil.path_parser(desktop_app_path)
        electron_chrome_path = ConfigModule.get_config_value(
            "Selenium_driver_paths", "electron_chrome_path"
        )
        if not electron_chrome_path:
            electron_chrome_path = ChromeDriverManager().install()

        try:
            from selenium.webdriver.chrome.options import Options
            from selenium.webdriver.chrome.service import Service

            opts = Options()
            opts.binary_location = desktop_app_path
            selenium_driver = webdriver.Chrome(opts, Service())
            selenium_driver.implicitly_wait(0.5)
            CommonUtil.ExecLog(sModuleInfo, "Started Electron App", 1)
            Shared_Resources.Set_Shared_Variables("selenium_driver", selenium_driver)
            CommonUtil.set_screenshot_vars(Shared_Resources.Shared_Variable_Export())

        except Exception:
            return CommonUtil.Exception_Handler(sys.exc_info())

        if driver_id in selenium_details:
            pass  # we need to decide later based on the situation
        else:
            selenium_details[driver_id] = {"driver": selenium_driver}
        current_driver_id = driver_id
        return "passed"
    except:
        return CommonUtil.Exception_Handler(sys.exc_info())


@logger
def use_xvfb_or_headless(callback):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    if platform.system() == "Linux":
        try:
            global vdisplay
            vdisplay = Xvfb(width=1920, height=1080, colordepth=16)
            vdisplay.start()
        except:
            CommonUtil.ExecLog(
                sModuleInfo,
                "Failed to initialize xvfb. "
                "Perhaps xvfb is not installed?\n"
                "For apt-get: `sudo apt-get install xvfb`\n"
                "For yum: `sudo yum install xvfb`.\n"
                "Falling back to headless mode.",
                2,
            )
            callback()
    else:
        callback()


def set_extension_variables():
    try:
        url = ConfigModule.get_config_value("Authentication", "server_address").strip()
        apiKey = ConfigModule.get_config_value("Authentication", "api-key").strip()
        jwtKey = CommonUtil.jwt_token.strip()
        metaData = {
            "testNo": CommonUtil.current_tc_no,
            "testName": CommonUtil.current_tc_name,
            "stepNo": CommonUtil.current_step_sequence,
            "stepName": CommonUtil.current_step_name,
            "url": url,
            "apiKey": apiKey,
            "jwtKey": jwtKey,
            "nodeId": Shared_Resources.Get_Shared_Variables("node_id"),
        }
        with open(Path(aiplugin_path) / "data.json", "w") as file:
            json.dump(metaData, file, indent=4)

    except:
        return CommonUtil.Exception_Handler(
            sys.exc_info(), None, "Could not load inspector extension"
        )

    try:
        with open(Path(ai_recorder_path) / "background" / "data.json", "w") as file:
            json.dump(metaData, file, indent=4)
        with open(
            Path(ai_recorder_public_path) / "background" / "data.json", "w"
        ) as file:
            json.dump(metaData, file, indent=4)

    except:
        return CommonUtil.Exception_Handler(
            sys.exc_info(), None, "Could not load recorder extension"
        )


def generate_options(browser: str, browser_options: BrowserOptions):
    """Adds capabilities and options for Browser/WebDriver"""
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    chromium_condition = browser in ("android", "chrome", "chromeheadless", "microsoft edge chromium", "edgechromiumheadless")
    
    # Check if we're in a headless environment and need to auto-enable headless mode
    auto_headless = False
    if "headless" not in browser.lower() and is_headless_environment():
        auto_headless = True
        CommonUtil.ExecLog(sModuleInfo, f"Headless environment detected. Auto-enabling headless mode for {browser}", 2)
    
    msg = ""
    if chromium_condition:
        b = "edge" if "edge" in browser else "chrome"
        from selenium.webdriver.chrome.options import Options as ChromeOptions
        from selenium.webdriver.edge.options import Options as EdgeOptions

        options = ChromeOptions() if b == "chrome" else EdgeOptions()
        # from selenium.webdriver.chromium.options import ChromiumOptions
        # options = ChromiumOptions()
        if browser == "android":
            mobile_emulation = {"deviceName": "Pixel 2 XL"}
            options.add_experimental_option("mobileEmulation", mobile_emulation)
        for argument in browser_options[b]["add_argument"]:
            options.add_argument(argument)
        for key, val in browser_options[b]["add_experimental_option"].items():
            options.add_experimental_option(key, val)
        for extension in browser_options[b]["add_extension"]:
            options.add_extension(extension)
        for extension in browser_options[b]["add_encoded_extension"]:
            options.add_encoded_extension(extension)
        if "page_load_strategy" in browser_options[b]:
            options.page_load_strategy = browser_options[b]["page_load_strategy"]
        if "debugger_address" in browser_options[b]:
            # When debugger_address is mentioned, the Service() object should be ignored by default
            # Users need to remove experimental options by setting it to {}
            options.debugger_address = browser_options[b]["debugger_address"]
            msg += f"Debugger address: {options.debugger_address}\n"
        msg += (
            f"Experimental_options: {json.dumps(options.experimental_options, indent=2)}\n"
            f"Extensions: {len(options.extensions)} added\n"
        )
    elif browser in ("firefox", "firefoxheadless"):
        from selenium.webdriver.firefox.options import Options as FirefoxOptions

        options = FirefoxOptions()
        for argument in browser_options["firefox"]["add_argument"]:
            options.add_argument(argument)
        for key, val in browser_options["firefox"]["set_preference"].items():
            options.set_preference(key, val)
        if "page_load_strategy" in browser_options["firefox"]:
            options.page_load_strategy = browser_options["firefox"][
                "page_load_strategy"
            ]
        msg += f"Preferences: {json.dumps(options.preferences, indent=2)}\n"
    elif "safari" in browser:
        from selenium.webdriver.safari.options import Options as SafariOptions

        options = SafariOptions()
        for argument in browser_options["safari"]["add_argument"]:
            options.add_argument(argument)
        if "page_load_strategy" in browser_options["safari"]:
            options.page_load_strategy = browser_options["safari"]["page_load_strategy"]
    else:
        from selenium.webdriver.common.options import ArgOptions

        return ArgOptions()

    # Add headless arguments if explicitly requested or auto-detected
    if "headless" in browser or auto_headless:
        def headless():
            if "chrome" in browser or "edge" in browser:
                arg = "--headless=new"
            else:
                arg = "--headless"
            
            # Check if headless argument is already present
            headless_already_added = any(
                "--headless" in str(arg) for arg in getattr(options, 'arguments', [])
            )
            
            if not headless_already_added:
                options.add_argument(arg)
                if auto_headless:
                    CommonUtil.ExecLog(sModuleInfo, f"Added {arg} argument due to headless environment detection", 1)
                    
        use_xvfb_or_headless(headless)

    for key, value in browser_options["capabilities"].items():
        options.set_capability(key, value)

    # On Debug run open inspector with credentials
    if (
        CommonUtil.debug_status
        and ConfigModule.get_config_value("Inspector", "ai_plugin").strip().lower()
        in ("true", "on", "enable", "yes", "on_debug")
        and browser in ("chrome", "microsoft edge chromium")
    ):
        set_extension_variables()
        options.add_argument("--disable-features=DisableLoadExtensionCommandLineSwitch")
        options.add_argument(f"load-extension={aiplugin_path},{ai_recorder_path}")
        # This is for running extension on a http server to call a https request
        options.add_argument("--allow-running-insecure-content")

    msg += (
        f"Capabilities: {json.dumps(options.capabilities, indent=2)}\n"
        + f"Arguments: {json.dumps(options.arguments, indent=2)}\n"
        + f"Page load strategy: {options.page_load_strategy}\n"
    )
    CommonUtil.ExecLog(sModuleInfo, msg, 5)
    return options


@logger
def Open_Browser(browser, browser_options: BrowserOptions):
    """Launch browser from options and service object"""
    try:
        global selenium_driver
        sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
        browser = browser.lower().strip()
        if browser == "ios":
            # Finds the appium binary and starts the server.
            appium_port = start_appium_server()

            if appium_port == "zeuz_failed":
                return "zeuz_failed"

            capabilities = {
                "platformName": "iOS",
                "automationName": "XCUITest",
                "browserName": "Safari",
            }

            from appium import webdriver as appiumdriver
            from appium.options.android import UiAutomator2Options

            capabilities_options = UiAutomator2Options().load_capabilities(capabilities)
            selenium_driver = appiumdriver.Remote(
                "http://localhost:%d" % appium_port, options=capabilities_options
            )
            return "passed"

        options = generate_options(browser, browser_options)
        if browser in ("android", "chrome", "chromeheadless"):
            from selenium.webdriver.chrome.service import Service

            chrome_bin = browser_options["chrome"].get("binary_location", None)
            driver_bin = browser_options["chrome"].get("driver_path", None)

            if chrome_bin and driver_bin:
                # Use Chrome for Testing binaries
                service = Service(executable_path=driver_bin)
                options.binary_location = chrome_bin
                CommonUtil.ExecLog(sModuleInfo, "Using Chrome for Testing binaries", 1)
            else:
                # Use standard ChromeDriverManager
                service = Service()
                CommonUtil.ExecLog(sModuleInfo, "Using standard Chrome binaries", 1)

            selenium_driver = webdriver.Chrome(
                service=service,
                options=options,
            )

            # service = Service()
            # selenium_driver = webdriver.Chrome(
            #     service=service,
            #     options=options,
            # )

        elif browser in ("microsoft edge chromium", "edgechromiumheadless"):
            from selenium.webdriver.edge.service import Service

            service = Service()
            selenium_driver = webdriver.Edge(
                service=service,
                options=options,
            )

        elif browser in ("firefox", "firefoxheadless"):
            from selenium.webdriver.firefox.service import Service

            service = Service()
            selenium_driver = webdriver.Firefox(
                service=service,
                options=options,
            )

        elif "safari" in browser:
            from selenium.webdriver.safari.service import Service

            service = Service()
            selenium_driver = webdriver.Safari(
                service=service,
                options=options,
            )
        else:
            CommonUtil.ExecLog(
                sModuleInfo, "You did not select a valid browser: %s" % browser, 3
            )
            return "zeuz_failed"

        CommonUtil.ExecLog(sModuleInfo, f"Started {browser} browser", 1)
        Shared_Resources.Set_Shared_Variables("selenium_driver", selenium_driver)
        CommonUtil.set_screenshot_vars(Shared_Resources.Shared_Variable_Export())
        return "passed"

    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


@logger
def Go_To_Link_V2(step_data):
    from selenium.webdriver.chrome.options import Options

    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME

    global dependency
    global selenium_driver
    global selenium_details
    global current_driver_id

    url = None
    driver_tag = "default"
    page_load_timeout_sec = 120
    options = Options()
    page_load_strategy = "normal"

    for left, _, right in step_data:
        left = left.strip().lower()
        if "add argument" == left:
            options.add_argument(right.strip())
            CommonUtil.ExecLog(sModuleInfo, "Added argument: " + right.strip(), 1)
        elif "add extension" == left:
            filepath = CommonUtil.path_parser(right.strip())
            options.add_extension(filepath)
            CommonUtil.ExecLog(sModuleInfo, "Added extension: " + filepath, 1)
        elif "add experimental option" in left:
            options.add_experimental_option(
                eval(right.split(",", 1)[0].strip()),
                eval(right.split(",", 1)[1].strip()),
            )
            CommonUtil.ExecLog(
                sModuleInfo, "Added experimental option: " + right.strip(), 1
            )
        elif "set capability" in left:
            options.set_capability(
                eval(right.split(",", 1)[0].strip()),
                eval(right.split(",", 1)[1].strip()),
            )
            CommonUtil.ExecLog(sModuleInfo, "Added capability: " + right.strip(), 1)
        elif "go to link v2" == left:
            url = right.strip() if right.strip() != "" else None
        elif "driver tag" == left:
            driver_tag = right.strip()
        elif "wait for element" == left:
            Shared_Resources.Set_Shared_Variables("element_wait", float(right.strip()))
        elif "page load timeout" == left:
            page_load_timeout_sec = float(right.strip())
        elif "page load strategy" == left:
            page_load_strategy = right.strip()
            options.page_load_strategy = page_load_strategy

    if driver_tag in selenium_details.keys():
        selenium_driver = selenium_details[driver_tag]["driver"]
    else:
        if Shared_Resources.Test_Shared_Variables("dependency"):
            dependency = Shared_Resources.Get_Shared_Variables("dependency")
        else:
            raise ValueError("No dependency set - Cannot run")

        dependency_browser = dependency["Browser"].lower()
        if "headless" in dependency_browser:
            options.add_argument("--headless")
            CommonUtil.ExecLog(sModuleInfo, "Added headless argument", 1)

        if "chrome" in dependency_browser:
            selenium_driver = webdriver.Chrome(options=options)
        elif "firefox" in dependency_browser:
            selenium_driver = webdriver.Firefox(options=options)

        selenium_driver.set_page_load_timeout(page_load_timeout_sec)
        selenium_details[driver_tag] = dict()
        selenium_details[driver_tag]["driver"] = selenium_driver
        current_driver_id = selenium_driver
        Shared_Resources.Set_Shared_Variables("selenium_driver", selenium_driver)

        # Handle headless mode window maximize
        if (
            "--headless" in options.arguments
            and "--start-maximized" in options.arguments
        ):
            selenium_driver.set_window_size(default_x, default_y)

    if url:
        selenium_driver.get(url)

    selenium_driver.maximize_window()
    Shared_Resources.Set_Shared_Variables("selenium_driver", selenium_driver)
    CommonUtil.set_screenshot_vars(Shared_Resources.Shared_Variable_Export())
    return "passed"


def parse_and_verify_datatype(left: str, right: str, chrome_version=None):
    val = CommonUtil.parse_value_into_object(right)
    if left == "addargument":
        if isinstance(val, list) and all(isinstance(item, str) for item in val):
            return val
        raise ValueError(
            "Argument must be list of strings. Example: ['--ignore-ssl-errors', '--no-sandbox']"
        )

    if left == "addextension":
        if isinstance(val, list) and all(isinstance(item, str) for item in val):
            extension_ids = []
            extension_crxs = []
            for item in val:
                if item.lower().endswith(".crx") or os.path.isfile(item):
                    extension_crxs.append(item)
                elif re.match(r"^[a-p]{32}$", item):
                    extension_ids.append(item)
                else:
                    raise ValueError(
                        f"Invalid extension: {item}. Must be .crx file path or Chrome extension ID."
                    )

            # download all extensions from ids
            for ext_id in extension_ids:
                downloader = ChromeExtensionDownloader(chrome_version=chrome_version)
                result = downloader.setup_chrome_extension_download(extension_id=ext_id)
                if result.get("crx_path"):
                    extension_crxs.append(result["crx_path"])

            return extension_crxs
        raise ValueError(
            "Extensions must be list of strings. Example: ['path/to/ex1.crx', 'path/to/ex2.crx']"
        )

    if left == "addencodedextension":
        if isinstance(val, list) and all(isinstance(item, str) for item in val):
            return val
        raise ValueError(
            "Encoded_extenions must be list of strings. Example: ['ex1_encoded_str', 'ex2_encoded_str']"
        )

    elif left == "addexperimentaloption":
        if isinstance(val, dict):
            return val
        raise ValueError(
            'Experimental_option must be dictionary. Example: {"mobileEmulation":{"deviceName": "Pixel 2 XL"}}'
        )

    elif left == "setpreference":
        if isinstance(val, dict):
            return val
        raise ValueError(
            'Preference must be dictionary. Example: {"security.mixed_content.block_active_content": False}'
        )


@logger
def Go_To_Link(dataset: Dataset) -> ReturnType:
    try:
        sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
        window_size_X = None
        window_size_Y = None

        global initial_download_folder
        initial_download_folder = download_dir = ConfigModule.get_config_value(
            "sectionOne", "initial_download_folder", temp_config
        )
        apps = "application/pdf;text/plain;application/text;text/xml;application/xml;application/xlsx;application/csv;application/zip"
        default_chromium_arguments = {
            "add_argument": [
                "--ignore-certificate-errors",
                "--ignore-ssl-errors",
                "--zeuz_pid_finder",
                # "--remote-debugging-port=9222",  # Required for playright
                # "--no-sandbox"
            ],
            "add_experimental_option": {
                "prefs": {
                    # "profile.default_content_settings.popups": 0,
                    "download.default_directory": download_dir,
                    "download.prompt_for_download": False,
                    # "download.directory_upgrade": True,
                    # 'safebrowsing.enabled': 'false'
                }
            },
            "add_extension": [],
            "add_encoded_extension": [],
            # "page_load_strategy": "normal"
        }
        browser_options: BrowserOptions = {
            "capabilities": {
                "unhandledPromptBehavior": "ignore",
                # "goog:loggingPrefs": {"performance": "ALL"},
            },
            "chrome": default_chromium_arguments,
            "edge": default_chromium_arguments,
            "firefox": {
                "add_argument": [],
                "set_preference": {
                    "browser.download.folderList": 2,
                    "browser.download.manager.showWhenStarting": False,
                    "browser.download.dir": download_dir,
                    "browser.helperApps.neverAsk.saveToDisk": apps,
                    "browser.download.useDownloadDir": True,
                    "browser.download.manager.closeWhenDone": True,
                    "security.mixed_content.block_active_content": False,
                },
            },
            "safari": {
                "add_argument": [],
            },
        }
        # Open browser and create driver if user has not already done so
        global dependency
        global selenium_driver
        global selenium_details
        global current_driver_id
        if Shared_Resources.Test_Shared_Variables("dependency"):
            dependency = Shared_Resources.Get_Shared_Variables("dependency")
        else:
            raise ValueError("No dependency set - Cannot run")

        page_load_timeout_sec = 120
        web_link = None  # None is for Open_Empty_Browser
        if dependency["Browser"] in options_map:
            browser = options_map[dependency["Browser"]]
        else:
            browser = None
        driver_id = ""
        chrome_version = None
        chrome_channel = None
        debug_port = False

        for left, mid, right in dataset:
            left = left.replace(" ", "").replace("_", "").replace("-", "").lower()
            if left == "gotolink":
                web_link = right.strip()
            elif left == "driverid":
                driver_id = right.strip()
            elif left in ("waittimetoappearelement", "waitforelement"):
                Shared_Resources.Set_Shared_Variables(
                    "element_wait", float(right.strip())
                )
            elif left == "waittimetopageload":
                page_load_timeout_sec = int(right.strip())
            elif left == "resolution":
                resolution = right.split(",")
                window_size_X = int(resolution[0])
                window_size_Y = int(resolution[1])
            elif left == "chrome:version":
                chrome_version = right.strip()

            # Capabilities are WebDriver attribute common across different browser
            elif mid.strip().lower() == "shared capability":
                browser_options["capabilities"] = CommonUtil.parse_value_into_object(
                    right
                )
            # Options are browser specific.
            elif browser is not None and (
                mid.strip().lower() == "chromium option"
                and browser in ("chrome", "edge")
                or browser == mid.split(" ")[0].strip().lower()
            ):
                if left == "addargument":
                    browser_options[browser]["add_argument"] = (
                        parse_and_verify_datatype(left, right)
                    )
                elif left == "addexperimentaloption":
                    browser_options[browser]["add_experimental_option"] = (
                        parse_and_verify_datatype(left, right)
                    )
                elif left == "addextension":
                    browser_options[browser]["add_extension"] = (
                        parse_and_verify_datatype(left, right, chrome_version)
                    )
                elif left == "addencodedextension":
                    browser_options[browser]["add_encoded_extension"] = (
                        parse_and_verify_datatype(left, right)
                    )
                elif left == "setpreference":
                    browser_options[browser]["set_preference"] = (
                        parse_and_verify_datatype(left, right)
                    )
                elif left == "pageloadstrategy":
                    browser_options[browser]["page_load_strategy"] = right.strip()
                elif left == "debuggeraddress":
                    browser_options[browser]["debugger_address"] = right.strip()

        debug_port = None
        if browser in browser_options:
            for arg in browser_options[browser]["add_argument"]:
                if any(arg.startswith(prefix) for prefix in [
                        "--remote-debugging-port=",
                        "--webkit-remote-debugging-port="
                ]):
                    debug_port = int(arg.split("=")[1])
                    break

        if dependency["Browser"] in (
            "Chrome",
            "ChromeHeadless",
        ) and not browser_options["chrome"].get("debugger_address", ""):
            cft = ChromeForTesting()

            if chrome_version:
                if chrome_version.strip().lower() in ("beta", "dev", "canary"):
                    chrome_channel = chrome_version.strip().capitalize()
                    chrome_version = None
                else:
                    chrome_version = chrome_version.strip()

            chrome_bin, driver_bin = cft.setup_chrome_for_testing(
                chrome_version, chrome_channel
            )

            if chrome_bin and driver_bin:
                browser_options["chrome"]["binary_location"] = str(chrome_bin)
                browser_options["chrome"]["driver_path"] = str(driver_bin)
                CommonUtil.ExecLog(
                    sModuleInfo,
                    f"Using Chrome for Testing {chrome_version or 'latest'}",
                    1,
                )
            else:
                CommonUtil.ExecLog(
                    sModuleInfo,
                    "Failed to get Chrome for Testing binaries. Using system Chrome",
                    2,
                )

        if not driver_id:
            if len(selenium_details.keys()) == 0:
                driver_id = "default"
            elif current_driver_id is not None:
                driver_id = current_driver_id
            else:
                driver_id = list(selenium_details.keys())[0]

        if (
            driver_id not in selenium_details
            or selenium_details[driver_id]["driver"]
            .capabilities["browserName"]
            .strip()
            .lower()
            != browser_map[dependency["Browser"]]
        ):
            if (
                driver_id in selenium_details
                and selenium_details[driver_id]["driver"]
                .capabilities["browserName"]
                .strip()
                .lower()
                != browser_map[dependency["Browser"]]
            ):
                Tear_Down_Selenium()  # If dependency is changed then teardown and relaunch selenium driver
            CommonUtil.ExecLog(
                sModuleInfo, "Browser not previously opened, doing so now", 1
            )

            if Open_Browser(dependency["Browser"], browser_options) == "zeuz_failed":
                return "zeuz_failed"

            if ConfigModule.get_config_value(
                "RunDefinition", "window_size_x"
            ) and ConfigModule.get_config_value("RunDefinition", "window_size_y"):
                window_size_X = ConfigModule.get_config_value(
                    "RunDefinition", "window_size_x"
                )
                window_size_Y = ConfigModule.get_config_value(
                    "RunDefinition", "window_size_y"
                )

            if not window_size_X and not window_size_Y:
                if dependency["Browser"] == "ChromeHeadless":
                    window_size_X, window_size_Y = 1920, 1080
                    selenium_driver.set_window_size(window_size_X, window_size_Y)
                else:
                    selenium_driver.maximize_window()
            else:
                selenium_driver.set_window_size(window_size_X, window_size_Y)

            selenium_details[driver_id] = {
                "driver": Shared_Resources.Get_Shared_Variables("selenium_driver"),
                "remote-debugging-port": debug_port
            }
        else:
            selenium_driver = selenium_details[driver_id]["driver"]
            Shared_Resources.Set_Shared_Variables("selenium_driver", selenium_driver)
        current_driver_id = driver_id
    except Exception:
        ErrorMessage = "failed to open browser"
        return CommonUtil.Exception_Handler(sys.exc_info(), None, ErrorMessage)

    # Set timeout
    selenium_driver.set_page_load_timeout(page_load_timeout_sec)

    # Open URL in browser
    try:
        if web_link is not None:
            try:
                selenium_driver.get(web_link)
            except TimeoutException as e:
                CommonUtil.ExecLog(
                    sModuleInfo,
                    "Maximum page load time reached. Loading and proceeding",
                    2,
                )

            selenium_driver.implicitly_wait(0.5)  # Wait for page to load
            CommonUtil.ExecLog(
                sModuleInfo,
                "Successfully opened your link with driver_id='%s': %s"
                % (driver_id, web_link),
                1,
            )

    except WebDriverException as e:
        browser = selenium_driver.capabilities["browserName"].strip().lower()
        if (
            browser in ("chrome", "edge")
            and e.msg.lower().startswith("chrome not reachable")
        ) or (
            browser == "firefox"
            and e.msg.lower().startswith(
                "tried to run command without establishing a connection"
            )
        ):
            CommonUtil.ExecLog(
                sModuleInfo, "Browser not found. trying to restart the browser", 2
            )
            # If the browser is closed but selenium instance is on, relaunch selenium_driver
            if Shared_Resources.Test_Shared_Variables("dependency"):
                dependency = Shared_Resources.Get_Shared_Variables("dependency")
            result = Open_Browser(dependency["Browser"], browser_options)
        else:
            result = "zeuz_failed"

        if result == "zeuz_failed":
            ErrorMessage = "failed to open your link with driver_id='%s: %s" % (
                driver_id,
                web_link,
            )
            return CommonUtil.Exception_Handler(sys.exc_info(), None, ErrorMessage)
        try:
            selenium_driver.get(web_link)
            selenium_driver.implicitly_wait(0.5)
            CommonUtil.ExecLog(
                sModuleInfo,
                "Successfully opened your link with driver_id='%s': %s"
                % (driver_id, web_link),
                1,
            )
        except Exception:
            ErrorMessage = "failed to open your link: %s" % (web_link)
            return CommonUtil.Exception_Handler(sys.exc_info(), None, ErrorMessage)
    except Exception:
        ErrorMessage = "failed to open your link: %s" % (web_link)
        return CommonUtil.Exception_Handler(sys.exc_info(), None, ErrorMessage)

    return "passed"


@logger
def Handle_Browser_Alert(step_data):
    # accepts browser alert
    """
    wait           optional parameter  5.0
    handle alert   selenium action     get text = my_variable
    handle alert   selenium action     send text = my text to send to alert
    handle alert   selenium action     accept, pass, yes, ok (any of these would work)
    handle alert   selenium action     reject, fail, no, cancel (any of these would work)
    """
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME

    wait = 5.0
    choice, choice_lower = "", ""
    try:
        for left, mid, right in step_data:
            left = left.lower()
            if "handle alert" in left:
                choice = right
                choice_lower = right.strip().lower()
            elif "wait" in left:
                wait = float(right.strip())

    except Exception:
        CommonUtil.ExecLog(sModuleInfo, "Failed to parse data", 3)
        return "zeuz_failed"

    try:
        CommonUtil.ExecLog(
            "", "Waiting %s seconds max for the alert box to appear" % str(wait), 1
        )
        WebDriverWait(selenium_driver, wait).until(EC.alert_is_present())
        time.sleep(2)
    except TimeoutException:
        CommonUtil.ExecLog(
            sModuleInfo, "Waited %s seconds but no alert box appeared" % str(wait), 3
        )
        return "zeuz_failed"

    try:
        if choice_lower in ("accept", "pass", "yes", "ok"):
            Alert(selenium_driver).accept()
            CommonUtil.ExecLog(sModuleInfo, "Browser alert accepted", 1)
            return "passed"

        elif choice_lower in ("reject", "decline", "dismiss", "fail", "no", "cancel"):
            Alert(selenium_driver).dismiss()
            CommonUtil.ExecLog(sModuleInfo, "Browser alert rejected", 1)
            return "passed"

        elif choice_lower.replace(" ", "").replace("_", "").startswith("gettext"):
            alert_text = Alert(selenium_driver).text
            Alert(selenium_driver).accept()
            variable_name = (choice.split("="))[1].strip()
            return Shared_Resources.Set_Shared_Variables(variable_name, alert_text)

        elif choice_lower.replace(" ", "").replace("_", "").startswith("sendtext"):
            text_to_send = (choice.split("="))[1].strip()
            Alert(selenium_driver).send_keys(text_to_send)
            Alert(selenium_driver).accept()
            return "passed"

        else:
            CommonUtil.ExecLog(
                sModuleInfo,
                "Wrong Step Data. The following are valid data --\n"
                + "1. (handle alert, selenium action, ok)"
                + "2. (handle alert, selenium action, cancel)"
                + "3. (handle alert, selenium action, get text = var_name)"
                + "4. (handle alert, selenium action, send text = some text)",
                3,
            )
            return "zeuz_failed"

    except Exception:
        ErrorMessage = "Failed to handle alert"
        return CommonUtil.Exception_Handler(sys.exc_info(), None, ErrorMessage)


@logger
def save_screenshot(driver, path):
    """
    Take the screenshot of the whole web page
    :param driver: selenium driver
    :param path: where to save the screenshot
    :return: None
    """
    # Ref: https://stackoverflow.com/a/52572919
    import time

    original_size = driver.get_window_size()
    required_width = driver.execute_script(
        "return document.body.parentNode.scrollWidth"
    )
    required_height = driver.execute_script(
        "return document.body.parentNode.scrollHeight"
    )
    driver.set_window_size(required_width, required_height)
    time.sleep(2)
    # driver.save_screenshot(path)  # has scrollbar
    driver.find_element("xpath", "//body").screenshot(path)  # avoids scrollbar
    time.sleep(2)
    driver.set_window_size(original_size["width"], original_size["height"])


@logger
def take_screenshot_selenium(data_set):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME

    try:
        filename_format = "%Y_%m_%d_%H-%M-%S"
        fullscreen = False

        for left, mid, right in data_set:
            if "take screenshot web" in left:
                if "default" not in right:
                    filename_format = right.strip()
            if "fullscreen" in left:
                fullscreen = right.lower().strip() == "true"

        screenshot_folder = ConfigModule.get_config_value(
            "sectionOne", "screen_capture_folder", temp_config
        )
        filename = time.strftime(filename_format) + ".png"
        screenshot_path = str(Path(screenshot_folder) / Path(filename))

        if fullscreen:
            save_screenshot(selenium_driver, screenshot_path)
        else:
            selenium_driver.save_screenshot(screenshot_path)

        # Save the screenshot's name into a variable
        Shared_Resources.Set_Shared_Variables("zeuz_screenshot", filename)
        return 'passed'
    except Exception:
        errMsg = "Failed to take screenshot"
        return CommonUtil.Exception_Handler(sys.exc_info(), None, errMsg)


def Change_Attribute_Value(step_data):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    try:
        change_value = ""
        attribute_name = ""
        global selenium_driver
        Element = LocateElement.Get_Element(step_data, selenium_driver)
        if Element == "zeuz_failed":
            CommonUtil.ExecLog(
                sModuleInfo, "Unable to locate your element with given data.", 3
            )
            return "zeuz_failed"
        for left, mid, right in step_data:
            mid = mid.strip().lower()
            left = left.strip().lower()
            if "input parameter" in mid:
                attribute_name = left
                change_value = right

        selenium_driver.execute_script(
            f"arguments[0].{attribute_name} = `{change_value}`;", Element
        )
        CommonUtil.ExecLog(
            sModuleInfo,
            "Successfully set the value of the attribute to: %s" % change_value,
            1,
        )
        return "passed"
    except Exception:
        errMsg = "Could not find your element."
        return CommonUtil.Exception_Handler(sys.exc_info(), None, errMsg)


@logger
def capture_network_log(step_data):
    """
    This action captures network activity (API requests, responses, status codes, etc.) from a Chromium-based browser using Selenium. The logs can be filtered and saved to a variable for further validation or analysis.

    Example 1:
    Field	                    Sub Field	            Value
    capture network log         selenium action 	    start

    Example 2:
    Field	                    Sub Field	            Value
    save                        input parameter         variable_name
    filter domain               input parameter         zeuz.ai
    include status code         input parameter         201, 400-504
    include request method      input parameter         GET, POST
    include response body       input parameter         false
    capture network log         selenium action 	    stop
    """
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver

    try:
        # Helper function to parse status code
        def parse_status_codes(code_str):
            result = []
            for part in code_str.split(","):
                part = part.strip()
                if "-" in part:
                    start, end = map(int, part.split("-"))
                    result.extend(range(start, end + 1))
                else:
                    result.append(int(part))
            return result

        params = {
            "variable_name": None,
            "mode": None,
            "filter_domains": [],
            "status_filter": [],
            "method_filter": [],
            "include_body": False,
        }

        # Parse
        for left, mid, right in step_data:
            left = left.lower().strip()
            if left == "capture network log":
                params["mode"] = right.lower().strip()
            elif left == "save":
                params["variable_name"] = right.strip()
            elif left == "filter domain":
                params["filter_domains"] = [d.strip() for d in right.split(",")]
            elif left == "include status code":
                params["status_filter"] = parse_status_codes(right.strip())
            elif left == "include request method":
                params["method_filter"] = [m.strip().upper() for m in right.split(",")]
            elif left == "include response body":
                params["include_body"] = right.strip().lower() == "true"

        # Start/stop handling
        if params["mode"] == "start":
            selenium_driver.get_log("performance")
            CommonUtil.ExecLog(sModuleInfo, "Started collecting network logs...", 1)
            return "passed"

        if params["mode"] == "stop":
            EXCLUDED_EXTENSIONS = {
                ".js",
                ".css",
                ".png",
                ".jpg",
                ".jpeg",
                ".gif",
                ".svg",
                ".ico",
                ".woff",
                ".woff2",
                ".ttf",
                ".eot",
                ".webp",
                ".map",
                ".txt",
            }
            EXCLUDED_MIME_PREFIXES = {
                "image/",
                "font/",
                "text/css",
                "application/javascript",
                "text/javascript",
                "application/font-",
                "application/x-font-",
            }

            browser_log = selenium_driver.get_log("performance")
            api_logs = []
            requests = {}

            for entry in browser_log:
                try:
                    outer = json.loads(entry["message"])
                    message_data = outer.get("message", {})
                    method = message_data.get("method")
                    log_params = message_data.get("params", {})
                    request_id = log_params.get("requestId")

                    if method == "Network.requestWillBeSent":
                        requests[request_id] = log_params.get("request", {})

                    elif method == "Network.responseReceived":
                        response = log_params.get("response", {})
                        url = response.get("url", "")
                        mime_type = response.get("mimeType", "")
                        status = response.get("status", 0)

                        # Skip static resources
                        if any(url.endswith(ext) for ext in EXCLUDED_EXTENSIONS):
                            continue
                        if any(
                            mime_type.startswith(prefix)
                            for prefix in EXCLUDED_MIME_PREFIXES
                        ):
                            continue

                        request = requests.get(request_id, {})

                        # Apply filters
                        if params["filter_domains"]:
                            domain = urlparse(url).netloc
                            if not any(d in domain for d in params["filter_domains"]):
                                continue

                        if params["method_filter"]:
                            request_method = request.get("method", "").upper()
                            if request_method not in params["method_filter"]:
                                continue

                        if params["status_filter"]:
                            if status not in params["status_filter"]:
                                continue

                        # Build log entry
                        log_entry = {
                            "url": url,
                            "status": status,
                            "method": request.get("method", ""),
                            "mimeType": mime_type,
                            "type": log_params.get("type", ""),
                            "timestamp": entry.get("timestamp"),
                        }

                        # Add response body if requested
                        if params["include_body"]:
                            try:
                                body = selenium_driver.execute_cdp_cmd(
                                    "Network.getResponseBody", {"requestId": request_id}
                                )
                                log_entry["body"] = body.get("body", "Unavailable")
                            except:
                                log_entry["body"] = "Unavailable"

                        api_logs.append(log_entry)

                except Exception as e:
                    err = f"Error processing log entry: {str(e)}"
                    CommonUtil.ExecLog(sModuleInfo, err, 3)
                    continue

            # Save results
            if params["variable_name"]:
                Shared_Resources.Set_Shared_Variables(params["variable_name"], api_logs)
                CommonUtil.ExecLog(
                    sModuleInfo,
                    f"Saved {len(api_logs)} network events to '{params['variable_name']}'",
                    1,
                )
            return "passed"

    except Exception:
        errMsg = "Could not collect network logs. Ensure performance logging is enabled in browser options"
        return CommonUtil.Exception_Handler(sys.exc_info(), None, errMsg)


# Method to enter texts in a text box; step data passed on by the user
@logger
def Enter_Text_In_Text_Box(step_data):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    try:
        delay = 0
        text_value = ""
        use_js = False
        clear = True
        global selenium_driver
        Element = LocateElement.Get_Element(step_data, selenium_driver)
        if Element == "zeuz_failed":
            CommonUtil.ExecLog(
                sModuleInfo, "Unable to locate your element with given data.", 3
            )
            return "zeuz_failed"
        for left, mid, right in step_data:
            mid = mid.strip().lower()
            left = left.strip().lower()
            if mid == "action":
                text_value = right
            elif left == "delay":
                delay = float(right.strip())
            elif left == "use js":
                use_js = right.strip().lower() in ("true", "yes", "1")
            elif left == "clear":
                clear = False if right.strip().lower() in ("no", "false") else True
        if use_js:  # Use js will automatically clear the field and then enter text
            try:
                selenium_driver.execute_script("arguments[0].click();", Element)
            except:
                CommonUtil.ExecLog(
                    sModuleInfo, "Entering text without clicking the element", 2
                )
            # Fill up the value.
            selenium_driver.execute_script(
                f"arguments[0].value = `{text_value}`;", Element
            )
            # Trigger change events
            # - input: Fired when the value of the text field changes (after each keystroke, paste, etc.).
            # - change: Fired when the value of the text field changes and the element loses focus.
            selenium_driver.execute_script(
                "arguments[0].dispatchEvent(new Event('input', {'bubbles': true}))",
                Element,
            )
            selenium_driver.execute_script(
                "arguments[0].dispatchEvent(new Event('change', {'bubbles': true}))",
                Element,
            )
            # Sometimes text field becomes unclickable after entering text?
            selenium_driver.execute_script("arguments[0].click();", Element)
        else:
            try:
                Element = handle_clickability_and_click(step_data, Element)
            except:
                CommonUtil.ExecLog(
                    sModuleInfo, "Entering text without clicking the element", 2
                )
            if clear:
                # Element.clear()
                # Safari Keys are extremely slow and not working
                if selenium_driver.capabilities["browserName"] == "Safari":
                    Element.clear()
                else:
                    if sys.platform == "darwin":
                        Element.send_keys(Keys.COMMAND, "a")
                    else:
                        Element.send_keys(Keys.CONTROL, "a")
                    Element.send_keys(Keys.DELETE)
                    try:
                        Element.clear()  # some cases it works .. so adding it here just incase
                    except:
                        pass
            if delay == 0:
                Element.send_keys(text_value)
            else:
                for c in text_value:
                    Element.send_keys(c)
                    time.sleep(delay)
            try:
                Element.click()
            except:  # sometimes text field can be unclickable after entering text
                pass
        CommonUtil.ExecLog(
            sModuleInfo, "Successfully set the value of to text to: %s" % text_value, 1
        )
        return "passed"
    except Exception:
        errMsg = "Could not select/click your element."
        return CommonUtil.Exception_Handler(sys.exc_info(), None, errMsg)


@logger
def Keystroke_For_Element(data_set):
    """Send a key stroke or string to an element or wherever the cursor is located"""
    # Keystroke Keys: Any key. Eg: Tab, Escape, etc
    # Keystroke Chars: Any string. Eg: The quick brown...
    # If no element parameter is provided, it will enter the keystroke wherever the cursor is located

    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    # Parse the data set
    try:
        stype = ""  # keys/chars
        paste_image = False # identifiying image paste
        get_element = False  # Use element
        key_count = 1  # Default number of button presses
        for row in data_set:
            if row[1] == "action":
                if row[0] == "keystroke keys":  # Keypress
                    stype = "keys"
                    keystroke_value = row[2]
                    if "," in keystroke_value:  # If user supplied a number of presses
                        keystroke_value.replace(" ", "")
                        keystroke_value, key_count = keystroke_value.split(
                            ","
                        )  # Save keypress and count
                        key_count = int(key_count)
                elif row[0] == "keystroke chars":  # String
                    stype = "chars"
                    keystroke_value = row[2]
            elif row[1] == "element parameter":
                get_element = True
            elif row[1] == "optional parameter":
                if row[0] == "paste image":
                    paste_image = row[2].strip().lower() == "true"

        if stype == "":
            CommonUtil.ExecLog(sModuleInfo, "Field contains incorrect data", 3)
            return "zeuz_failed"

    except:
        return CommonUtil.Exception_Handler(
            sys.exc_info(), None, "Error parsing data set"
        )

    # Get the element, or if none provided, create action chains for keystroke insertion without an element
    if get_element:
        Element = LocateElement.Get_Element(data_set, selenium_driver)
        if Element in failed_tag_list:
            CommonUtil.ExecLog(sModuleInfo, "Failed to locate element", 3)
            return "zeuz_failed"
    else:
        Element = ActionChains(selenium_driver)

    # Insert keystroke
    try:
        if stype == "keys":
            keystroke_value = keystroke_value.upper()
            convert = {
                "CTRL": "CONTROL",
                "PLUS": "ADD",
                "MINUS": "SUBTRACT",
                "DASH": "SUBTRACT",
                "CMD": "COMMAND",
            }
            for key in convert:
                keystroke_value = keystroke_value.replace(key, convert[key])

            # Special handling for paste command (Ctrl+V / Command+V)
            normalized_keystroke = (
                keystroke_value.replace(" ", "").replace("_", "").lower()
            )
            if normalized_keystroke in (
                "ctrl+v",
                "control+v",
                "ctrlv",
                "controlv",
                "cmd+v",
                "cmdv",
                "command+v",
                "commandv",
            ):
                capabilities = selenium_driver.capabilities
                platform_name = capabilities.get("platformName", "").lower()
                browser_name = capabilities.get("browserName", "").lower()

                if "mac" in platform_name or "os x" in platform_name:
                    paste_key = Keys.COMMAND
                elif platform.system().lower() in ("darwin", "macos"):
                    paste_key = Keys.COMMAND
                else:
                    paste_key = Keys.CONTROL

                if browser_name == "firefox" and (
                    "linux" in platform_name or platform.system().lower() == "linux"
                ):
                    paste_key = Keys.CONTROL

                if paste_image:
                    try:
                        if get_element:
                            selenium_driver.execute_script("arguments[0].focus();", Element)
                            time.sleep(0.1)

                            # Perform paste using ActionChains
                            actions = ActionChains(selenium_driver)
                            actions.key_down(paste_key, element=Element)
                            actions.send_keys_to_element(Element, "v")
                            actions.key_up(paste_key, element=Element)
                            actions.perform()
                        else:
                            actions = ActionChains(selenium_driver)
                            actions.key_down(paste_key)
                            actions.send_keys("v")
                            actions.key_up(paste_key)
                            actions.perform()

                        CommonUtil.ExecLog(
                            sModuleInfo, "Copied image is successfully pasted", 1
                        )
                        return "passed"
                    except Exception as e:
                        # Fallback to JavaScript if ActionChains fails
                        try:
                            CommonUtil.ExecLog(
                                sModuleInfo,
                                f"Standard paste failed. Trying JavaScript fallback...",
                                2,
                            )
                            if get_element:
                                selenium_driver.execute_script(
                                    "arguments[0].focus();", Element
                                )
                                selenium_driver.execute_script(
                                    "arguments[0].value = arguments[1];",
                                    Element,
                                    pyperclip.paste(),
                                )
                            else:
                                selenium_driver.execute_script(
                                    f"document.activeElement.value += '{pyperclip.paste()}';"
                                )
                            CommonUtil.ExecLog(
                                sModuleInfo, "Successfully image paste executed via JavaScript fallback", 1
                            )
                            return "passed"
                        except Exception as js_e:
                            return CommonUtil.Exception_Handler(
                                sys.exc_info(),
                                None,
                                f"Both methods failed for paste the image: {str(js_e)}",
                            )
                else:
                    # simple text paste
                    try:
                        if get_element:
                            selenium_driver.execute_script(
                                "arguments[0].focus();", Element
                            )
                            selenium_driver.execute_script(
                                "arguments[0].value = arguments[1];",
                                Element,
                                pyperclip.paste(),
                            )
                        else:
                            selenium_driver.execute_script(
                                f"document.activeElement.value += '{pyperclip.paste()}';"
                            )
                        CommonUtil.ExecLog(
                            sModuleInfo, "Paste successfully executed via JavaScript", 1
                        )
                        return "passed"
                    except Exception as js_e:
                        CommonUtil.ExecLog(
                            sModuleInfo, "JavaScript paste execution failed. Trying keypress...", 3
                        )

            elif "+" in keystroke_value:
                hotkey_list = keystroke_value.split("+")
                for i in range(len(hotkey_list)):
                    if hotkey_list[i] in list(dict(Keys.__dict__).keys())[2:-2]:
                        Element.key_down(getattr(Keys, hotkey_list[i]))
                    else:
                        Element.key_down(hotkey_list[i])
                for i in range(len(hotkey_list)).__reversed__():
                    if hotkey_list[i] in list(dict(Keys.__dict__).keys())[2:-2]:
                        Element.key_up(getattr(Keys, hotkey_list[i]))
                    else:
                        Element.key_up(hotkey_list[i])
                Element.perform()
                result = "passed"

            else:
                get_keystroke_value = getattr(
                    Keys, keystroke_value
                )  # Create an object for the keystroke
                result = Element.send_keys(
                    get_keystroke_value * key_count
                )  # Prepare keystroke for sending if Actions, or send if Element
                if not get_element:
                    Element.perform()  # Send keystroke
        else:
            result = Element.send_keys(keystroke_value)
            if not get_element:
                Element.perform()
    except:
        return CommonUtil.Exception_Handler(
            sys.exc_info(),
            None,
            "Error sending keystroke %s: %s" % (stype, keystroke_value),
        )

    # Test result
    if result not in failed_tag_list:
        CommonUtil.ExecLog(
            sModuleInfo,
            "Successfully sent %s: %s %d times" % (stype, keystroke_value, key_count),
            1,
        )
        return "passed"
    else:
        CommonUtil.ExecLog(
            sModuleInfo,
            "Error sending keystroke %s: %s %d times"
            % (stype, keystroke_value, key_count),
            3,
        )
        return "zeuz_failed"


@logger
def execute_javascript(data_set):
    """Executes the JavaScript code.

    Args:
        data_set:
          id/class/etc       | element parameter  | button_id     ; optional row
          variable           | optional parameter | var_name      ; store result into variable
          execute javascript | selenium action    | js_code_here  ; example: $elem.click();

    Returns:
        "passed" if the given script execution is successful.
        "zeuz_failed" otherwise.
    """

    try:
        Element = False
        var_name = None
        script_to_exec = None

        for left, mid, right in data_set:
            left = left.lower().strip()
            mid = mid.lower().strip()
            right = right.strip()

            if "element parameter" in mid:
                Element = True
            if "variable" == left:
                var_name = right
            if "javascript" in left:
                script_to_exec = right

        # Element parameter is provided to use Zeuz Node's element finding approach.
        if Element:
            Element = LocateElement.Get_Element(data_set, selenium_driver)
            # Replace "$elem" with "arguments[0]". For convenience only.
            script_to_exec = script_to_exec.replace("$elem", "arguments[0]")
            # Execute the script.
            result = selenium_driver.execute_script(script_to_exec, Element)
        else:
            result = selenium_driver.execute_script(script_to_exec, None)

        if var_name:
            return Shared_Resources.Set_Shared_Variables(var_name, result)
        else:
            return "passed"
    except Exception:
        errMsg = "Make sure element parameter is provided in the action."
        return CommonUtil.Exception_Handler(sys.exc_info(), None, errMsg)


def handle_clickability_and_click(
    dataset, Element: selenium.webdriver.remote.webelement.WebElement
):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    wait_clickable = Shared_Resources.Get_Shared_Variables("element_wait")
    # for left, mid, right in dataset:
    #     if mid.strip().lower() == "option":
    #         left = left.strip().lower()
    #         if "wait" in left and "clickable" in left:
    #             wait_clickable = int(right.strip())
    # if not wait_clickable:
    #     Element.click()     # no need of try except here. we need to return the exact exception upto this point
    # else:
    log_flag = True
    log_flag2 = True
    first = True
    start = time.perf_counter()
    stale_i = 0
    while True:
        try:
            Element.click()
            if not first:
                CommonUtil.ExecLog(
                    sModuleInfo,
                    "Element has become clickable after %s seconds"
                    % round(time.perf_counter() - start, 2),
                    2,
                )
            return Element
        except ElementClickInterceptedException:
            first = False
            if log_flag:
                CommonUtil.ExecLog(
                    sModuleInfo,
                    "Click is Intercepted. Waiting %s seconds max for the element to become clickable"
                    % wait_clickable,
                    2,
                )
                log_flag = False
        except StaleElementReferenceException:
            first = False
            if log_flag2:
                CommonUtil.ExecLog(
                    sModuleInfo,
                    "Element is stale. Waiting %s seconds max for the element to become clickable"
                    % wait_clickable,
                    2,
                )
                log_flag2 = False
            Element = LocateElement.Get_Element(
                dataset, selenium_driver
            )  # Element may need to be relocated in stale
            if stale_i == 0:
                stale_i += 1
                continue
        if time.perf_counter() > start + wait_clickable:
            raise Exception  # not StaleElementReferenceException. we don't want js to perform click


# Method to click on element; step data passed on by the user
@logger
def Click_Element(data_set, retry=0):
    """Click using element or location"""
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    use_js = False  # Use js to click on element?
    try:
        location = ""
        for row in data_set:
            if row[0] == "offset" and row[1] == "optional parameter":
                location = row[
                    2
                ]  # Save shared variable name, or coordinates if entered directory in step data
            if "use js" in row[0].lower():
                use_js = row[2].strip().lower() in ("true", "yes", "1")
    except Exception:
        return CommonUtil.Exception_Handler(
            sys.exc_info(), None, "Error parsing data set"
        )

    Element = LocateElement.Get_Element(data_set, selenium_driver)
    if Element in failed_tag_list:
        CommonUtil.ExecLog(sModuleInfo, "Could not find element", 3)
        return "zeuz_failed"
    if location == "":
        try:
            if use_js:
                # Click on element.
                selenium_driver.execute_script("arguments[0].click();", Element)
            else:
                handle_clickability_and_click(data_set, Element)

            CommonUtil.ExecLog(sModuleInfo, "Successfully clicked the element", 1)
            return "passed"

        except ElementClickInterceptedException:
            try:
                selenium_driver.execute_script("arguments[0].click();", Element)
                CommonUtil.ExecLog(
                    sModuleInfo,
                    "Your element is overlapped with another sibling element. Clicked the element successfully by executing JavaScript",
                    2,
                )
                return "passed"
            except Exception:
                try:
                    element_attributes = Element.get_attribute("outerHTML")
                    CommonUtil.ExecLog(
                        sModuleInfo, "Element Attributes: %s" % (element_attributes), 3
                    )
                    errMsg = "Could not click and hold your element."
                    return CommonUtil.Exception_Handler(sys.exc_info(), None, errMsg)
                except:
                    return CommonUtil.Exception_Handler(sys.exc_info())
        except StaleElementReferenceException:
            if retry == 5:
                CommonUtil.ExecLog(
                    sModuleInfo,
                    "Could not perform click because javascript of the element is not fully loaded",
                    3,
                )
                return "zeuz_failed"
            CommonUtil.ExecLog(
                "",
                "Javascript of the element is not fully loaded. Trying again after 1 second delay",
                2,
            )
            time.sleep(1)
            return Click_Element(data_set, retry + 1)

        except Exception:
            try:
                element_attributes = Element.get_attribute("outerHTML")
                CommonUtil.ExecLog(
                    sModuleInfo, "Element Attributes: %s" % (element_attributes), 3
                )
                errMsg = "Could not click and hold your element."
                return CommonUtil.Exception_Handler(sys.exc_info(), None, errMsg)
            except:
                return CommonUtil.Exception_Handler(sys.exc_info())

    # Click using location
    else:
        try:
            total_x_offset, total_y_offset = get_offsets(location, Element)
            actions = ActionChains(selenium_driver)  # Create actions object
            actions.move_to_element_with_offset(
                Element, total_x_offset, total_y_offset
            )  # Move to coordinates (referrenced by body at 0,0)
            actions.click()  # Click action
            actions.perform()  # Perform all actions
            CommonUtil.ExecLog(sModuleInfo, "Click on location successful", 1)
            return "passed"
        except Exception:
            return CommonUtil.Exception_Handler(
                sys.exc_info(), None, "Error clicking location"
            )


@logger
def Click_and_Download(data_set):
    """Click and download attachments from web and save it to specific destinations"""
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver

    if selenium_driver.capabilities["browserName"].strip().lower() not in (
        "chrome",
        "microsoftedge",
        "firefox",
    ):
        CommonUtil.ExecLog(
            sModuleInfo,
            "This action was made for Chrome, MS Edge and Firefox. Other browsers won't download files in Zeuz_Download_Folder",
            2,
        )

    # Todo:
    # 1. For other browsers than ("chrome", "msedge", "firefox") copy the New files generated in Downloads directory and move them to zeuz_download_folder

    wait_download = 20
    filepath = ""
    automate_firefox = False
    try:
        click_dataset = []
        for left, mid, right in data_set:
            l = left.replace(" ", "").replace("_", "").lower()
            if l == "waitfordownload":
                wait_download = float(right.strip())
            elif l in (
                "folderpath",
                "directory",
                "filepath",
                "file",
                "folder",
            ) and mid.strip().lower() in ("optional parameter"):
                filepath = right.strip()
                filepath = CommonUtil.path_parser(filepath)
            elif l == "automatefirefoxsavewindow" and mid.strip().lower() in (
                "optional parameter"
            ):
                automate_firefox = right.strip().lower() in (
                    "accept",
                    "yes",
                    "ok",
                    "true",
                )
            else:
                click_dataset.append((left, mid, right))

            # On next improvement user will have option to tell the filename and only that filename will be copied from
            # the initial download directory
    except Exception:
        return CommonUtil.Exception_Handler(
            sys.exc_info(), None, "Error parsing data set"
        )

    try:
        if Click_Element(click_dataset) == "zeuz_failed":
            return "zeuz_failed"
        if (
            selenium_driver.capabilities["browserName"].strip().lower() == "firefox"
            and automate_firefox
        ):
            if platform.system() == "Windows":
                try:
                    from Framework.Built_In_Automation.Desktop.Windows.BuiltInFunctions import (
                        Click_Element as win_Click_Element,
                        wait_for_element,
                    )

                    pid = str(selenium_driver.capabilities["moz:processID"])
                    window_ds = ("window pid", "element parameter", pid)
                    wait_ds = [
                        window_ds,
                        ("Name", "element parameter", "Save File"),
                        ("LocalizedControlType", "element parameter", "radio button"),
                        ("wait to appear", "windows action", "10"),
                    ]
                    CommonUtil.ExecLog(
                        sModuleInfo, "Checking if any Save window is opened", 1
                    )
                    if wait_for_element(wait_ds) == "zeuz_failed":
                        CommonUtil.ExecLog(
                            sModuleInfo, "No Save window is found. Continuing...", 1
                        )
                    else:
                        save_click_ds = [
                            window_ds,
                            ("Name", "element parameter", "Save File"),
                            (
                                "LocalizedControlType",
                                "element parameter",
                                "radio button",
                            ),
                            ("click", "windows action", "click"),
                        ]
                        if win_Click_Element(save_click_ds) == "zeuz_failed":
                            CommonUtil.ExecLog(
                                sModuleInfo,
                                "Could not click Save Button. Switching to GUI method",
                                2,
                            )
                            import pyautogui

                            pyautogui.hotkey("down")
                            pyautogui.hotkey("enter")

                        else:
                            # remember_choice_ds = [
                            #     window_ds,
                            #     ("wait", "optional parameter", "5"),
                            #     ("*Name", "element parameter", "Do this automatically"),
                            #     ("LocalizedControlType", "element parameter", "check box"),
                            #     ("click", "windows action", "click"),
                            # ]
                            # if win_Click_Element(remember_choice_ds) == "zeuz_failed":
                            #     CommonUtil.ExecLog(sModuleInfo, "Could not click remember choice Button", 2)
                            ok_ds = [
                                window_ds,
                                ("Name", "element parameter", "OK"),
                                ("LocalizedControlType", "element parameter", "button"),
                                ("click", "windows action", "click"),
                            ]
                            if win_Click_Element(ok_ds) == "zeuz_failed":
                                CommonUtil.ExecLog(
                                    sModuleInfo,
                                    "Could not find the OK button. Switching to GUI method (pressing Enter)",
                                    2,
                                )
                                import pyautogui

                                pyautogui.hotkey("enter")
                except:
                    CommonUtil.ExecLog(
                        sModuleInfo,
                        "Could not check if any save window was opened. Continuing...",
                        2,
                    )

            else:
                # Todo: Test this on Mac and Linux
                import pyautogui

                pyautogui.hotkey("down")
                pyautogui.hotkey("enter")

        if selenium_driver.capabilities["browserName"].strip().lower() in (
            "chrome",
            "microsoftedge",
            "firefox",
        ):
            CommonUtil.ExecLog(
                sModuleInfo,
                "Download started. Will wait max %s seconds..." % wait_download,
                1,
            )
            s = time.perf_counter()
            if selenium_driver.capabilities["browserName"].strip().lower() == "firefox":
                ext = ".part"
            elif selenium_driver.capabilities["browserName"].strip().lower() == "opera":
                ext = ".opera"
            else:
                ext = ".crdownload"
            e = 0
            while True:
                try:
                    ld = os.listdir(initial_download_folder)
                    if all(
                        [
                            len(ld) > 0,
                            all(
                                [
                                    not i.endswith(".tmp") and not i.endswith(ext)
                                    for i in ld
                                ]
                            ),
                        ]
                    ):
                        CommonUtil.ExecLog(
                            sModuleInfo,
                            "Download Finished in %s seconds"
                            % round(time.perf_counter() - s, 2),
                            1,
                        )
                        break
                    if s + wait_download < time.perf_counter():
                        CommonUtil.ExecLog(
                            sModuleInfo,
                            "Could not finish download within %s seconds. You can increase the amount of seconds with (wait for download, optional parameter, 60)"
                            % wait_download,
                            2,
                        )
                        break
                except:
                    CommonUtil.Exception_Handler(sys.exc_info())
                    time.sleep(2)
                    e += 1
                    if e == 3:
                        break
        else:
            time.sleep(2)
        time.sleep(3)

        if filepath:
            # filepath = Shared_Resources.Get_Shared_Variables("zeuz_download_folder")
            source_folder = initial_download_folder
            all_source_dir = [
                os.path.join(source_folder, f)
                for f in os.listdir(source_folder)
                if os.path.isfile(os.path.join(source_folder, f))
            ]
            new_path = filepath
            for file_to_be_moved in all_source_dir:
                file_name = Path(file_to_be_moved).name
                if "." not in os.path.basename(new_path) and not os.path.exists(
                    new_path
                ):
                    # if the path is a directory and does not exist then create the directory
                    Path(new_path).mkdir(parents=True, exist_ok=True)
                elif "." in os.path.basename(new_path) and not os.path.exists(new_path):
                    # if the path is a filepath and the directory does not exist then create the directory
                    Path(os.path.dirname(new_path)).mkdir(parents=True, exist_ok=True)
                shutil.move(file_to_be_moved, new_path)

                # after performing shutil.move() we have to check that if the file with new name exists in correct location.
                # if the file exists in correct position then return passed
                # if the file doesn't exist in correct position then return failed
                if "." not in os.path.basename(new_path):
                    file_path_for_check_after_move = os.path.join(new_path, file_name)
                    if os.path.isfile(file_path_for_check_after_move):
                        CommonUtil.ExecLog(
                            sModuleInfo,
                            "File '%s' is moved to '%s'"
                            % (file_name, file_path_for_check_after_move),
                            1,
                        )
                    else:
                        CommonUtil.ExecLog(sModuleInfo, "File failed to move", 3)
                        return "zeuz_failed"
                else:
                    if os.path.isfile(new_path):
                        CommonUtil.ExecLog(
                            sModuleInfo,
                            "File '%s' is moved to '%s'" % (file_name, new_path),
                            1,
                        )
                    else:
                        CommonUtil.ExecLog(sModuleInfo, "File failed to move", 3)
                        return "zeuz_failed"
        return "passed"
    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


# Method to right click on element; step data passed on by the user
@logger
def Right_Click_Element(step_data):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        Element = LocateElement.Get_Element(step_data, selenium_driver)
        if Element != "zeuz_failed":
            try:
                context_click = ActionChains(selenium_driver).context_click(Element)
                context_click.perform()
                CommonUtil.ExecLog(
                    sModuleInfo,
                    "Successfully right clicked the element with given parameters and values",
                    1,
                )
                return "passed"
            except Exception:
                try:
                    element_attributes = Element.get_attribute("outerHTML")
                    CommonUtil.ExecLog(
                        sModuleInfo, "Element Attributes: %s" % (element_attributes), 3
                    )
                    errMsg = "Could not click and hold your element."
                    return CommonUtil.Exception_Handler(sys.exc_info(), None, errMsg)
                except:
                    return CommonUtil.Exception_Handler(sys.exc_info())
        else:
            CommonUtil.ExecLog(
                sModuleInfo, "Unable to locate your element with given data.", 3
            )
            return "zeuz_failed"
    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


# Method to double click on element; step data passed on by the user
@logger
def Double_Click_Element(step_data):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        Element = LocateElement.Get_Element(step_data, selenium_driver)
        if Element != "zeuz_failed":
            try:
                double_click = ActionChains(selenium_driver).double_click(Element)
                double_click.perform()
                CommonUtil.ExecLog(
                    sModuleInfo,
                    "Successfully double clicked the element with given parameters and values",
                    1,
                )
                return "passed"
            except Exception:
                try:
                    element_attributes = Element.get_attribute("outerHTML")
                    CommonUtil.ExecLog(
                        sModuleInfo, "Element Attributes: %s" % (element_attributes), 3
                    )
                    errMsg = "Could not click and hold your element."
                    return CommonUtil.Exception_Handler(sys.exc_info(), None, errMsg)
                except:
                    return CommonUtil.Exception_Handler(sys.exc_info())
        else:
            CommonUtil.ExecLog(
                sModuleInfo, "Unable to locate your element with given data.", 3
            )
            return "zeuz_failed"
    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


# Method to hover over element; step data passed on by the user
@logger
def Hover_Over_Element(step_data):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        Element = LocateElement.Get_Element(step_data, selenium_driver)
        if Element != "zeuz_failed":
            try:
                hov = ActionChains(selenium_driver).move_to_element(Element)
                hov.perform()
                CommonUtil.ExecLog(
                    sModuleInfo,
                    "Successfully hovered over the element with given parameters and values",
                    1,
                )
                return "passed"
            except Exception:
                try:
                    element_attributes = Element.get_attribute("outerHTML")
                    CommonUtil.ExecLog(
                        sModuleInfo, "Element Attributes: %s" % (element_attributes), 3
                    )
                    errMsg = "Could not select/hover your element."
                    return CommonUtil.Exception_Handler(sys.exc_info(), None, errMsg)
                except:
                    return CommonUtil.Exception_Handler(sys.exc_info())
        else:
            CommonUtil.ExecLog(
                sModuleInfo, "Unable to locate your element with given data.", 3
            )
            return "zeuz_failed"
    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


@logger
def get_element_info(dataset):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        variable_name = None
        new_ds = []
        for each_step_data_item in dataset:
            if "action" == each_step_data_item[1].strip().lower():
                variable_name = each_step_data_item[2].strip()
            else:
                new_ds.append(each_step_data_item)

        if variable_name is None:
            CommonUtil.ExecLog(
                sModuleInfo,
                "Variable name should be mentioned. Example: (text, save parameter, var_name)",
                3,
            )
            return "zeuz_failed"

        Element = LocateElement.Get_Element(new_ds, selenium_driver)
        if Element == "zeuz_failed":
            CommonUtil.ExecLog(
                sModuleInfo, "Unable to locate your element with given data.", 3
            )
            return "zeuz_failed"
        else:
            Shared_Resources.Set_Shared_Variables(
                variable_name, {"size": Element.size, "location": Element.location}
            )
            return "passed"
    except Exception as e:
        CommonUtil.ExecLog(sModuleInfo, e, 3)
        return "zeuz_failed"


@logger
def Save_Attribute(step_data):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        variable_name = None
        new_ds = []
        for each_step_data_item in step_data:
            if "save parameter" == each_step_data_item[1].strip().lower():
                variable_name = each_step_data_item[2].strip()
                attribute_name = each_step_data_item[0].strip().lower()
            else:
                new_ds.append(each_step_data_item)

        if variable_name is None:
            CommonUtil.ExecLog(
                sModuleInfo,
                "Variable name should be mentioned. Example: (text, save parameter, var_name)",
                3,
            )
            return "zeuz_failed"

        Element = LocateElement.Get_Element(new_ds, selenium_driver)
        if Element == "zeuz_failed":
            CommonUtil.ExecLog(
                sModuleInfo, "Unable to locate your element with given data.", 3
            )
            return "zeuz_failed"

        elif attribute_name == "text":
            attribute_value = Element.text
        elif attribute_name == "tag":
            attribute_value = Element.tag_name
        elif attribute_name == "checked":
            attribute_value = Element.is_selected()
        else:
            attribute_value = Element.get_attribute(attribute_name)

        result = Shared_Resources.Set_Shared_Variables(variable_name, attribute_value)
        if result in failed_tag_list:
            CommonUtil.ExecLog(
                sModuleInfo,
                "Value of Variable '%s' could not be saved!!!" % variable_name,
                3,
            )
            return "zeuz_failed"
        else:
            return "passed"
    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


@logger
def save_attribute_values_in_list(step_data):
    """
    This action will expect users to provide a parent element under which they are expecting
    to collect multiple objects.  Users can provide certain constrain to search their elements
    Sample data:

    aria-label                       element parameter      Calendar

    attributes                       target parameter       data-automation="productItemName",
                                                            class="S58f2saa25a3w1",
                                                            return="text",
                                                            return_contains="128GB",
                                                            return_does_not_contain="Windows 10",
                                                            return_does_not_contain="Linux"

    attributes                       target parameter       class="productPricingContainer_3gTS3",
                                                            return="text",
                                                            return_does_not_contain="99.99"

    save attribute values in list    selenium action        list_name

    """
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        # this is the parent object.  If the user wants to search the entire page, they can
        # provide tag = html
        Element = LocateElement.Get_Element(step_data, selenium_driver)
        if Element == "zeuz_failed":
            CommonUtil.ExecLog(
                sModuleInfo, "Unable to locate your element with given data.", 3
            )
            return "zeuz_failed"

        all_elements = []
        target_index = 0
        target = []
        paired = True

        try:
            for left, mid, right in step_data:
                left = left.strip().lower()
                mid = mid.strip().lower()
                right = right.strip()
                if "target parameter" in mid:
                    target.append([[], [], [], []])
                    temp = right.strip(",").split(",\n")
                    data = []
                    for each in temp:
                        data.append(each.strip().split("=", 1))
                    for i in range(len(data)):
                        for j in range(len(data[i])):
                            data[i][j] = data[i][j].strip()
                            if j == 1:
                                data[i][j] = CommonUtil.strip1(
                                    data[i][j], '"'
                                )  # dont add another strip here. dont need to strip inside quotation mark

                    for Left, Right in data:
                        if Left == "return":
                            target[target_index][1] = Right
                        elif Left == "return_contains":
                            target[target_index][2].append(Right)
                        elif Left == "return_does_not_contain":
                            target[target_index][3].append(Right)
                        elif Left.replace(" ", "").replace("_", "") in (
                            "allowhidden",
                            "allowdisable",
                        ):
                            target[target_index][0].append(
                                ("allow hidden", "optional parameter", Right)
                            )
                        else:
                            target[target_index][0].append(
                                (Left, "element parameter", Right)
                            )

                    target_index = target_index + 1
                elif left == "save attribute values in list":
                    variable_name = right
                elif left == "paired":
                    paired = False if right.lower() == "no" else True

        except:
            CommonUtil.ExecLog(
                sModuleInfo,
                "Unable to parse data. Please write data in correct format",
                3,
            )
            return "zeuz_failed"

        for each in target:
            all_elements.append(
                LocateElement.Get_Element(each[0], Element, return_all_elements=True)
            )

        variable_value_size = 0
        for each in all_elements:
            variable_value_size = max(variable_value_size, len(each))

        variable_value = []
        for i in range(variable_value_size):
            variable_value.append([])

        i = 0
        for each in all_elements:
            search_by_attribute = target[i][1]
            j = 0
            for elem in each:
                if search_by_attribute == "text":
                    Attribute_value = elem.text
                elif search_by_attribute == "tag":
                    Attribute_value = elem.tag_name
                elif search_by_attribute == "checked":
                    Attribute_value = str(elem.is_selected())
                else:
                    Attribute_value = elem.get_attribute(search_by_attribute)
                try:
                    for search_contain in target[i][2]:
                        if (
                            not isinstance(search_contain, type(Attribute_value))
                            or search_contain in Attribute_value
                            or len(search_contain) == 0
                        ):
                            break
                    else:
                        if target[i][2]:
                            Attribute_value = None

                    for search_doesnt_contain in target[i][3]:
                        if (
                            isinstance(search_doesnt_contain, type(Attribute_value))
                            and search_doesnt_contain in Attribute_value
                            and len(search_doesnt_contain) != 0
                        ):
                            Attribute_value = None
                except:
                    CommonUtil.ExecLog(
                        sModuleInfo,
                        "Couldn't search by return_contains and return_does_not_contain",
                        2,
                    )
                variable_value[j].append(Attribute_value)
                j = j + 1
            i = i + 1
        if target_index == 1:
            variable_value = list(map(list, zip(*variable_value)))[0]
        elif not paired:
            variable_value = list(map(list, zip(*variable_value)))

        return Shared_Resources.Set_Shared_Variables(variable_name, variable_value)

    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


@logger
def Extract_Table_Data(step_data):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        Element = LocateElement.Get_Element(step_data, selenium_driver)
        if Element == "zeuz_failed":
            CommonUtil.ExecLog(
                sModuleInfo, "Unable to locate your element with given data.", 3
            )
            return "zeuz_failed"
        if Element.tag_name != "tbody":
            CommonUtil.ExecLog(sModuleInfo, 'Tag name of the Element is not "tbody"', 2)
        _row = ""
        _column = ""
        try:
            for left, mid, right in step_data:
                left = left.strip().lower()
                right = right.strip()
                mid = mid.strip().lower()
                if left == "extract table data":
                    variable_name = right
                elif "row" in left and mid == "optional parameter":
                    _row = right.replace(" ", "")
                elif "column" in left and mid == "optional parameter":
                    _column = right.replace(" ", "")

        except:
            CommonUtil.ExecLog(
                sModuleInfo,
                "Unable to parse data. Please write data in correct format",
                3,
            )
            return "zeuz_failed"

        variable_value = []
        all_tr = Element.find_elements("tag name", "tr")
        for row in all_tr:
            all_td = row.find_elements("tag name", "td")
            td_data = []
            for td in all_td:
                text_data = td.get_property("textContent").strip()
                td_data.append(text_data)
            variable_value.append(td_data)
        if _row and "," not in _row and "-" not in _row:
            try:
                int(_row)
                variable_value = [variable_value[int(_row)]]
            except:
                variable_value = eval("variable_value[%s]" % _row)
        if _column and "," not in _column and "-" not in _column:
            try:
                int(_column)
                variable_value = [[i[int(_column)]] for i in variable_value]
            except:
                variable_value = [eval("i[%s]" % _column) for i in variable_value]

        return Shared_Resources.Set_Shared_Variables(variable_name, variable_value)

    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


@logger
def save_web_elements_in_list(step_data):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        has_element = False
        all_elements = []
        target_index = 0
        target = []
        # paired = True
        try:
            for left, mid, right in step_data:
                left = left.strip().lower()
                mid = mid.strip().lower()
                right = right.strip()
                if not has_element and mid in (
                    "element parameter",
                    "parent parameter",
                    "unique parameter",
                    "child parameter",
                    "sibling parameter",
                ):
                    has_element = True
                elif "target parameter" in mid:
                    target.append([[], [], [], []])
                    temp = right.strip(",").split(",")
                    data = []
                    for each in temp:
                        if each.strip("\n").startswith("return_contains"):
                            data.append(
                                [
                                    "return_contains",
                                    each.split("return_contains")[1]
                                    .strip()[1:-1]
                                    .split("="),
                                ]
                            )
                        elif each.strip("\n").startswith("return_does_not_contain"):
                            data.append(
                                [
                                    "return_does_not_contain",
                                    each.split("return_does_not_contain")[1]
                                    .strip()[1:-1]
                                    .split("="),
                                ]
                            )
                        else:
                            data.append(each.strip().split("="))
                    for i in range(len(data)):
                        for j in range(len(data[i])):
                            if isinstance(data[i][j], str):
                                data[i][j] = data[i][j].strip()
                            if j == 1:
                                if isinstance(data[i][j], list):
                                    data[i][j][0], data[i][j][1] = (
                                        data[i][j][0].strip().strip('"'),
                                        data[i][j][1].strip().strip('"'),
                                    )
                                elif isinstance(data[i][j], str):
                                    data[i][j] = data[i][j].strip(
                                        '"'
                                    )  # dont add another strip here. dont need to strip inside quotation mark

                    for Left, Right in data:
                        if Left == "return_contains":
                            target[target_index][2].append(Right)
                        elif Left == "return_does_not_contain":
                            target[target_index][3].append(Right)
                        else:
                            target[target_index][0].append(
                                (Left, "element parameter", Right)
                            )

                    target_index = target_index + 1
                elif left == "save web elements in list":
                    variable_name = right
                # elif left == "paired":
                #     paired = False if right.lower() == "no" else True

            if has_element:
                Element = LocateElement.Get_Element(step_data, selenium_driver)
                if Element == "zeuz_failed":
                    CommonUtil.ExecLog(
                        sModuleInfo, "Unable to locate your element with given data.", 3
                    )
                    return "zeuz_failed"
            else:
                Element = selenium_driver
        except:
            CommonUtil.ExecLog(
                sModuleInfo,
                "Unable to parse data. Please write data in correct format",
                3,
            )
            return "zeuz_failed"

        for each in target:
            all_elements.append(
                LocateElement.Get_Element(each[0], Element, return_all_elements=True)
            )

        cnt = 0
        while cnt < target_index:
            if target[cnt][2]:
                count, to_del = 0, []
                for elem in all_elements[cnt]:
                    for each in target[cnt][2]:
                        if each[0] == "text" and each[1] in elem.text:
                            break
                    else:
                        for each in target[cnt][2]:
                            if each[0] == "tag" and each[1] in elem.tag_name:
                                break
                        else:
                            for each in target[cnt][2]:
                                if (
                                    each[0] not in ("text", "tag")
                                    and elem.get_attribute(each[0]) is None
                                ):
                                    break
                            else:
                                for each in target[cnt][2]:
                                    if each[0] not in ("text", "tag") and each[
                                        1
                                    ] in elem.get_attribute(each[0]):
                                        break
                                else:
                                    to_del.append(count)
                    count += 1
                all_elements[cnt] = CommonUtil.Delete_from_list(
                    all_elements[cnt], to_del
                )
                # Using this function to delete in O(N) complexity
            if target[cnt][3]:
                count, to_del = 0, []
                for elem in all_elements[cnt]:
                    for each in target[cnt][3]:
                        if each[0] == "text" and each[1] in elem.text:
                            to_del.append(count)
                            break
                    else:
                        for each in target[cnt][3]:
                            if each[0] == "tag" and each[1] in elem.tag_name:
                                to_del.append(count)
                                break
                        else:
                            for each in target[cnt][3]:
                                if (
                                    each[0] not in ("text", "tag")
                                    and elem.get_attribute(each[0]) is None
                                ):
                                    to_del.append(count)
                                    break
                            else:
                                for each in target[cnt][3]:
                                    if each[0] not in ("text", "tag") and each[
                                        1
                                    ] in elem.get_attribute(each[0]):
                                        to_del.append(count)
                                        break

                    count += 1
                all_elements[cnt] = CommonUtil.Delete_from_list(
                    all_elements[cnt], to_del
                )

            cnt += 1

        if target_index == 1:
            return Shared_Resources.Set_Shared_Variables(variable_name, all_elements[0])
        else:
            return Shared_Resources.Set_Shared_Variables(variable_name, all_elements)

    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


# Validating text from an element given information regarding the expected text
@logger
def Validate_Text(step_data):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        Element = LocateElement.Get_Element(step_data, selenium_driver)
        ignore_case = False
        zeuz_ai = None
        if Element == "zeuz_failed":
            CommonUtil.ExecLog(
                sModuleInfo, "Unable to locate your element with given data.", 3
            )
            return "zeuz_failed"
        for each_step_data_item in step_data:
            if each_step_data_item[1] == "action":
                expected_text_data = each_step_data_item[2]
                validation_type = each_step_data_item[0]
            elif (
                each_step_data_item[1].strip().lower() in ("optional parameter")
                and each_step_data_item[0] == "ignore case"
            ):
                ignore_case = (
                    True
                    if each_step_data_item[2].strip().lower() in ("yes", "true", "ok")
                    else False
                )
            elif each_step_data_item[1].strip().lower() == "text classifier offset":
                zeuz_ai = [
                    each_step_data_item[0].strip(),
                    float(each_step_data_item[2]),
                ]
        # expected_text_data = step_data[0][len(step_data[0]) - 1][2]
        if ignore_case:
            expected_text_data = expected_text_data.lower()
            list_of_element_text = Element.text.lower().split("\n")
        else:
            list_of_element_text = Element.text.split("\n")
        visible_list_of_element_text = []
        for each_text_item in list_of_element_text:
            if each_text_item != "":
                visible_list_of_element_text.append(each_text_item)

        # if step_data[0][len(step_data[0])-1][0] == "validate partial text":
        if zeuz_ai is not None:
            """{
                "binary_classification":{
                    "expected_category":"success",
                    "confidence": 0.7
                }
             }
             """
            message = " ".join(visible_list_of_element_text)
            labels = [zeuz_ai[0]]
            confidence = zeuz_ai[1]
            return binary_classification(message, labels, confidence)["status"]

        elif validation_type == "validate partial text":
            actual_text_data = visible_list_of_element_text
            CommonUtil.ExecLog(sModuleInfo, "Expected Text: " + expected_text_data, 1)
            CommonUtil.ExecLog(sModuleInfo, "Actual Text: " + str(actual_text_data), 1)
            for each_actual_text_data_item in actual_text_data:
                if expected_text_data in each_actual_text_data_item:
                    CommonUtil.ExecLog(
                        sModuleInfo,
                        "The text has been validated by a partial match.",
                        1,
                    )
                    return "passed"
            CommonUtil.ExecLog(
                sModuleInfo, "Unable to validate using partial match.", 3
            )
            return "zeuz_failed"
        # if step_data[0][len(step_data[0])-1][0] == "validate full text":
        elif validation_type == "validate full text":
            actual_text_data = visible_list_of_element_text
            CommonUtil.ExecLog(sModuleInfo, "Expected Text: " + expected_text_data, 1)
            CommonUtil.ExecLog(sModuleInfo, "Actual Text: " + str(actual_text_data), 1)
            if expected_text_data in actual_text_data:
                CommonUtil.ExecLog(
                    sModuleInfo,
                    "The text has been validated by using complete match.",
                    1,
                )
                return "passed"
            else:
                CommonUtil.ExecLog(
                    sModuleInfo, "Unable to validate using complete match.", 3
                )
                return "zeuz_failed"

        else:
            CommonUtil.ExecLog(
                sModuleInfo, "Incorrect validation type. Please check step data", 3
            )
            return "zeuz_failed"

    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


def generate_scroll_offset(direction: str, pixel: int) -> str:
    if direction == "down":
        return f"0,{pixel}"
    elif direction == "up":
        return f"0,-{pixel}"
    elif direction == "left":
        return f"-{pixel},0"
    elif direction == "right":
        return f"{pixel},0"
    else:
        return "0,0"


# Method to scroll down a page
@logger
def Scroll(step_data):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        Element = None
        get_element = False
        scroll_direction = ""
        offset = ""
        pixel = 750
        for left, mid, right in step_data:
            mid = mid.strip().lower()
            if "action" in mid:
                scroll_direction = right.strip().lower()
            elif mid == "element parameter":
                get_element = True
            elif left.strip().lower() == "pixels":
                pixel = int(right.strip().lower())

        if get_element:
            Element = LocateElement.Get_Element(step_data, selenium_driver)

        offset = generate_scroll_offset(scroll_direction, pixel)

        CommonUtil.ExecLog(sModuleInfo, f"Scrolling {scroll_direction}", 1)
        selenium_driver.execute_script(
            f"{'arguments[0]' if Element is not None else 'window'}.scrollBy({offset})"
        )
        time.sleep(2)
        return "passed"

    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


# Method to scroll to view an element
@logger
def scroll_to_element(step_data):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    retur_ntop_left_script = """
        var Top = window.pageYOffset || document.documentElement.scrollTop;
        var Left = window.pageXOffset || document.documentElement.scrollLeft;
        return [Top, Left]"""
    method = "js"
    additional_scroll = 0.1
    direction = ""
    top, left = None, None
    alignToTop = "true"
    """
    The alignToTop parameter is a boolean value that can be either true or false. Here's what each value does:

    true: If alignToTop  is set to  true, the browser will scroll the element so that it is positioned at the
    top of the visible area of the window. In other words, the top of the element will be aligned with the top of the viewport.
    
    false (or omitted): If alignToTop is set to false or omitted, the browser will scroll the element into the
    visible area of the window, but it will try to align the bottom of the element with the bottom of the viewport.
    This means that the element will be positioned at the bottom of the visible area.
    """

    try:
        for left, mid, right in step_data:
            left = left.lower().strip()
            right = right.strip().lower()
            if "use js" == left:
                method = "js" if right in ("true", "yes", "1") else "action chain"
            elif "align to top" == left:
                alignToTop = "true" if right in ("true", "yes", "1") else "false"
            elif "method" == left:
                method = right
            elif "additional scroll" in left:
                additional_scroll = float(right)
                d = right.lstrip("additional scroll").strip()
                if d in ("up", "down", "left", "right"):
                    direction = d

        scroll_element = LocateElement.Get_Element(step_data, selenium_driver)
        if scroll_element in failed_tag_list:
            CommonUtil.ExecLog(
                sModuleInfo, "Element to which instructed to scroll not found", 3
            )
            return "zeuz_failed"

        if not direction and additional_scroll > 0:
            try:
                top, left = selenium_driver.execute_script(retur_ntop_left_script)
            except:
                top, left = None, None

        if method == "js":
            selenium_driver.execute_script(
                f"arguments[0].scrollIntoView({alignToTop});", scroll_element
            )
        elif method == "webdriver":
            scroll_element.location_once_scrolled_into_view
        else:
            ActionChains(selenium_driver).move_to_element(scroll_element).perform()

        CommonUtil.ExecLog(
            sModuleInfo,
            f"Scrolled to view with method = {method}",
            1,
        )

        if (
            not direction
            and additional_scroll > 0
            and top is not None
            and left is not None
        ):
            try:
                newTop, newLeft = selenium_driver.execute_script(retur_ntop_left_script)
                if newTop > top:
                    direction = "down"
                elif newTop < top:
                    direction = "up"
                elif newLeft > left:
                    direction = "right"
                elif newLeft < left:
                    direction = "left"
                else:
                    direction = ""
            except:
                direction = ""

            if (
                (method in ["js", "webdriver"])
                and (alignToTop == "true" and direction in ["down", "right"])
                or (alignToTop == "false" and direction in ["up", "left"])
            ):
                # No need of default additional scroll
                direction = ""

        if direction and additional_scroll > 0:
            time.sleep(1)
            offset = generate_scroll_offset(
                direction,
                round(
                    selenium_driver.get_window_size()[
                        "height" if direction in ("up", "down") else "width"
                    ]
                    * additional_scroll
                ),
            )
            CommonUtil.ExecLog(
                sModuleInfo,
                f"Doing additional scroll in {direction} direction, {additional_scroll * 100}% of {'height' if direction in ('up', 'down') else 'width'} of html body, ({offset}) pixels",
                1,
            )
            selenium_driver.execute_script(f"window.scrollBy({offset})")
        return "passed"

    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


scroll_to_top_code = """ var pre_x = window.pageXOffset;
var pre_y = window.pageYOffset;
window.scrollTo(window.pageXOffset,0); return [pre_x, pre_y, window.pageXOffset, window.pageYOffset]
"""


# Method to scroll to view an element
@logger
def scroll_to_top(step_data):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    try:
        pre_x, pre_y, x, y = selenium_driver.execute_script(scroll_to_top_code)
        CommonUtil.ExecLog(
            sModuleInfo,
            f"Scrolled to top of the html.\npre_x, pre_y, x, y = [{pre_x}, {pre_y}, {x}, {y}]",
            1 if (x, y) == (0, 0) else 2,
        )
        return "passed"

    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


# Method to return pass or fail for the step outcome
@logger
def Navigate(step_data):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        if 1 < len(step_data) >= 2:
            CommonUtil.ExecLog(sModuleInfo, "Please provide only single row of data", 3)
            return "zeuz_failed"
        else:
            navigate = step_data[0][2]
            if navigate == "back":
                selenium_driver.back()
                CommonUtil.ExecLog(sModuleInfo, "Performing browser back", 1)
            elif navigate == "forward":
                selenium_driver.forward()
                CommonUtil.ExecLog(sModuleInfo, "Performing browser forward", 1)
            elif navigate == "refresh":
                selenium_driver.refresh()
                CommonUtil.ExecLog(sModuleInfo, "Performing browser refresh", 1)
            else:
                CommonUtil.ExecLog(
                    sModuleInfo,
                    "Value invalid. Only 'back', 'forward', 'refresh' allowed",
                    3,
                )
                return "zeuz_failed"
            return "passed"
    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


@logger
def Select_Deselect(step_data):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        Element = LocateElement.Get_Element(step_data, selenium_driver)
        if Element == "zeuz_failed":
            CommonUtil.ExecLog(
                sModuleInfo, "Unable to locate your element with given data.", 3
            )
            return "zeuz_failed"

        for each in step_data:
            if each[1] == "action":
                if each[0] == "deselect all":
                    CommonUtil.ExecLog(sModuleInfo, "Deselect all elements", 1)
                    result = Select(Element).deselect_all()
                    # result = selected_Element.deselect_all()
                    return "passed"
                elif each[0] == "deselect by visible text":
                    CommonUtil.ExecLog(sModuleInfo, "Deselect by visible text", 1)
                    visible_text = each[2]
                    selected_Element = Select(Element)
                    result = selected_Element.deselect_by_visible_text(visible_text)
                    return "passed"
                elif each[0] == "deselect by value":
                    CommonUtil.ExecLog(sModuleInfo, "Deselect by value", 1)
                    value = each[2]
                    selected_Element = Select(Element)
                    result = selected_Element.deselect_by_value(value)
                    return "passed"
                elif each[0] == "deselect by index":
                    CommonUtil.ExecLog(sModuleInfo, "Deselect by index", 1)
                    index = int(each[2])
                    selected_Element = Select(Element)
                    result = selected_Element.deselect_by_index(index)
                    return "passed"
                elif each[0] == "select by index":
                    CommonUtil.ExecLog(sModuleInfo, "Select by index", 1)
                    index = each[2]
                    selected_Element = Select(Element)
                    result = selected_Element.select_by_index(index)
                    return "passed"
                elif each[0] == "select by value":
                    CommonUtil.ExecLog(sModuleInfo, "Select by value", 1)
                    value = each[2]
                    selected_Element = Select(Element)
                    result = selected_Element.select_by_value(value)
                    return "passed"
                elif each[0] == "select by visible text":
                    CommonUtil.ExecLog(sModuleInfo, "Select by visible text", 1)
                    visible_text = each[2]
                    selected_Element = Select(Element)
                    result = selected_Element.select_by_visible_text(visible_text)
                    return "passed"
                else:
                    CommonUtil.ExecLog(
                        sModuleInfo,
                        "Value invalid. Only 'deselect all', 'deselect by visible text', etc allowed",
                        3,
                    )
                    result = "zeuz_failed"

            else:
                continue

    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


@logger
def Tear_Down_Selenium(step_data=[]):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    global selenium_details
    global current_driver_id
    try:
        driver_id = ""
        for left, mid, right in step_data:
            left = left.replace(" ", "").replace("_", "").replace("-", "").lower()
            if left == "driverid":
                driver_id = right.strip()

        if not driver_id:
            CommonUtil.Join_Thread_and_Return_Result(
                "screenshot"
            )  # Let the capturing screenshot end in thread
            for driver in selenium_details:
                try:
                    selenium_details[driver]["driver"].quit()
                    CommonUtil.ExecLog(
                        sModuleInfo, "Teared down driver_id='%s'" % driver, 1
                    )
                except:
                    errMsg = (
                        "Unable to tear down driver_id='%s'. may already been killed"
                        % driver
                    )
                    CommonUtil.ExecLog(sModuleInfo, errMsg, 2)
                    CommonUtil.Exception_Handler(sys.exc_info(), None, errMsg)
            Shared_Resources.Remove_From_Shared_Variables("selenium_driver")
            selenium_details = {}
            selenium_driver = None

        elif driver_id not in selenium_details:
            CommonUtil.ExecLog(
                sModuleInfo,
                "Driver_id='%s' not found. So could not tear down" % driver_id,
                2,
            )

        else:
            try:
                selenium_details[driver_id]["driver"].quit()
                CommonUtil.ExecLog(
                    sModuleInfo, "Teared down driver_id='%s'" % driver_id, 1
                )
            except:
                CommonUtil.ExecLog(
                    sModuleInfo,
                    "Unable to tear down driver_id='%s'. may already been killed"
                    % driver_id,
                    2,
                )
            del selenium_details[driver_id]
            if selenium_details:
                for driver in selenium_details:
                    selenium_driver = selenium_details[driver]["driver"]
                    Shared_Resources.Set_Shared_Variables(
                        "selenium_driver", selenium_driver
                    )
                    CommonUtil.ExecLog(
                        sModuleInfo,
                        "Current driver is set to driver_id='%s'" % driver,
                        1,
                    )
                    current_driver_id = driver
                    break
            else:
                Shared_Resources.Remove_From_Shared_Variables("selenium_driver")
                selenium_driver = None
                current_driver_id = driver_id

        global vdisplay
        if vdisplay:
            vdisplay.stop()
            vdisplay = None

        return "passed"
    except Exception:
        errMsg = "Unable to tear down selenium browsers. may already be killed"
        # return CommonUtil.Exception_Handler(sys.exc_info(), None, errMsg)
        CommonUtil.ExecLog(sModuleInfo, errMsg, 2)
        return "passed"


@logger
def Switch_Browser(step_data):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    global selenium_details
    global current_driver_id
    try:
        driver_id = ""
        for left, mid, right in step_data:
            left = left.replace(" ", "").replace("_", "").replace("-", "").lower()
            if left == "driverid":
                driver_id = right.strip()

        if not driver_id:
            driver_id = "default"

        if driver_id not in selenium_details:
            CommonUtil.ExecLog(
                sModuleInfo,
                "Driver_id='%s' not found. So could not Switch" % driver_id,
                3,
            )
            return "zeuz_failed"
        else:
            selenium_driver = selenium_details[driver_id]["driver"]
            Shared_Resources.Set_Shared_Variables("selenium_driver", selenium_driver)
            current_driver_id = driver_id
            CommonUtil.ExecLog(
                sModuleInfo, "Current driver is set to driver_id='%s'" % driver_id, 1
            )

        return "passed"
    except Exception:
        errMsg = "Unable to tear down selenium browsers. may already be killed"
        # return CommonUtil.Exception_Handler(sys.exc_info(), None, errMsg)
        CommonUtil.ExecLog(sModuleInfo, errMsg, 2)
        return "passed"


@logger
def Get_Current_URL(step_data):
    """
    This action saves the current url the browser is in by inspecting the address bar.

    get current url         selenium action     <saves the current url by inspecting the address bar of the browser>

    :param data_set: Action data set
    :return: string: "Current url saved in a variable named '%s'" or "zeuz_failed" depending on the outcome
    """
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    try:
        var_name = ""
        for left, mid, right in step_data:
            if "action" in mid:
                var_name = right.strip()
        current_url = selenium_driver.current_url
        Shared_Resources.Set_Shared_Variables(var_name, current_url)
        CommonUtil.ExecLog(
            sModuleInfo, "Current url saved in a variable named '%s'" % var_name, 1
        )

        return "passed"
    except Exception:
        errMsg = "Unable to saved current url "
        # return CommonUtil.Exception_Handler(sys.exc_info(), None, errMsg)
        CommonUtil.ExecLog(sModuleInfo, errMsg, 2)
        return "passed"


# Method to open a new tab
@logger
def open_new_tab(step_data):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        time.sleep(2)
        CommonUtil.ExecLog(sModuleInfo, "Opening New Tab in Browser", 1)
        selenium_driver.execute_script("""window.open("");""")
        selenium_driver.switch_to.window(selenium_driver.window_handles[-1])

        CommonUtil.ExecLog(sModuleInfo, "New Tab Opened Successfully in Browser", 1)

        return "passed"
    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


@logger
def switch_window_or_tab(step_data):
    """
    This action will switch tab/window in browser. Basically window and tabs are same in selenium.

    Example 1:
    Field	                    Sub Field	        Value
    *window title               input parameter	    googl
    switch window/tab           selenium action 	switch window or frame


    Example 2:
    Field	                    Sub Field	        Value
    window title                input parameter	    google
    switch window/tab           selenium action 	switch window or frame

    Example 3:
    Field	                    Sub Field	        Value
    window index                input parameter	    9
    switch window/tab           selenium action 	switch window or frame

    """
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        window_title_condition = False
        window_index_condition = False
        partial_match = False
        for left, mid, right in step_data:
            left = left.lower().strip()
            if left in ("window title", "tab title"):
                switch_by_title = right
                window_title_condition = True
            elif left in ("*window title", "*tab title"):
                switch_by_title = right
                partial_match = True
                window_title_condition = True
            elif left in ("window index", "tab index"):
                switch_by_index = right.strip()
                window_index_condition = True
                window_title_condition = False

    except Exception:
        CommonUtil.ExecLog(
            sModuleInfo,
            "Unable to parse data. Maintain correct format writen in document",
            3,
        )
        return "zeuz_failed"

    try:
        if window_title_condition:
            all_windows = selenium_driver.window_handles
            current_window = selenium_driver.current_window_handle
            window_handles_found = False
            Tries = 3
            for Try in range(Tries):
                for each in all_windows:
                    selenium_driver.switch_to.window(each)
                    if (
                        partial_match
                        and switch_by_title.lower() in selenium_driver.title.lower()
                    ) or (
                        not partial_match
                        and switch_by_title.lower() == selenium_driver.title.lower()
                    ):
                        window_handles_found = True
                        CommonUtil.ExecLog(
                            sModuleInfo,
                            "Tab switched to '%s'" % selenium_driver.title,
                            1,
                        )
                        break
                else:
                    CommonUtil.ExecLog(
                        sModuleInfo,
                        "Couldn't find the title. Trying again after 1 second delay",
                        2,
                    )
                    time.sleep(1)
                    continue  # only executed if the inner loop did not break
                break  # only executed if the inner loop did break

            if not window_handles_found:
                selenium_driver.switch_to.window(current_window)
                CommonUtil.ExecLog(
                    sModuleInfo,
                    "unable to find the title among the tabs. If you want to match partially please use '*tab title'",
                    3,
                )
                return "zeuz_failed"

        elif window_index_condition:
            window_index = int(switch_by_index)
            window_to_switch = selenium_driver.window_handles[window_index]
            selenium_driver.switch_to.window(window_to_switch)
            CommonUtil.ExecLog(
                sModuleInfo,
                f"Tab switched to index {switch_by_index} title {selenium_driver.title}",
                1,
            )

        return "passed"
    except Exception:
        CommonUtil.ExecLog(sModuleInfo, "Unable to switch your tab", 3)
        return CommonUtil.Exception_Handler(sys.exc_info())


@logger
def close_tab(step_data):
    """
    This action will close tab/window in browser. Supports both Selenium and Playwright.

    Example 1:
    Field	                    Sub Field	        Value
    playwright                  optional parameter	 True
    close tab                   selenium action 	close tab

    Example 2:
    Field	                    Sub Field	        Value
    tab title                   input parameter	    ['Zeuz', 'Google']
    playwright                  optional parameter	    True
    close tab                   selenium action 	close tab

    Example 3:
    Field	                    Sub Field	        Value
    tab index                   input parameter	    [0,1,-1]
    playwright                  optional parameter	    True
    close tab                   selenium action 	close tab

    Example 4:
    Field	                    Sub Field	        Value
    close tab                   selenium action 	close tab
    # Closes current active tab

    """
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        close_tabs = []
        playwright_enabled = False
        tab_title = None
        tab_index = None

        for left, mid, right in step_data:
            left = left.lower().strip()
            if left in ("tabs"):
                close_tabs = [
                    i.strip().lower() if isinstance(i, str) else i
                    for i in CommonUtil.parse_value_into_object(right)
                ]
            elif left == "playwright" and right.lower() == "true":
                playwright_enabled = True
            elif left == "tab title":
                tab_title = right.strip()
            elif left == "tab index":
                tab_index = right.strip()

    except Exception:
        CommonUtil.ExecLog(
            sModuleInfo,
            "Unable to parse data. Maintain correct format writen in document",
            3,
        )
        return "zeuz_failed"

    try:
        if playwright_enabled:
            # --- Playwright tab closing ---
            print("Using Playwright for tab closing")
            from playwright.sync_api import sync_playwright

            try:
                with sync_playwright() as p:
                    debug_port = selenium_details[current_driver_id]["remote-debugging-port"]
                    browser = p.chromium.connect_over_cdp(f"http://localhost:{debug_port}")
                    context = browser.contexts[0]
                    pages = context.pages

                    if tab_title:
                        # Close tab by title
                        for page in pages:
                            page_title = page.title()
                            if tab_title.lower() in page_title.lower():
                                page.close()
                                CommonUtil.ExecLog(
                                    sModuleInfo,
                                    f"Playwright: Tab closed '{page_title}'",
                                    1,
                                )
                                return "passed"
                        CommonUtil.ExecLog(
                            sModuleInfo,
                            f"Playwright: No tab with title '{tab_title}' found",
                            3,
                        )
                        return "zeuz_failed"

                    elif tab_index is not None:
                        # Close tab by index using visual order
                        try:
                            idx = int(tab_index)

                            # Get visual tab order from CDP
                            import urllib.request
                            import json

                            with urllib.request.urlopen(
                                f"http://localhost:{debug_port}/json"
                            ) as response:
                                tabs = json.load(response)
                                # Filter only 'page' type tabs for clean left-to-right order
                                # the target url is ordered right to left
                                target_urls = [
                                    tab["url"] for tab in tabs if tab["type"] == "page"
                                ]
                                target_urls.reverse()  # Reverse to get actual left-to-right visual order

                            if idx < len(target_urls):
                                desired_url = target_urls[idx]
                                # Find the page with matching URL
                                for page in pages:
                                    if page.url == desired_url:
                                        page.close()
                                        CommonUtil.ExecLog(
                                            sModuleInfo,
                                            f"Playwright: Tab closed at  index {idx}",
                                            1,
                                        )
                                        return "passed"

                                CommonUtil.ExecLog(
                                    sModuleInfo,
                                    f"Playwright: Tab at visual index {idx} not found in context",
                                    3,
                                )
                                return "zeuz_failed"
                            else:
                                CommonUtil.ExecLog(
                                    sModuleInfo,
                                    f"Playwright: Invalid index {idx}. Only {len(target_urls)} tabs open.",
                                    3,
                                )
                                return "zeuz_failed"
                        except ValueError:
                            CommonUtil.ExecLog(
                                sModuleInfo,
                                f"Playwright: Invalid tab index '{tab_index}'",
                                3,
                            )
                            return "zeuz_failed"
                        except Exception as e:
                            CommonUtil.ExecLog(
                                sModuleInfo,
                                f"Playwright: Failed to get visual tab order: {e}",
                                3,
                            )
                            return "zeuz_failed"

                    else:
                        # Close current active tab
                        if len(pages) >= 1:
                            # Try to find the currently focused tab
                            current_page = None
                            for page in pages:
                                try:
                                    # Check if this page is currently active
                                    if page.evaluate("document.hasFocus()"):
                                        current_page = page
                                        break
                                except Exception:
                                    continue

                            # If no focused page found, get the first tab in visual order
                            if current_page is None:
                                try:
                                    import urllib.request
                                    import json

                                    with urllib.request.urlopen(
                                        f"http://localhost:{debug_port}/json"
                                    ) as response:
                                        tabs = json.load(response)

                                        # Filter only 'page' type tabs (last opened tab is at index 0)
                                        target_urls = [
                                            tab["url"]
                                            for tab in tabs
                                            if tab["type"] == "page"
                                        ]
                                        if target_urls:
                                            last_tab_url = target_urls[0]
                                            # Find the page with matching URL
                                            for page in pages:
                                                if page.url == last_tab_url:
                                                    current_page = page
                                                    break
                                except Exception as e:
                                    CommonUtil.ExecLog(
                                        sModuleInfo,
                                        f"Failed to get visual tab order: {e}",
                                        2,
                                    )
                                    # Ultimate fallback to first page in context
                                    current_page = pages[0]

                            page_title = current_page.title()
                            current_page.close()
                            CommonUtil.ExecLog(
                                sModuleInfo,
                                f"Playwright: Current tab closed '{page_title}'",
                                1,
                            )
                            return "passed"
                        else:
                            CommonUtil.ExecLog(
                                sModuleInfo, "Playwright: No tabs found to close", 3
                            )
                            return "zeuz_failed"

            except Exception as e:
                CommonUtil.ExecLog(
                    sModuleInfo,
                    f"Playwright tab closing failed: {e}. Falling back to Selenium",
                    2,
                )
                playwright_enabled = False
                # Continue with Selenium fallback

        # --- Selenium tab closing ---
        if not playwright_enabled:
            window_handles_found = False

            if tab_title:
                # Close tab by title using Selenium
                current_window = selenium_driver.current_window_handle
                for each in selenium_driver.window_handles:
                    selenium_driver.switch_to.window(each)
                    if tab_title.lower() in selenium_driver.title.strip().lower():
                        title = selenium_driver.title
                        selenium_driver.close()
                        window_handles_found = True
                        CommonUtil.ExecLog(sModuleInfo, f"Tab closed '{title}'", 1)
                        break

                # Return to a valid window
                if window_handles_found:
                    try:
                        remaining_handles = selenium_driver.window_handles
                        if remaining_handles:
                            if current_window in remaining_handles:
                                selenium_driver.switch_to.window(current_window)
                            else:
                                selenium_driver.switch_to.window(remaining_handles[-1])
                        else:
                            # No windows left, browser will close automatically
                            CommonUtil.ExecLog(
                                sModuleInfo,
                                f"Last tab closed '{title}'. Browser will close.",
                                1,
                            )
                            return "passed"
                    except Exception:
                        # Session might be invalid, which is expected when closing the last tab
                        CommonUtil.ExecLog(
                            sModuleInfo,
                            f"Tab closed '{title}'. Browser session ended.",
                            1,
                        )
                        return "passed"
                else:
                    CommonUtil.ExecLog(
                        sModuleInfo, f"No tab with title '{tab_title}' found", 3
                    )
                    return "zeuz_failed"

            elif tab_index is not None:
                # Close tab by index using Selenium
                try:
                    idx = int(tab_index)
                    if idx < 0 or idx >= len(selenium_driver.window_handles):
                        CommonUtil.ExecLog(
                            sModuleInfo,
                            f"Invalid index {idx}. Only {len(selenium_driver.window_handles)} tabs open.",
                            3,
                        )
                        return "zeuz_failed"

                    current_window = selenium_driver.current_window_handle
                    target_handle = selenium_driver.window_handles[idx]
                    selenium_driver.switch_to.window(target_handle)
                    title = selenium_driver.title
                    selenium_driver.close()

                    # Return to a valid window
                    try:
                        remaining_handles = selenium_driver.window_handles
                        if remaining_handles:
                            if current_window in remaining_handles:
                                selenium_driver.switch_to.window(current_window)
                            else:
                                selenium_driver.switch_to.window(remaining_handles[-1])
                        else:
                            # No windows left, browser will close automatically
                            CommonUtil.ExecLog(
                                sModuleInfo,
                                f"Last tab closed at index {idx}: '{title}'. Browser will close.",
                                1,
                            )
                            return "passed"
                    except Exception:
                        # Session might be invalid, which is expected when closing the last tab
                        CommonUtil.ExecLog(
                            sModuleInfo,
                            f"Tab closed at index {idx}: '{title}'. Browser session ended.",
                            1,
                        )
                        return "passed"

                    CommonUtil.ExecLog(
                        sModuleInfo, f"Tab closed at index {idx}: '{title}'", 1
                    )

                except ValueError:
                    CommonUtil.ExecLog(
                        sModuleInfo, f"Invalid tab index '{tab_index}'", 3
                    )
                    return "zeuz_failed"

            elif len(close_tabs) > 1 and isinstance(close_tabs[0], str):
                # Close multiple tabs by title
                current_window = selenium_driver.current_window_handle
                for each in selenium_driver.window_handles:
                    selenium_driver.switch_to.window(each)
                    if selenium_driver.title.strip().lower() in close_tabs:
                        title = selenium_driver.title
                        selenium_driver.close()
                        window_handles_found = True
                        CommonUtil.ExecLog(sModuleInfo, "Tab closed '%s'" % title, 1)
                if window_handles_found:
                    try:
                        remaining_handles = selenium_driver.window_handles
                        if remaining_handles:
                            if current_window in remaining_handles:
                                selenium_driver.switch_to.window(current_window)
                            else:
                                selenium_driver.switch_to.window(remaining_handles[-1])
                        else:
                            # No windows left, browser will close automatically
                            CommonUtil.ExecLog(
                                sModuleInfo, "All tabs closed. Browser will close.", 1
                            )
                            return "passed"
                    except Exception:
                        # Session might be invalid, which is expected when closing the last tab
                        CommonUtil.ExecLog(
                            sModuleInfo, "Tabs closed. Browser session ended.", 1
                        )
                        return "passed"

            elif len(close_tabs) > 1:
                # Close multiple tabs by index
                current_window = selenium_driver.current_window_handle
                for each in [selenium_driver.window_handles[i] for i in close_tabs]:
                    selenium_driver.switch_to.window(each)
                    title = selenium_driver.title
                    selenium_driver.close()
                    CommonUtil.ExecLog(sModuleInfo, f"Tab closed '{title}'", 1)
                try:
                    remaining_handles = selenium_driver.window_handles
                    if remaining_handles:
                        if current_window in remaining_handles:
                            selenium_driver.switch_to.window(current_window)
                        else:
                            selenium_driver.switch_to.window(remaining_handles[-1])
                    else:
                        # No windows left, browser will close automatically
                        CommonUtil.ExecLog(
                            sModuleInfo, "All tabs closed. Browser will close.", 1
                        )
                        return "passed"
                except Exception:
                    # Session might be invalid, which is expected when closing the last tab
                    CommonUtil.ExecLog(
                        sModuleInfo, "Tabs closed. Browser session ended.", 1
                    )
                    return "passed"

            else:
                # Close current active tab and switch to left tab
                title = selenium_driver.title
                current_index = selenium_driver.window_handles.index(
                    selenium_driver.current_window_handle
                )
                selenium_driver.close()

                # Check if there are any remaining windows after closing
                try:
                    remaining_handles = selenium_driver.window_handles
                    if remaining_handles:
                        # Switch to the left tab (previous index)
                        if current_index > 0:
                            # Go to the tab to the left
                            selenium_driver.switch_to.window(
                                remaining_handles[current_index - 1]
                            )
                        else:
                            # If we were at the leftmost tab, go to the new leftmost
                            selenium_driver.switch_to.window(remaining_handles[0])
                    else:
                        # No windows left, browser will close automatically
                        CommonUtil.ExecLog(
                            sModuleInfo,
                            f"Last tab closed '{title}'. Browser will close.",
                            1,
                        )
                        return "passed"

                except Exception:
                    # Session might be invalid, which is expected when closing the last tab
                    CommonUtil.ExecLog(
                        sModuleInfo,
                        f"Current tab closed '{title}'. Browser session ended.",
                        1,
                    )
                    return "passed"

                CommonUtil.ExecLog(sModuleInfo, f"Current tab closed '{title}'", 1)

        return "passed"
    except Exception:
        CommonUtil.ExecLog(sModuleInfo, "Unable to switch your tab", 3)
        return CommonUtil.Exception_Handler(sys.exc_info())


@logger
def switch_iframe(step_data):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        for left, mid, right in step_data:
            left = left.lower().strip()
            if "action" in mid.lower() and left == "switch iframe":
                pass
            elif left == "index" and "default" in right.lower():
                selenium_driver.switch_to.default_content()
                CommonUtil.ExecLog(
                    sModuleInfo, "Exited all iframes and switched to default content", 1
                )
            elif left == "index":
                if mid == "iframe parameter":
                    for i in range(5):
                        iframes = selenium_driver.find_elements(By.TAG_NAME, "iframe")
                        idx = int(right.strip())
                        if -len(iframes) <= idx < len(iframes):
                            CommonUtil.ExecLog(
                                sModuleInfo,
                                "Iframe switched to index %s" % right.strip(),
                                1,
                            )
                            break
                        CommonUtil.ExecLog(
                            sModuleInfo,
                            "Iframe index = %s not found. retrying after 2 sec wait"
                            % right.strip(),
                            2,
                        )
                        time.sleep(2)
                    else:
                        CommonUtil.ExecLog(
                            sModuleInfo,
                            "Index out of range. Total %s iframes found."
                            % len(iframes),
                            3,
                        )
                        return "zeuz_failed"
                    if idx < 0:
                        idx = len(iframes) + idx
                    try:
                        frame_attribute = iframes[idx].get_attribute("outerHTML")
                        i, c = 0, 0
                        for i in range(len(frame_attribute)):
                            if frame_attribute[i] == '"':
                                c += 1
                            if frame_attribute[i] == ">" and c % 2 == 0:
                                break
                        frame_attribute = frame_attribute[: i + 1]
                        CommonUtil.ExecLog(sModuleInfo, "%s" % (frame_attribute), 5)
                    except:
                        pass
                    selenium_driver.switch_to.frame(idx)
                elif mid == "frame parameter":
                    for i in range(5):
                        frames = selenium_driver.find_elements(By.TAG_NAME, "frame")
                        idx = int(right.strip())
                        if -len(frames) <= idx < len(frames):
                            CommonUtil.ExecLog(
                                sModuleInfo,
                                "Frame switched to index %s" % right.strip(),
                                1,
                            )
                            break
                        CommonUtil.ExecLog(
                            sModuleInfo,
                            "Frame index = %s not found. retrying after 2 sec wait"
                            % right.strip(),
                            2,
                        )
                        time.sleep(2)
                    else:
                        CommonUtil.ExecLog(
                            sModuleInfo,
                            "Index out of range. Total %s frames found." % len(frames),
                            3,
                        )
                        return "zeuz_failed"
                    if idx < 0:
                        idx = len(frames) + idx
                    try:
                        frame_attribute = frames[idx].get_attribute("outerHTML")
                        i, c = 0, 0
                        for i in range(len(frame_attribute)):
                            if frame_attribute[i] == '"':
                                c += 1
                            if frame_attribute[i] == ">" and c % 2 == 0:
                                break
                        frame_attribute = frame_attribute[: i + 1]
                        CommonUtil.ExecLog(sModuleInfo, "%s" % (frame_attribute), 5)
                    except:
                        pass
                    selenium_driver.switch_to.frame(idx)

            elif "default" in right.lower():
                try:
                    iframe_data = [(left, "element parameter", right)]
                    if left != "xpath":
                        if mid == "iframe parameter":
                            iframe_data.append(("tag", "element parameter", "iframe"))
                        elif mid == "frame parameter":
                            iframe_data.append(("tag", "element parameter", "frame"))
                    element = LocateElement.Get_Element(iframe_data, selenium_driver)
                    selenium_driver.switch_to.frame(element)
                    CommonUtil.ExecLog(
                        sModuleInfo, "Iframe switched using above Xpath", 1
                    )
                except:
                    if mid == "iframe parameter":
                        CommonUtil.ExecLog(
                            sModuleInfo,
                            "No such iframe found. Exited all iframes and switched to default content",
                            2,
                        )
                    elif mid == "frame parameter":
                        CommonUtil.ExecLog(
                            sModuleInfo,
                            "No such frame found. Exited all frames and switched to default content",
                            2,
                        )
                    selenium_driver.switch_to.default_content()
            else:
                try:
                    iframe_data = [(left, "element parameter", right)]
                    if left != "xpath":
                        if mid == "iframe parameter":
                            iframe_data.append(("tag", "element parameter", "iframe"))
                        elif mid == "frame parameter":
                            iframe_data.append(("tag", "element parameter", "frame"))
                    element = LocateElement.Get_Element(iframe_data, selenium_driver)
                    selenium_driver.switch_to.frame(element)
                    CommonUtil.ExecLog(
                        sModuleInfo, "Iframe switched using above Xpath", 1
                    )
                except:
                    if mid == "iframe parameter":
                        CommonUtil.ExecLog(
                            sModuleInfo, "No such iframe found using above Xpath", 3
                        )
                    elif mid == "frame parameter":
                        CommonUtil.ExecLog(
                            sModuleInfo, "No such frame found using above Xpath", 3
                        )
                    return "zeuz_failed"
        return "passed"
    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


# Method to upload file
@logger
def upload_file(step_data):
    """
    This action will use normal element search parameters to locate the upload button
    You can upload the attachment to your test case and use the name as a variable for reference

    Example 1:
    Field                        Sub Field            Value
    id                           element parameter    fileUPload
    upload file                  selenium action      %|log.rtf|%

    """
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        file_name = ""
        for each in step_data:
            if each[1] == "action":
                file_name = str(each[2]).strip()

        if file_name == "":
            CommonUtil.ExecLog(sModuleInfo, "File name can't be empty!", 3)
            return "zeuz_failed"
        elif not os.path.exists(file_name):
            CommonUtil.ExecLog(
                sModuleInfo,
                "File '%s' can't be found.. please give a valid file path" % file_name,
                3,
            )
            return "zeuz_failed"

        upload_button = LocateElement.Get_Element(step_data, selenium_driver)
        if upload_button in failed_tag_list:
            CommonUtil.ExecLog(
                sModuleInfo, "Could not find the element with given data", 3
            )
            return "zeuz_failed"

        upload_button.send_keys(file_name)
        CommonUtil.ExecLog(
            sModuleInfo, "Uploaded the file: %s successfully." % file_name, 1
        )
        return "passed"

    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


def _gui_upload(path_name, pid=None):
    # Todo: Implement PID to activate the window and focus that at front
    import pyautogui

    time.sleep(3)
    pyautogui.hotkey("alt", "a")
    time.sleep(0.5)
    pyautogui.write(path_name)
    time.sleep(1)
    pyautogui.hotkey("enter")


# Method to upload file
def get_offsets(location: str, Element: WebElement) -> tuple[int]:
    location = location.replace(" ", "")
    location = location.split(",")
    x = float(location[0])
    y = float(location[1])

    height_width = Element.size

    ele_width = int((height_width)["width"])
    ele_height = int((height_width)["height"])

    total_x_offset = int((ele_width // 2) * (x / 100))
    total_y_offset = int((ele_height // 2) * (y / 100))

    return total_x_offset, total_y_offset


@logger
def drag_and_drop(dataset):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    from time import sleep

    try:
        source = []
        destination = []
        destination_offset = None
        delay = None
        param_dict = {
            "elementparameter": "element parameter",
            "parentparameter": "parent parameter",
            "siblingparameter": "sibling parameter",
            "childparameter": "child parameter",
            "optionalparameter": "optional parameter",
        }
        for left, mid, right in dataset:
            if mid.startswith("src") or mid.startswith("source"):
                mid = mid.replace("src", "").replace(" ", "").replace("source", "")
                for param in param_dict:
                    if param == mid:
                        source.append((left, param_dict[param], right))
            elif mid.startswith("dst") or mid.startswith("destination"):
                mid = mid.replace("dst", "").replace(" ", "").replace("destination", "")
                for param in param_dict:
                    if param == mid:
                        destination.append((left, param_dict[param], right))
            elif (
                left.strip().lower() in ("wait", "allow disable", "allow hidden")
                and mid == "option"
            ):
                source.append((left, mid, right))
                destination.append((left, mid, right))
            elif (
                left.strip().lower() == "destination offset"
                and mid.strip().lower() == "optional parameter"
            ):
                destination_offset = right
            elif left.strip().lower() == "delay":
                delay = float(right.strip())

        if not source:
            CommonUtil.ExecLog(
                sModuleInfo,
                'Please provide source element with "src element parameter", "src parent parameter" etc. Example:\n'
                + "(id, src element parameter, file)",
                3,
            )
            return "zeuz_failed"

        if not destination:
            CommonUtil.ExecLog(
                sModuleInfo,
                'Please provide Destination element with "dst element parameter", "dst parent parameter" etc. Example:\n'
                + "(id, dst element parameter, table)",
                3,
            )
            return "zeuz_failed"

        source_element = LocateElement.Get_Element(source, selenium_driver)
        if source_element == "zeuz_failed":
            CommonUtil.ExecLog(sModuleInfo, "Source Element is not found", 3)
            return "zeuz_failed"

        destination_element = LocateElement.Get_Element(destination, selenium_driver)
        if destination_element == "zeuz_failed":
            CommonUtil.ExecLog(sModuleInfo, "Destination Element is not found", 3)
            return "zeuz_failed"

        if destination_offset:
            x, y = get_offsets(destination_offset, destination_element)
            if delay is not None:
                """ This line of code was not tested, just keeping here"""
                ActionChains(selenium_driver).click_and_hold(
                    source_element
                ).move_to_element_with_offset(destination_element, x, y).pause(
                    delay
                ).release().perform()
            else:
                ActionChains(selenium_driver).click_and_hold(
                    source_element
                ).move_to_element_with_offset(
                    destination_element, x, y
                ).release().perform()

        else:
            if delay is not None:
                ActionChains(selenium_driver).click_and_hold(
                    source_element
                ).move_to_element(destination_element).pause(delay).release(
                    destination_element
                ).perform()
            else:
                ActionChains(selenium_driver).drag_and_drop(
                    source_element, destination_element
                ).perform()

        CommonUtil.ExecLog(
            sModuleInfo, "Drag and drop completed from source to destination", 1
        )
        return "passed"
    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


# Method to upload file
@logger
def playwright(dataset):
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        from playwright.sync_api import sync_playwright

        devtools_url = (
            selenium_driver.command_executor._url.replace("http://", "ws://")
            + "/devtools/browser"
        )
        with sync_playwright() as p:
            # browser = p.chromium.connect(browserURL=devtools_url)
            browser = p.chromium.connect_over_cdp("http://localhost:9222")
            page = browser.contexts[0].pages[0]

            # source = page.locator("//div[contains(text(), 'abcd')]")
            # dest = page.locator('(//div[@class="fc-timegrid-bg-harness"][1]/div)[1]')
            # source.drag_to(dest)
            #
            # source = page.locator("//div[contains(text(), 'Wolfgang Donna')]")
            # dest = page.locator('//span[contains(text(), "abcd")]/parent::div')
            # source.drag_to(dest)

            fileChooserPromise = page.wait_for_event("filechooser")
            # await page.getByText('Upload file').click();
            # fileChooser = await fileChooserPromise;
            # await fileChooser.setFiles(path.join(__dirname, 'myfile.pdf'));

        return "passed"
    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


@logger
def check_uncheck_all(data_set):
    """Check or uncheck all elements of a common attribute"""

    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver

    use_js = False
    target = []
    command = "check"
    try:
        for left, mid, right in data_set:
            left = left.lower().strip()
            mid = mid.lower().strip()
            if "use js" == left:
                use_js = right.strip().lower() in ("true", "yes", "ok")
            elif "target parameter" == mid:
                target.append((left, "element parameter", right))
            elif "check uncheck all" == left:
                command = "uncheck" if "uncheck" in right.lower() else "check"
            elif "allow hidden" == left:
                target.append((left, "option", right))

    except Exception:
        return CommonUtil.Exception_Handler(
            sys.exc_info(), None, "Error parsing data set"
        )

    Element = LocateElement.Get_Element(data_set, selenium_driver)
    if Element == "zeuz_failed":
        CommonUtil.ExecLog(sModuleInfo, "Could not find the parent element", 3)
        return "zeuz_failed"

    all_elements = LocateElement.Get_Element(target, Element, return_all_elements=True)
    if not all_elements:
        CommonUtil.ExecLog("", "No target was found", 3)
        return "zeuz_failed"

    for i in range(len(all_elements)):
        th = "th"
        if i + 1 == 1:
            th = "st"
        elif i + 1 == 2:
            th = "nd"
        elif i + 1 == 3:
            th = "rd"
        if command == "check" and all_elements[i].is_selected():
            CommonUtil.ExecLog(
                "", str(i + 1) + th + " target is already checked so skipped it", 1
            )
            continue
        if command == "uncheck" and not all_elements[i].is_selected():
            CommonUtil.ExecLog(
                "", str(i + 1) + th + " target is already unchecked so skipped it", 1
            )
            continue

        try:
            if use_js:
                selenium_driver.execute_script("arguments[0].click();", all_elements[i])
                if command == "check":
                    CommonUtil.ExecLog(
                        "",
                        str(i + 1)
                        + th
                        + " target is checked successfully using Java Script",
                        1,
                    )
                else:
                    CommonUtil.ExecLog(
                        "",
                        str(i + 1)
                        + th
                        + " target is unchecked successfully using Java Script",
                        1,
                    )
            else:
                try:
                    all_elements[i].click()
                    if command == "check":
                        CommonUtil.ExecLog(
                            "", str(i + 1) + th + " target is checked successfully", 1
                        )
                    else:
                        CommonUtil.ExecLog(
                            "", str(i + 1) + th + " target is unchecked successfully", 1
                        )

                except ElementClickInterceptedException:
                    try:
                        selenium_driver.execute_script(
                            "arguments[0].click();", all_elements[i]
                        )
                        if command == "check":
                            CommonUtil.ExecLog(
                                "",
                                str(i + 1)
                                + th
                                + " target is checked successfully using Java Script",
                                1,
                            )
                        else:
                            CommonUtil.ExecLog(
                                "",
                                str(i + 1)
                                + th
                                + " target is unchecked successfully using Java Script",
                                1,
                            )
                    except:
                        if command == "check":
                            CommonUtil.ExecLog(
                                "",
                                str(i + 1)
                                + th
                                + " target couldn't be checked so skipped it",
                                3,
                            )
                        else:
                            CommonUtil.ExecLog(
                                "",
                                str(i + 1)
                                + th
                                + " target couldn't be unchecked so skipped it",
                                3,
                            )
        except:
            if command == "check":
                CommonUtil.ExecLog(
                    "", str(i + 1) + th + " target couldn't be checked so skipped it", 3
                )
            else:
                CommonUtil.ExecLog(
                    "",
                    str(i + 1) + th + " target couldn't be unchecked so skipped it",
                    3,
                )

    return "passed"


@logger
def check_uncheck(data_set):
    """Check or uncheck all elements of a common attribute"""

    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver

    use_js = False
    command = "check"
    try:
        for left, mid, right in data_set:
            left = left.lower().strip()
            if "use js" == left:
                use_js = right.strip().lower() in ("true", "yes", "ok")
            elif "check uncheck" == left:
                command = "uncheck" if "uncheck" in right.lower() else "check"
    except Exception:
        return CommonUtil.Exception_Handler(
            sys.exc_info(), None, "Error parsing data set"
        )

    Element = LocateElement.Get_Element(data_set, selenium_driver)
    if Element == "zeuz_failed":
        CommonUtil.ExecLog(sModuleInfo, "Could not find the element", 3)
        return "zeuz_failed"

    if command == "check" and Element.is_selected():
        CommonUtil.ExecLog(
            sModuleInfo, "The element is already checked so skipped it", 1
        )
        return "passed"
    elif command == "uncheck" and not Element.is_selected():
        CommonUtil.ExecLog(
            sModuleInfo, "The element is already unchecked so skipped it", 1
        )
        return "passed"
    try:
        if use_js:
            selenium_driver.execute_script("arguments[0].click();", Element)
            if command == "check":
                CommonUtil.ExecLog(
                    sModuleInfo,
                    "The element is checked successfully using Java Script",
                    1,
                )
            else:
                CommonUtil.ExecLog(
                    sModuleInfo,
                    "The element is unchecked successfully using Java Script",
                    1,
                )
            return "passed"
        else:
            try:
                handle_clickability_and_click(data_set, Element)
                if command == "check":
                    CommonUtil.ExecLog(
                        sModuleInfo, "The element is checked successfully", 1
                    )
                else:
                    CommonUtil.ExecLog(
                        sModuleInfo, "The element is unchecked successfully", 1
                    )
                return "passed"
            except ElementClickInterceptedException:
                try:
                    selenium_driver.execute_script("arguments[0].click();", Element)
                    if command == "check":
                        CommonUtil.ExecLog(
                            sModuleInfo,
                            "The element is checked successfully using Java Script",
                            1,
                        )
                    else:
                        CommonUtil.ExecLog(
                            sModuleInfo,
                            "The element is unchecked successfully using Java Script",
                            1,
                        )
                    return "passed"
                except:
                    if command == "check":
                        CommonUtil.ExecLog(
                            sModuleInfo, "The element couldn't be checked", 3
                        )
                    else:
                        CommonUtil.ExecLog(
                            sModuleInfo, "The element couldn't be unchecked", 3
                        )
                    return "zeuz_failed"
    except:
        if command == "check":
            CommonUtil.ExecLog(sModuleInfo, "The element couldn't be checked", 3)
        else:
            CommonUtil.ExecLog(sModuleInfo, "The element couldn't be unchecked", 3)
        return "zeuz_failed"


def insert(string, str_to_insert, index):
    return string[:index] + str_to_insert + string[index:]


@logger
def multiple_check_uncheck(data_set):
    """Check or uncheck multiple web elements"""

    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver

    use_js = False
    inside = False
    allow_hidden = ""
    try:
        for left, mid, right in data_set:
            left = left.lower().strip()
            mid = mid.lower().strip()
            if "use js" == left:
                use_js = right.strip().lower() in ("true", "yes", "ok")
            elif "allow hidden" == left:
                allow_hidden = right
            elif "target parameter" == mid:
                targets = []
                temp = right.strip()
                i = 0
                while True:
                    if i >= len(temp):
                        break
                    if temp[i] == "(":
                        inside = True
                        temp = insert(temp, '"', i + 1)
                    elif inside and temp[i] == ",":
                        temp = insert(temp, '"', i + 1)
                        temp = insert(temp, '"', i)
                        i += 1
                    if temp[i] == ")":
                        inside = False
                        temp = insert(temp, '"', i)
                        i += 1
                    i += 1
                temp = insert(temp, "[", 0)
                temp = insert(temp, "]", len(temp))
                temp = CommonUtil.parse_value_into_object(temp)
                for Left, Mid, Right in temp:
                    targets.append(
                        (Left.strip().lower(), Mid.strip(), Right.strip().lower())
                    )
                    # Stripped Mid if any trailing spaces exists need to use asterisk

    except Exception:
        return CommonUtil.Exception_Handler(
            sys.exc_info(), None, "Error parsing data set"
        )

    Element = LocateElement.Get_Element(data_set, selenium_driver)
    if Element == "zeuz_failed":
        CommonUtil.ExecLog(sModuleInfo, "Could not find the parent element", 3)
        return "zeuz_failed"

    element_params = []
    for left, mid, right in targets:
        if allow_hidden:
            element_params.append(
                [
                    ("allow hidden", "option", allow_hidden),
                    (left, "element parameter", mid),
                ]
            )
        else:
            element_params.append([(left, "element parameter", mid)])

    all_elements = []
    for i in element_params:
        all_elements.append(LocateElement.Get_Element(i, Element))

    for i in range(len(all_elements)):
        if all_elements[i] == "zeuz_failed":
            CommonUtil.ExecLog("", str(targets[i]) + " was not found so skipped it", 3)
            continue
        if targets[i][2] == "check" and all_elements[i].is_selected():
            CommonUtil.ExecLog(
                "", str(targets[i]) + " is already checked so skipped it", 1
            )
            continue
        if targets[i][2] == "uncheck" and not all_elements[i].is_selected():
            CommonUtil.ExecLog(
                "", str(targets[i]) + " is already unchecked so skipped it", 1
            )
            continue

        try:
            if use_js:
                selenium_driver.execute_script("arguments[0].click();", all_elements[i])
                if targets[i][2] == "check":
                    CommonUtil.ExecLog(
                        "",
                        str(targets[i]) + " is checked successfully using Java Script",
                        1,
                    )
                else:
                    CommonUtil.ExecLog(
                        "",
                        str(targets[i])
                        + " is unchecked successfully using Java Script",
                        1,
                    )
            else:
                try:
                    all_elements[i].click()
                    if targets[i][2] == "check":
                        CommonUtil.ExecLog(
                            "", str(targets[i]) + " is checked successfully", 1
                        )
                    else:
                        CommonUtil.ExecLog(
                            "", str(targets[i]) + " is unchecked successfully", 1
                        )
                except ElementClickInterceptedException:
                    try:
                        selenium_driver.execute_script(
                            "arguments[0].click();", all_elements[i]
                        )
                        if targets[i][2] == "check":
                            CommonUtil.ExecLog(
                                "",
                                str(targets[i])
                                + " is checked successfully using Java Script",
                                1,
                            )
                        else:
                            CommonUtil.ExecLog(
                                "",
                                str(targets[i])
                                + " is unchecked successfully using Java Script",
                                1,
                            )
                    except:
                        if targets[i][2] == "check":
                            CommonUtil.ExecLog(
                                "",
                                str(targets[i]) + " couldn't be checked so skipped it",
                                3,
                            )
                        else:
                            CommonUtil.ExecLog(
                                "",
                                str(targets[i])
                                + " couldn't be unchecked so skipped it",
                                3,
                            )
        except:
            if targets[i][2] == "check":
                CommonUtil.ExecLog(
                    "", str(targets[i]) + " couldn't be checked so skipped it", 3
                )
            else:
                CommonUtil.ExecLog(
                    "", str(targets[i]) + " couldn't be unchecked so skipped it", 3
                )

    return "passed"


@logger
def slider_bar(data_set):
    """Set certain value to a slider bar
    you must provide a number between 0 - 100
    """

    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        value = ""

        for left, mid, right in data_set:
            if "action" in mid:
                value = int(right.strip())
        # if value not in range(0, 100):
        #     CommonUtil.ExecLog(sModuleInfo, "Failed to parse data/locate element. You must provide a number between 0-100", 3)
        #     return "zeuz_failed"
        Element = LocateElement.Get_Element(data_set, selenium_driver)
        if Element == "zeuz_failed":
            CommonUtil.ExecLog(sModuleInfo, "Could not find the element", 3)
            return "zeuz_failed"
        else:
            CommonUtil.ExecLog(sModuleInfo, f"Moving the slider by %{value} ", 1)
            move = ActionChains(selenium_driver)
            height_width = Element.size
            ele_width = int((height_width)["width"])
            ele_height = int((height_width)["height"])
            x_cord_to_tap = (value / 100) * ele_width
            y_cord_to_tap = ele_height / 2

            move.move_to_element_with_offset(
                Element, x_cord_to_tap, y_cord_to_tap
            ).click().perform()
            CommonUtil.ExecLog(
                sModuleInfo, f"Successfully set the slider to %{value}", 1
            )

        return "passed"
    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())


@logger
def resize_window(step_data):
    """Action to resize window size"""
    """
    width          element parameter   50%
    height         element parameter   70%
    resize window  selenium action     resize window
    """
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        window_size = selenium_driver.get_window_size()
        CommonUtil.ExecLog(sModuleInfo, f"Current window size is {window_size}", 1)
        for left, mid, right in step_data:
            left = left.lower().strip()
            right = right.lower().strip()
            if "element parameter" in mid.lower():
                for dim in ["width", "height"]:
                    if left.lower().strip() == dim:
                        right = right.replace("%", "").strip()
                        try:
                            right = float(right)
                            window_size[dim] = window_size[dim] * right / 100
                        except:
                            CommonUtil.ExecLog(
                                sModuleInfo, f"Enter valid size for {dim}", 3
                            )
                            return CommonUtil.Exception_Handler(sys.exc_info())
        selenium_driver.set_window_size(window_size["width"], window_size["height"])
        CommonUtil.ExecLog(
            sModuleInfo, f"Successfully set the new window size to {window_size}", 1
        )
        return "passed"
    except Exception:
        return CommonUtil.Exception_Handler(
            sys.exc_info(), None, "Error resizing window"
        )


@deprecated
@logger
def if_element_exists(data_set):
    """if an element found, save a value to a variable"""

    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver
    try:
        variable_name = ""
        value = ""

        for left, mid, right in data_set:
            if "action" in mid:
                value, variable_name = right.split("=")
                value = value.strip()
                variable_name = variable_name.strip()

        Element = LocateElement.Get_Element(data_set, selenium_driver)
        if Element in failed_tag_list:
            Shared_Resources.Set_Shared_Variables(variable_name, "false")
        else:
            Shared_Resources.Set_Shared_Variables(variable_name, value)
        return "passed"
    except Exception:
        errMsg = (
            "Failed to parse data/locate element. Data format: variableName = value"
        )
        return CommonUtil.Exception_Handler(sys.exc_info(), None, errMsg)


@logger
def copy_image_into_browser(data_set):
    """
    This action will copy an image from path or a variable into browser, and later you can paste via ctrl+v or cmd+v.
    Supported formats: PNG, SVG

    Example 1:
    Field	                    Sub Field	            Value
    image file                  input parameter 	    %| image.png |%
    copy image into browser     selenium action 	    copy image into browser

    Example 2:
    Field	                    Sub Field	            Value
    image variable              input parameter         %| image_var |%
    copy image into browser     selenium action 	    copy image into browser
    """
    sModuleInfo = inspect.currentframe().f_code.co_name + " : " + MODULE_NAME
    global selenium_driver

    try:
        image_data = None
        image_path = ""
        variable_name = ""
        mime_type = "image/png"

        # Parse
        for left, mid, right in data_set:
            left = left.lower().replace(" ", "")
            mid = mid.lower().replace(" ", "")
            right = right.strip()

            if left == "imagefile":
                if os.path.exists(right):
                    image_path = right
                else:
                    image_path = CommonUtil.path_parser(right)

            elif left == "imagevariable":
                if os.path.exists(right):
                    image_path = right
                else:
                    variable_name = right

        if image_path:
            if not os.path.exists(image_path):
                CommonUtil.ExecLog(
                    sModuleInfo, f"Image file not found: {image_path}", 3
                )
                return "zeuz_failed"
        elif variable_name:
            image_path = Shared_Resources.Get_Shared_Variables(variable_name)
            if not image_path:
                CommonUtil.ExecLog(
                    sModuleInfo,
                    f"Image path not found in variable: {variable_name}. Make sure you must be use '%| |%' syntax for any variable or attachment.",
                    3,
                )
                return "zeuz_failed"
        else:
            CommonUtil.ExecLog(
                sModuleInfo, "Must provide either 'image file' or 'image variable'", 3
            )
            return "zeuz_failed"

        if image_path.lower().endswith(".svg"):
            mime_type = "image/svg+xml"
        elif image_path.lower().endswith(".png"):
            mime_type = "image/png"
        else:
            CommonUtil.ExecLog(
                sModuleInfo,
                "Unsupported file format. You can copy only PNG or SVG image.",
                2,
            )
            return "zeuz_failed"

        with open(image_path, "rb") as image_file:
            image_data = image_file.read()

        # Convert
        image_b64 = base64.b64encode(image_data).decode("utf-8")

        browser_name = selenium_driver.capabilities.get("browserName", "").lower()
        if browser_name in ("chrome", "microsoft edge", "edge"):
            try:
                selenium_driver.execute_cdp_cmd(
                    "Browser.setClipboard", {"data": image_b64, "type": mime_type}
                )
                CommonUtil.ExecLog(
                    sModuleInfo, f"Image copied to clipboard via CDP: {image_path}", 1
                )
                return "passed"
            except Exception as e:
                CommonUtil.ExecLog(
                    sModuleInfo, f"CDP failed ({str(e)}). Trying fallback method", 2
                )

        try:
            # Grant clipboard permissions via CDP if possible
            try:
                from urllib.parse import urlparse

                parsed_uri = urlparse(selenium_driver.current_url)
                origin = f"{parsed_uri.scheme}://{parsed_uri.netloc}"
                selenium_driver.execute_cdp_cmd(
                    "Browser.grantPermissions",
                    {
                        "origin": origin,
                        "permissions": [
                            "clipboardReadWrite",
                            "clipboardSanitizedWrite",
                        ],
                    },
                )
            except:
                pass

            async_script = """
            const [base64Data, mimeType, callback] = arguments;
            const byteCharacters = atob(base64Data);
            const byteArrays = [];
            
            for (let offset = 0; offset < byteCharacters.length; offset += 512) {
                const slice = byteCharacters.slice(offset, offset + 512);
                const byteNumbers = new Array(slice.length);
                
                for (let i = 0; i < slice.length; i++) {
                    byteNumbers[i] = slice.charCodeAt(i);
                }
                
                byteArrays.push(new Uint8Array(byteNumbers));
            }
            
            const blob = new Blob(byteArrays, {type: mimeType});
            const item = new ClipboardItem({ [mimeType]: blob });
            
            window.focus();
            navigator.clipboard.write([item])
                .then(() => {
                    console.log('Successfully copied image to clipboard.');
                    callback(true);
                })
                .catch(err => {
                    console.log('Failed to copy image to clipboard', err);
                    callback(false);
                });
            """

            selenium_driver.switch_to.window(selenium_driver.current_window_handle)
            selenium_driver.execute_script("window.focus();")

            success = selenium_driver.execute_async_script(
                async_script, image_b64, mime_type
            )
            if success:
                CommonUtil.ExecLog(
                    sModuleInfo, f"Image copied to clipboard: {image_path}", 1
                )
                return "passed"
            CommonUtil.ExecLog(
                sModuleInfo,
                f"Document is not focused. Failed to copy image to clipboard: {image_path}",
                3,
            )
            return "zeuz_failed"

        except Exception as e:
            CommonUtil.ExecLog(sModuleInfo, f"Fallback method failed: {str(e)}", 3)
            return "zeuz_failed"

    except Exception:
        return CommonUtil.Exception_Handler(sys.exc_info())