hda_utils

def compute_thumbnail_rect(node):
    """Compute thumbnail bounding rect based on thumbnail parms"""
    offset_x = node.evalParm("thumbnail_offsetx")
    offset_y = node.evalParm("thumbnail_offsety")
    width = node.evalParm("thumbnail_size")
    # todo: compute height from aspect of actual image file.
    aspect = 0.5625  # for now assume 16:9
    height = width * aspect

    center = 0.5
    half_width = width * 0.5

    return hou.BoundingRect(
        offset_x + center - half_width,
        offset_y,
        offset_x + center + half_width,
        offset_y + height,
    )

def ensure_loader_expression_parm_defaults(node):
    """Reset `representation` and `file` parm to defaults.

    The filepath and representation id parms are updated through expressions,
    however in older versions they were explicitly set so we ensure that the
    current value is set to the default value with the expression - otherwise
    the value will be set to the previously explicitly set overridden value.

    Silently ignores if the parm does not exist or is already at default.

    Args:
        node (hou.OpNode): The node to reset.

    """
    for parm_name in ["representation", "file"]:
        parm = node.parm(parm_name)
        if parm is None:
            continue

        # TODO: For whatever reason this still returns True even if the
        #  expression does not match the default, so for now we always revert
        # if parm.isAtDefault(compare_expressions=True):
        #     continue

        default_expression = parm.parmTemplate().defaultExpression()
        if not default_expression:
            continue

        default_expression = default_expression[0]

        try:
            current_expression = parm.expression()
            if current_expression == default_expression:
                continue
        except hou.OperationFailed:
            pass

        print(f"Enforcing {parm.path()} to default value")
        locked = parm.isLocked()
        parm.lock(False)
        parm.deleteAllKeyframes()
        parm.revertToDefaults()
        parm.lock(locked)

def get_available_representations(node):
    """Return the representation list for node.

    Args:
        node (hou.Node): Node to query selected version's representations for.

    Returns:
        list[str]: representation names for the product version.
    """

    project_name = node.evalParm("project_name") or get_current_project_name()
    folder_path = node.evalParm("folder_path")
    product_name = node.evalParm("product_name")
    version = node.evalParm("version")

    if not all([project_name, folder_path, product_name, version]):
        return []

    # Use wildcard entity URI to find all representations in the context
    # to also support version values like 'latest' and 'hero'
    uri = _construct_ayon_entity_uri_str(
        project_name,
        folder_path,
        product_name,
        version,
        representation_name="*"
    )
    entities = _resolve_entity_uri(uri)
    representation_ids = {
        entity["representationId"] for entity in entities
    }

    # Refreshing Nodes Parm States
    node.updateParmStates()

    representation_filter = None
    filter_parm = node.parm("representation_filter")
    if filter_parm and not filter_parm.isDisabled() and filter_parm.eval():
        representation_filter = filter_parm.eval().split(" ")

    representations = get_representations(
        project_name,
        fields={"name", "attrib.path"},
        representation_ids=representation_ids,
        representation_names=representation_filter,
    )
    extension_filter = set()
    filter_parm = node.parm("extension_filter")
    if filter_parm and not filter_parm.isDisabled() and filter_parm.eval():
        extension_filter = set(filter_parm.eval().split(" "))

    representations_names = []
    for n in representations:
        if extension_filter:
            _, ext = lib.splitext(
                n["attrib"]["path"], allowed_multidot_extensions=[
                    ".ass.gz", ".bgeo.sc", ".bgeo.gz",
                    ".bgeo.lzma", ".bgeo.bz2"]
            )
            if ext not in extension_filter:
                continue
        representations_names.append(n["name"])
    return representations_names

def get_available_versions(
        node,
        include_latest=True,
        include_hero=True,
        include_latest_done=True,
    ):
    """Return the version as list for node.

    The versions are sorted with the latest version first and oldest lower
    version last.

    Args:
        node (hou.Node): Node to query selected products' versions for.
        include_latest (bool): Whether to include a dedicated 'latest' option.
        include_hero (bool): Whether to include hero version if it exists.

    Returns:
        list[str | int]: Available version names for the product
    """

    project_name = node.evalParm("project_name") or get_current_project_name()
    folder_path = node.evalParm("folder_path")
    product_name = node.evalParm("product_name")

    # Always include "latest" as an option
    all_version_names: list[Union[str, int]] = []
    if include_latest:
        all_version_names.append("latest")
    if include_latest_done:
        all_version_names.append("latestDone")

    if not all([project_name, folder_path, product_name]):
        return all_version_names

    folder_entity = get_folder_by_path(
        project_name, folder_path, fields={"id"}
    )
    if not folder_entity:
        return all_version_names
    product_entity = get_product_by_name(
        project_name,
        product_name=product_name,
        folder_id=folder_entity["id"],
        fields={"id"},
    )
    if not product_entity:
        return all_version_names

    versions = get_versions(
        project_name,
        product_ids={product_entity["id"]},
        fields={"version"},
        hero=include_hero,
    )
    def _sort_versions(version: dict) -> float:
        # Hero versions are negative and should be just below their non-hero
        # positive equivalents, like 1, 2, 3, -4, 4.
        num: int = version["version"]
        return float(abs(num) - (int(num < 0) * 0.5))

    for version in sorted(versions, key=_sort_versions, reverse=True):
        all_version_names.append(version["version"])
    return all_version_names

def get_filepath_from_context(context: dict):
    """Format file path for sequence with $F or <UDIM>."""
    # The path is either a single file or sequence in a folder.
    # Format frame as $F and udim as <UDIM>
    representation = context["representation"]
    frame = representation["context"].get("frame")
    udim = representation["context"].get("udim")
    if frame is not None or udim is not None:
        template: str = representation["attrib"]["template"]
        repre_context: dict = dict(representation["context"])
        if udim is not None:
            repre_context["udim"] = "<UDIM>"
            template = _remove_format_spec(template, "udim")
        if frame is not None:
            # Substitute frame number in sequence with $F with padding
            repre_context["frame"] = "$F{}".format(len(frame))  # e.g. $F4
            template = _remove_format_spec(template, "frame")

        project_name: str = repre_context["project"]["name"]
        anatomy = Anatomy(project_name, project_entity=context["project"])
        repre_context["root"] = anatomy.roots
        path = StringTemplate(template).format(repre_context)
    else:
        path = get_representation_path_from_context(context)

    # Load fails on UNC paths with backslashes and also
    # fails to resolve @sourcename var with backslashed
    # paths correctly. So we force forward slashes
    return os.path.normpath(path).replace("\\", "/")

def get_representation_id(
    project_name,
    folder_path,
    product_name,
    version,
    representation_name,
):
    """Get representation id.

    Args:
        project_name (str): Project name
        folder_path (str): Folder name
        product_name (str): Product name
        version (str): Version name as string
        representation_name (str): Representation name

    Returns:
        str: Representation id.

    Raises:
        ValueError: If the entity could not be resolved with input values.

    """
    if not all(
        [project_name, folder_path, product_name, version, representation_name]
    ):
        labels = {
            "project": project_name,
            "folder": folder_path,
            "product": product_name,
            "version": version,
            "representation": representation_name,
        }
        missing = ", ".join(key for key, value in labels.items() if not value)
        raise ValueError(f"Load info incomplete. Found empty: {missing}")

    entity_uri: str = _construct_ayon_entity_uri_str(
        project_name=project_name,
        folder_path=folder_path,
        product=product_name,
        version=version,
        representation_name=representation_name
    )
    try:
        entities = _resolve_entity_uri(entity_uri)
    except RuntimeError as exc:
        raise ValueError(exc)

    if len(entities) != 1:
        raise ValueError(
            f"Unable to find a matching entity for {entity_uri}"
        )

    return entities[0]["representationId"]

def get_session_cache() -> dict:
    """Get a persistent `hou.session.ayon_cache` dict"""
    cache = getattr(hou.session, "ayon_cache", None)
    if cache is None:
        hou.session.ayon_cache = cache = {}
    return cache

def is_valid_uuid(value) -> bool:
    """Return whether value is a valid UUID"""
    try:
        uuid.UUID(value)
    except ValueError:
        return False
    return True

def keep_background_images_linked(node, old_name):
    """Reconnect background images to node from old name.

    Used as callback on node name changes to keep thumbnails linked."""
    from ayon_houdini.api.lib import (
        get_background_images,
        set_background_images,
    )

    parent = node.parent()
    images = get_background_images(parent)
    if not images:
        return

    changes = False
    old_path = f"{node.parent().path()}/{old_name}"
    for image in images:
        if image.relativeToPath() == old_path:
            image.setRelativeToPath(node.path())
            changes = True

    if changes:
        set_background_images(parent, images)

def load_adapted_stylesheet(widget: QtWidgets.QWidget) -> str:
    """
    Loads and adapts AYON's stylesheet for Houdini.

    This function retrieves AYON's Qt stylesheet, modifies it to convert font
    sizes from points (pt) to pixels (px), and caches the result for future
    use.

    Houdini seems to handle pixels more gracefully than points on Windows, but
    using pixels across the board creates more problems, so we keep this fix
    local until a better solution emerges.

    Returns:
        str: The adapted stylesheet as a string.
    """
    dpr = widget.screen().devicePixelRatio()
    try:
        return load_adapted_stylesheet.cache[dpr]
    except AttributeError:
        setattr(load_adapted_stylesheet, "cache", {})
    except KeyError:
        pass

    # if we arrive here, a new cache entry must be created.
    hou.logging.log(
        hou.logging.LogEntry(
            message=f"load_adapted_stylesheet: new cache entry: {dpr}",
            source="AYON",
        )
    )

    def _convert(match):
        size = int((int(match.group(2)) * 1.1) * hou.ui.globalScaleFactor())
        size = int(size / dpr)
        return f"{match.group(1)}{size}px;"

    css = load_stylesheet()
    css = re.sub(r"(font-size:\s+)(\d+)pt;", _convert, css)  # type: ignore
    load_adapted_stylesheet.cache[dpr] = css

    return load_adapted_stylesheet.cache[dpr]

def on_flag_changed(node, **kwargs):
    """On node flag changed callback.

    Updates the brightness of attached thumbnails
    """
    # Showing thumbnail is disabled so can return early since
    # there should be no thumbnail to update.
    if not node.evalParm("show_thumbnail"):
        return

    # Update node thumbnails brightness with the
    # bypass state of the node.
    parent = node.parent()
    images = lib.get_background_images(parent)
    if not images:
        return

    # This may trigger on a node that can't be bypassed, like `ObjNode` so
    # consider those never bypassed
    is_bypassed = hasattr(node, "isBypassed") and node.isBypassed()
    brightness = 0.3 if is_bypassed else 1.0
    has_changes = False
    node_path = node.path()
    for image in images:
        if image.relativeToPath() == node_path:
            image.setBrightness(brightness)
            has_changes = True

    if has_changes:
        lib.set_background_images(parent, images)

def on_thumbnail_show_changed(node):
    """Callback on thumbnail show parm changed"""
    update_thumbnail(node)

def on_thumbnail_size_changed(node):
    """Callback on thumbnail offset or size parms changed"""
    thumbnail = lib.get_node_thumbnail(node)
    if thumbnail:
        rect = compute_thumbnail_rect(node)
        thumbnail.setRect(rect)
        lib.set_node_thumbnail(node, thumbnail)

def select_folder_path(node):
    """Show dialog to select folder path.

    When triggered it opens a dialog that shows the available
    folder paths within a given project.

    Note:
        This function should be refactored.
        It currently shows the available
          folder paths within the current project only.

    Args:
        node (hou.OpNode): The HDA node.
    """
    cursor_pos = QtGui.QCursor.pos()

    main_window = lib.get_main_window()

    project_name = node.evalParm("project_name")
    folder_path = node.evalParm("folder_path")

    dialog = SelectFolderPathDialog(parent=main_window)
    dialog.set_project_name(project_name)
    if folder_path:
        # We add a small delay to the setting of the selected folder
        # because the folder widget's set project logic itself also runs
        # with a bit of a delay, and unfortunately otherwise the project
        # has not been selected yet and thus selection does not work.
        def _select_folder_path():
            dialog.folder_widget.set_selected_folder_path(folder_path)

        QtCore.QTimer.singleShot(100, _select_folder_path)

    dialog.setStyleSheet(load_adapted_stylesheet(dialog))

    # Make it appear like a pop-up near cursor - use session's last width
    dialog.setMinimumWidth(300)
    dialog.setFixedHeight(600)
    dialog.resize(SelectFolderPathDialog.last_width, 600)
    dialog.setWindowFlags(QtCore.Qt.Popup)
    pos = dialog.mapToGlobal(
        cursor_pos - QtCore.QPoint(SelectFolderPathDialog.last_width, 0)
    )
    dialog.move(pos)

    result = dialog.exec_()
    if result != QtWidgets.QDialog.Accepted:
        return

    # Set project
    selected_project_name = dialog.get_selected_project_name()
    if selected_project_name == get_current_project_name():
        selected_project_name = "$AYON_PROJECT_NAME"

    project_parm = node.parm("project_name")
    project_parm.set(selected_project_name)
    project_parm.pressButton()  # allow any callbacks to trigger

    # Set folder path
    selected_folder_path = dialog.get_selected_folder_path()
    if not selected_folder_path:
        # Do nothing if user accepted with nothing selected
        return

    if selected_folder_path == get_current_folder_path():
        selected_folder_path = "$AYON_FOLDER_PATH"

    folder_parm = node.parm("folder_path")
    folder_parm.set(selected_folder_path)
    folder_parm.pressButton()  # allow any callbacks to trigger

def select_product_name(node):
    """Show a modal pop-up dialog to allow user to select a product name
    under the current folder entity as defined on the node's parameters.

    Applies the chosen value to the `product_name` parm on the node."""

    cursor_pos = QtGui.QCursor.pos()

    project_name = node.evalParm("project_name")
    folder_path = node.evalParm("folder_path")
    product_parm = node.parm("product_name")

    folder_entity = ayon_api.get_folder_by_path(
        project_name, folder_path, fields={"id"}
    )
    if not folder_entity:
        return

    dialog = SelectProductDialog(
        project_name, folder_entity["id"], parent=lib.get_main_window()
    )
    dialog.set_selected_product_name(product_parm.eval())

    dialog.resize(300, 600)
    dialog.setWindowFlags(QtCore.Qt.Popup)
    pos = dialog.mapToGlobal(cursor_pos - QtCore.QPoint(300, 0))
    dialog.move(pos)
    result = dialog.exec_()

    if result != QtWidgets.QDialog.Accepted:
        return
    selected_product = dialog.get_selected_product()

    if selected_product:
        product_parm.set(selected_product)
        product_parm.pressButton()  # allow any callbacks to trigger

def set_node_representation_from_context(
    node, context, ensure_expression_defaults=True
):
    """Update project, folder, product, version, representation name parms.

    Arguments:
        node (hou.Node): Node to update
        context (dict): Context of representation
        ensure_expression_defaults (bool): Ensure expression defaults.

    """
    # TODO: Avoid 'duplicate' taking over the expression if originally
    #       it was $OS and by duplicating, e.g. the `folder` does not exist
    #       anymore since it is now `hero1` instead of `hero`
    # TODO: Support hero versions
    version = str(context["version"]["version"])

    # We only set the values if the value does not match the currently
    # evaluated result of the other parms, so that if the project name
    # value was dynamically set by the user with an expression or alike
    # then if it still matches the value of the current representation id
    # we preserve it. In essence, only update the value if the current
    # *evaluated* value of the parm differs.
    parms = {
        "project_name": context["project"]["name"],
        "folder_path": context["folder"]["path"],
        "product_name": context["product"]["name"],
        "version": version,
        "representation_name": context["representation"]["name"],
    }
    parms = {
        key: value
        for key, value in parms.items()
        if node.evalParm(key) != value
    }
    node.setParms(parms)

    if ensure_expression_defaults:
        ensure_loader_expression_parm_defaults(node)

def set_node_thumbnail(node, thumbnail: str):
    """Update node thumbnail to thumbnail"""
    if thumbnail is None:
        lib.set_node_thumbnail(node, None)
        return

    rect = compute_thumbnail_rect(node)
    lib.set_node_thumbnail(node, thumbnail, rect)

def set_to_latest_version(node):
    """Callback on product name change

    Refresh version and representation parameters value by setting
    their value to the latest version and representation of
    the selected product.

    Args:
        node (hou.OpNode): The HDA node.
    """

    # Get available versions, excluding the 'latest' key
    versions = get_available_versions(
        node, include_latest=False, include_latest_done=False
        )
    if versions:
        node.parm("version").set(str(versions[0]))

    representations = get_available_representations(node)
    if representations:
        node.parm("representation_name").set(representations[0])
    else:
        node.parm("representation_name").set("")

def setup_flag_changed_callback(node):
    """Register flag changed callback (for thumbnail brightness)"""
    node.addEventCallback((hou.nodeEventType.FlagChanged,), on_flag_changed)