lib

def copy_placeholder_clip(destination: Path) -> Path:
    """Copy placeholder clip to the destination.

    Args:
        destination (Path): Destination directory.

    Returns:
        Path: Path to the copied clip.

    """
    clip_path = destination / "empty.exr"
    copyfile(
        Path(MOCHA_ADDON_ROOT) / "resources" / "empty.exr",
        clip_path
    )
    return clip_path

def create_empty_project(
        project_path: Optional[Path] = None) -> Project:
    """Create an empty project.

    Args:
        project_path (Path, optional): Project path. Defaults to None.

    Returns:
        Project: Project instance.

    """
    if not project_path:
        project_path = Path(tempfile.NamedTemporaryFile(  # noqa: SIM115
            suffix=".mocha", delete=False).name)

    clip_path = copy_placeholder_clip(project_path.parent)
    clip = Clip(clip_path.as_posix())
    return Project(clip)

def get_main_window() -> QtWidgets.QWidget:
    """Get the main window of the application.

    Returns:
        QWidget: Main window of the application.
    """
    return ui.get_widgets()["MainWindow"]

def get_mocha_version() -> Optional[str]:
    """Return Mocha version."""
    app_name = REGISTRY_APPLICATION_NAME
    result = re.search(
        r"Mocha Pro (?P<version>\d+\.?\d+)", app_name)
    return result["version"] if result else None

def get_shape_exporters() -> list[ExporterInfo]:
    """Return all registered shape exporters as a list."""
    version = get_mocha_version() or "2024"
    try:
        mapping = EXPORTER_MAPPING["shape"][version]
    except KeyError:
        mapping = EXPORTER_MAPPING["shape"]["2024.5"]

    return [
        ExporterInfo(
            id=sha256(k.encode()).hexdigest(),
            label=k,
            exporter=v,
            short_name=mapping.get(k, k)
        )
        for k, v in sorted(
            ShapeDataExporter.registered_exporters().items())
    ]

def get_tracking_exporters() -> list[ExporterInfo]:
    """Return all registered exporters as a list."""
    version = get_mocha_version() or "2024"
    try:
        mapping = EXPORTER_MAPPING["tracking"][version]
    except KeyError:
        mapping = EXPORTER_MAPPING["tracking"]["2024.5"]

    return [
        ExporterInfo(
            id=sha256(k.encode()).hexdigest(),
            label=k,
            exporter=v,
            short_name=mapping.get(k, k))
        for k, v in sorted(
            TrackingDataExporter.registered_exporters().items())
    ]

def quit_mocha() -> None:
    """Quit Mocha application."""
    # this code unfortunately doesn't work
    # menu_file = ui.get_menus()["MenuFile"]
    # quit_action = next(
    #   filter(lambda a: a.objectName() == "FileExit", menu_file.actions()))
    # quit_action.triggered.emit()
    # so we need to use this workaround
    QApplication.instance().quit()

def run_mocha(
        app: str = "mochapro",
        footage_path: str = "",
        **kwargs: dict[str, Any]) -> None:
    """Run Mocha application with given command-line arguments.

    See https://borisfx.com/support/documentation/mocha/#_command_line

    This is modified version of the original function from mocha module.
    We need to pass the environment to the subprocess.Popen call.

    Todo:
        - return something so we quit the parent app only if the new
            app is running
        - refactor this function to use the subprocess.run function

    Args:
        app (str): Application name (without an extension).
        footage_path (str): An absolute path to footage file.
        **kwargs: Keyword arguments for command line.

    Keywords mapping::

        in_point => --in
        out_point => --out
        frame_rate => --frame-rate
        par => --par
        interlace_mode => --interlace-mode

    Raises:
        ValueError: If unknown keyword argument is passed.

    """
    import os
    mocha_path = get_mocha_exec_name(app)
    if not os.path.isfile(mocha_path):
        return

    available_args = {
        "in_point": "in",
        "out_point": "out",
        "frame_rate": "frame-rate",
        "par": "par",
        "interlace_mode": "interlace-mode"
    }
    available_keys = set(available_args.keys())
    current_keys = set(kwargs.keys())
    if not current_keys <= available_keys:
        msg = (
            "No such parameters: "
            ", ".join(current_keys - available_keys)
        )
        raise ValueError(msg)

    cmd_args: list[str] = []
    for key, value in kwargs.items():
        cmd_args.extend((f"--{available_args[key]}", str(value)))
    cmd = [mocha_path, *cmd_args]
    if footage_path:
        cmd.append(footage_path)

    env = os.environ.copy()
    env["PYTHONPATH"] = os.pathsep.join(sys.path)
    if os.name == "nt":
        p = subprocess.Popen(
            cmd, creationflags=0x00000008, close_fds=True, env=env)
    else:
        p = subprocess.Popen(
            cmd, close_fds=True, env=env)
    p.poll()

def sanitize_unknown_exporter_name(name: str) -> str:
    """Sanitize unknown exporter name.

    Args:
        name (str): Exporter name.

    Returns:
        str: Sanitized exporter name

    """
    return re.sub(r"[^a-zA-Z0-9]", "_", name)

def update_ui() -> None:
    """Update the UI."""
    QApplication.processEvents()