lib

def add_path_mapping() -> None:
    """This function reads the path mappings from the project
    settings and adds them to Hiero's path mapping table.
    """
    def _parse_remaps(remap_str: str) -> set[tuple[str, str, str]]:
        """Parse a remap string into a set of path mapping tuples."""
        tokens = remap_str.rstrip(";").split(";")
        return {tuple(tokens[i:i + 3]) for i in range(0, len(tokens) - 2, 3)}

    def _remaps_to_str(remaps: set[tuple[str, str, str]]) -> str:
        return "".join(";".join(r) + ";" for r in sorted(remaps))

    current_project_name = get_current_project_name()
    configured_path_mappings = _configured_path_mappings(current_project_name)
    preferences = nuke.toNode("preferences")
    remap_knob = preferences["platformPathRemaps"]
    if not configured_path_mappings:
        return

    # Clear previously remapping set by AYON.
    ayon_knob = preferences.knob("ayon_path_remapping")
    remaps = _parse_remaps(remap_knob.toScript())
    if ayon_knob is not None:
        # Remove previously set AYON remaps
        remaps -= _parse_remaps(ayon_knob.value())
    else:
        # Create the knob if it doesn't exist
        ayon_knob = nuke.String_Knob("ayon_path_remapping", "AYON Path Remapping")
        ayon_knob.setFlag(nuke.INVISIBLE)
        preferences.addKnob(ayon_knob)

    # Add configured path mappings
    # Convert to set of tuples once
    configured_set = {tuple(m) for m in configured_path_mappings}
    remaps |= configured_set

  # Add to Hiero if not already present
    hiero_remaps = hiero.core.pathRemappings()
    for path_tuple in configured_set:
        if list(path_tuple) not in hiero_remaps:
            hiero.core.addPathRemap(*path_tuple)

    # Update knobs
    remap_knob.fromScript(_remaps_to_str(remaps))
    ayon_knob.setValue(_remaps_to_str(configured_set))

    _persist_prefs_knobs(preferences, ["platformPathRemaps", "ayon_path_remapping"])

def apply_colorspace_project():
    """Apply colorspaces from settings.

    Due to not being able to set the project settings through the Python API,
    we need to do use some dubious code to find the widgets and set them. It is
    possible to set the project settings without traversing through the widgets
    but it involves reading the hrox files from disk with XML, so no in-memory
    support. See https://community.foundry.com/discuss/topic/137771/change-a-project-s-default-color-transform-with-python  # noqa
    for more details.
    """
    # get presets for hiero
    project_name = get_current_project_name()
    imageio = get_project_settings(project_name)["hiero"]["imageio"]
    presets = imageio.get("workfile")

    # Open Project Settings UI.
    for act in hiero.ui.registeredActions():
        if act.objectName() == "foundry.project.settings":
            act.trigger()

    # Find widgets from their sibling label.
    labels = {
        "Working Space:": "workingSpace",
        "Viewer:": "viewerLut",
        "Thumbnails:": "thumbnailLut",
        "Monitor Out:": "monitorOutLut",
        "8 Bit Files:": "eightBitLut",
        "16 Bit Files:": "sixteenBitLut",
        "Log Files:": "logLut",
        "Floating Point Files:": "floatLut",
    }
    widgets = {x: None for x in labels.values()}

    def _recursive_children(widget, labels, widgets):
        children = widget.children()
        for count, child in enumerate(children):
            if isinstance(child, QtWidgets.QLabel):
                if child.text() in labels.keys():
                    widgets[labels[child.text()]] = children[count + 1]
            _recursive_children(child, labels, widgets)

    app = QtWidgets.QApplication.instance()
    title = "Project Settings"
    for widget in app.topLevelWidgets():
        if isinstance(widget, QtWidgets.QMainWindow):
            if widget.windowTitle() != title:
                continue
            _recursive_children(widget, labels, widgets)
            widget.close()

    msg = "Setting value \"{}\" is not a valid option for \"{}\""
    for key, widget in widgets.items():
        options = [
            widget.itemText(i) for i in range(widget.count())
            if "Error:" not in widget.itemText(i)
        ]
        setting_value = presets[key]
        found = False
        for option in options:
            if setting_value in option:
                found = True
                break
        assert found, msg.format(setting_value, key)
        log.info(f"Setting {key} to {setting_value}")
        # Find the index of the setting value in the widget options
        for i in range(widget.count()):
            if setting_value in widget.itemText(i):
                widget.setCurrentIndex(i)
                break

def check_inventory_versions(track_items=None):
    """
    Actual version color identifier of Loaded containers

    Check all track items and filter only
    Loader nodes for its version. It will get all versions from database
    and check if the node is having actual version. If not then it will color
    it to red.
    """
    from . import parse_container

    track_items = track_items or get_track_items()
    # presets
    clip_color_last = "green"
    clip_color = "red"

    containers = []
    # Find all containers and collect it's node and representation ids
    for track_item in track_items:
        container = parse_container(track_item)
        if container:
            containers.append(container)

    # Skip if nothing was found
    if not containers:
        return

    project_name = get_current_project_name()
    filter_result = filter_containers(containers, project_name)
    for container in filter_result.latest:
        set_track_color(container["_item"], clip_color_last)

    for container in filter_result.outdated:
        set_track_color(container["_item"], clip_color)

def create_bin(path=None, project=None):
    '''
    Create bin in project.
    If the path is "bin1/bin2/bin3" it will create whole depth
    and return `bin3`

    '''
    # get the first loaded project
    project = project or get_current_project()

    path = path or DEFAULT_BIN_NAME

    path = path.replace("\\", "/").split("/")

    root_bin = project.clipsBin()

    done_bin_lst = []
    for i, b in enumerate(path):
        if i == 0 and len(path) > 1:
            if b in [bin.name() for bin in root_bin.bins()]:
                bin = [bin for bin in root_bin.bins() if b in bin.name()][0]
                done_bin_lst.append(bin)
            else:
                create_bin = hiero.core.Bin(b)
                root_bin.addItem(create_bin)
                done_bin_lst.append(create_bin)

        elif i >= 1 and i < len(path) - 1:
            if b in [bin.name() for bin in done_bin_lst[i - 1].bins()]:
                bin = [
                    bin for bin in done_bin_lst[i - 1].bins()
                    if b in bin.name()
                ][0]
                done_bin_lst.append(bin)
            else:
                create_bin = hiero.core.Bin(b)
                done_bin_lst[i - 1].addItem(create_bin)
                done_bin_lst.append(create_bin)

        elif i == len(path) - 1:
            if b in [bin.name() for bin in done_bin_lst[i - 1].bins()]:
                bin = [
                    bin for bin in done_bin_lst[i - 1].bins()
                    if b in bin.name()
                ][0]
                done_bin_lst.append(bin)
            else:
                create_bin = hiero.core.Bin(b)
                done_bin_lst[i - 1].addItem(create_bin)
                done_bin_lst.append(create_bin)

    return done_bin_lst[-1]

def create_nuke_workfile_clips(nuke_workfiles, seq=None):
    '''
    nuke_workfiles is list of dictionaries like:
    [{
        'path': 'P:/Jakub_testy_pipeline/test_v01.nk',
        'name': 'test',
        'handleStart': 15, # added asymmetrically to handles
        'handleEnd': 10, # added asymmetrically to handles
        "clipIn": 16,
        "frameStart": 991,
        "frameEnd": 1023,
        'task': 'Comp-tracking',
        'work_dir': 'VFX_PR',
        'shot': '00010'
    }]
    '''

    proj = hiero.core.projects()[-1]
    root = proj.clipsBin()

    if not seq:
        seq = hiero.core.Sequence('NewSequences')
        root.addItem(hiero.core.BinItem(seq))
    # todo will need to define this better
    # track = seq[1]  # lazy example to get a destination#  track
    clips_lst = []
    for nk in nuke_workfiles:
        task_path = '/'.join([nk['work_dir'], nk['shot'], nk['task']])
        bin = create_bin(task_path, proj)

        if nk['task'] not in seq.videoTracks():
            track = hiero.core.VideoTrack(nk['task'])
            seq.addTrack(track)
        else:
            track = seq.tracks(nk['task'])

        # create clip media
        media = hiero.core.MediaSource(nk['path'])
        media_in = int(media.startTime() or 0)
        media_duration = int(media.duration() or 0)

        handle_start = nk.get("handleStart")
        handle_end = nk.get("handleEnd")

        if media_in:
            source_in = media_in + handle_start
        else:
            source_in = nk["frameStart"] + handle_start

        if media_duration:
            source_out = (media_in + media_duration - 1) - handle_end
        else:
            source_out = nk["frameEnd"] - handle_end

        source = hiero.core.Clip(media)

        name = os.path.basename(os.path.splitext(nk['path'])[0])
        split_name = split_by_client_version(name)[0] or name

        # add to bin as clip item
        items_in_bin = [b.name() for b in bin.items()]
        if split_name not in items_in_bin:
            binItem = hiero.core.BinItem(source)
            bin.addItem(binItem)

        new_source = [
            item for item in bin.items() if split_name in item.name()
        ][0].items()[0].item()

        # add to track as clip item
        trackItem = hiero.core.TrackItem(
            split_name, hiero.core.TrackItem.kVideo)
        trackItem.setSource(new_source)
        trackItem.setSourceIn(source_in)
        trackItem.setSourceOut(source_out)
        trackItem.setTimelineIn(nk["clipIn"])
        trackItem.setTimelineOut(nk["clipIn"] + (source_out - source_in))
        track.addTrackItem(trackItem)
        clips_lst.append(trackItem)

    return clips_lst

def deprecated(new_destination):
    """Mark functions as deprecated.

    It will result in a warning being emitted when the function is used.
    """

    func = None
    if callable(new_destination):
        func = new_destination
        new_destination = None

    def _decorator(decorated_func):
        if new_destination is None:
            warning_message = (
                " Please check content of deprecated function to figure out"
                " possible replacement."
            )
        else:
            warning_message = " Please replace your usage with '{}'.".format(
                new_destination
            )

        @functools.wraps(decorated_func)
        def wrapper(*args, **kwargs):
            warnings.simplefilter("always", DeprecatedWarning)
            warnings.warn(
                (
                    "Call to deprecated function '{}'"
                    "\nFunction was moved or removed.{}"
                ).format(decorated_func.__name__, warning_message),
                category=DeprecatedWarning,
                stacklevel=4
            )
            return decorated_func(*args, **kwargs)
        return wrapper

    if func is None:
        return _decorator
    return _decorator(func)

def get_current_sequence(name=None, new=False):
    """
    Get current sequence in context of active project.

    Args:
        name (str)[optional]: name of sequence we want to return
        new (bool)[optional]: if we want to create new one

    Returns:
        hiero.core.Sequence: the sequence object
    """
    sequence = None
    project = get_current_project()
    root_bin = project.clipsBin()

    if new:
        # create new
        name = name or DEFAULT_SEQUENCE_NAME
        sequence = hiero.core.Sequence(name)
        root_bin.addItem(hiero.core.BinItem(sequence))
    elif name:
        # look for sequence by name
        sequences = project.sequences()
        for _sequence in sequences:
            if _sequence.name() == name:
                sequence = _sequence
        if not sequence:
            # if nothing found create new with input name
            sequence = get_current_sequence(name, True)
    else:
        # if name is none and new is False then return current open sequence
        sequence = hiero.ui.activeSequence()

    return sequence

def get_current_track(sequence, name, audio=False):
    """
    Get current track in context of active project.

    Creates new if none is found.

    Args:
        sequence (hiero.core.Sequence): hiero sequence object
        name (str): name of track we want to return
        audio (bool)[optional]: switch to AudioTrack

    Returns:
        hiero.core.Track: the track object
    """
    tracks = sequence.videoTracks()

    if audio:
        tracks = sequence.audioTracks()

    # get track by name
    track = None
    for _track in tracks:
        if _track.name() == name:
            track = _track

    if not track:
        if not audio:
            track = hiero.core.VideoTrack(name)
        else:
            track = hiero.core.AudioTrack(name)

        sequence.addTrack(track)

    return track

def get_main_window():
    """Acquire Nuke's main window"""
    if _CTX.parent_gui is None:
        top_widgets = QtWidgets.QApplication.topLevelWidgets()
        name = "Foundry::UI::DockMainWindow"
        main_window = next(widget for widget in top_widgets if
                           widget.inherits("QMainWindow") and
                           widget.metaObject().className() == name)
        _CTX.parent_gui = main_window
    return _CTX.parent_gui

def get_sequence_pattern_and_padding(file):
    """ Return sequence pattern and padding from file

    Attributes:
        file (string): basename form path

    Example:
        Can find file.0001.ext, file.%02d.ext, file.####.ext

    Return:
        string: any matching sequence pattern
        int: padding of sequence numbering
    """
    foundall = re.findall(
        r"(#+)|(%\d+d)|(?<=[^a-zA-Z0-9])(\d+)(?=\.\w+$)", file)
    if not foundall:
        return None, None
    found = sorted(list(set(foundall[0])))[-1]

    padding = int(
        re.findall(r"\d+", found)[-1]) if "%" in found else len(found)
    return found, padding

def get_track_ayon_data(track, container_name=None):
    """
    Get track's AYON tag data.

    Data of legacy (OpenPype) tag are returned if the track does not
    have AYON tag.

    Attributes:
        track (hiero.core.VideoTrack): hiero object

    Returns:
        dict: data found on the AYON tag
    """
    tag = _get_ayon_tag(track, legacy=True)
    if not tag:
        return None

    return_data = {}
    for obj_name, obj_data in tags.get_tag_data(tag, legacy=True).items():
        if isinstance(obj_data, str):
            # legacy tag stored each container as json string
            try:
                obj_data = json.loads(obj_data)
            except json.JSONDecodeError:
                continue

        if isinstance(obj_data, dict):
            return_data[obj_name] = obj_data

    return (
        return_data[container_name]
        if container_name
        else return_data
    )

def get_track_ayon_tag(track, tag_name=AYON_TAG_NAME):
    """
    Get AYON track tag created by loader plugin.

    Attributes:
        track (hiero.core.VideoTrack): hiero object
        tag_name (str): The tag name.

    Returns:
        hiero.core.Tag: hierarchy, orig clip attributes
    """
    return _get_ayon_tag(track, tag_name)

def get_track_item_tags(track_item):
    """
    Get track item tags excluding AYON tag

    Attributes:
        trackItem (hiero.core.TrackItem): hiero object

    Returns:
        hiero.core.Tag: hierarchy, orig clip attributes
    """
    returning_tag_data = []
    # get all tags from track item
    _tags = track_item.tags()
    if not _tags:
        return []

    # collect all tags which are not AYON tag
    returning_tag_data.extend(
        tag for tag in _tags
        if AYON_TAG_NAME not in tag.name()
    )

    return returning_tag_data

def get_track_items(
        selection=False,
        sequence_name=None,
        track_item_name=None,
        track_name=None,
        track_type=None,
        check_enabled=True,
        check_locked=True,
        check_tagged=False):
    """Get all available current timeline track items.

    Attribute:
        selection (list)[optional]: list of selected track items
        sequence_name (str)[optional]: return only clips from input sequence
        track_item_name (str)[optional]: return only item with input name
        track_name (str)[optional]: return only items from track name
        track_type (str)[optional]: return only items of given type
                                    (`audio` or `video`) default is `video`
        check_enabled (bool)[optional]: ignore disabled if True
        check_locked (bool)[optional]: ignore locked if True

    Return:
        list or hiero.core.TrackItem: list of track items or single track item
    """
    track_type = track_type or "video"
    selection = selection or []
    return_list = []

    # get selected track items or all in active sequence
    if selection:
        try:
            for track_item in selection:
                log.info("___ track_item: {}".format(track_item))
                # make sure only trackitems are selected
                if not isinstance(track_item, hiero.core.TrackItem):
                    continue

                if _validate_all_atrributes(
                    track_item,
                    track_item_name,
                    track_name,
                    track_type,
                    check_enabled,
                    check_tagged
                ):
                    log.info("___ valid trackitem: {}".format(track_item))
                    return_list.append(track_item)
        except AttributeError:
            pass

    # collect all available active sequence track items
    if not return_list:
        sequence = get_current_sequence(name=sequence_name)
        tracks = []
        if sequence is not None:
            # get all available tracks from sequence
            tracks.extend(sequence.audioTracks())
            tracks.extend(sequence.videoTracks())

        # loop all tracks
        for track in tracks:
            if check_locked and track.isLocked():
                continue
            if check_enabled and not track.isEnabled():
                continue
            # and all items in track
            for track_item in track.items():
                # make sure no subtrackitem is also track items
                if not isinstance(track_item, hiero.core.TrackItem):
                    continue

                if _validate_all_atrributes(
                    track_item,
                    track_item_name,
                    track_name,
                    track_type,
                    check_enabled,
                    check_tagged
                ):
                    return_list.append(track_item)

    return return_list

def get_trackitem_ayon_data(track_item):
    """
    Get track item's AYON tag data.

    Data of legacy (OpenPype) tag are returned if the track item does not
    have AYON tag.

    Attributes:
        trackItem (hiero.core.TrackItem): hiero object

    Returns:
        dict: data found on the AYON tag
    """
    tag = _get_ayon_tag(track_item, legacy=True)
    if not tag:
        return None

    return tags.get_tag_data(tag, legacy=True)

def get_trackitem_ayon_tag(track_item, tag_name=AYON_TAG_NAME):
    """
    Get AYON track item tag created by creator or loader plugin.

    Attributes:
        trackItem (hiero.core.TrackItem): hiero object
        tag_name (str): The tag name.

    Returns:
        hiero.core.Tag: hierarchy, orig clip attributes
    """
    return _get_ayon_tag(track_item, tag_name)

def imprint(track_item, data=None):
    """
    Adding AYON data into a hiero track item tag.

    Arguments:
        track_item (hiero.core.TrackItem): hiero track item object
        data (dict): Any data which needs to be imprinted

    Examples:
        data = {
            'folderPath': '/shots/sq020sh0280',
            'productBaseType': 'render',
            'productName': 'productMain'
        }
    """
    data = data or {}

    set_trackitem_ayon_tag(track_item, data)

def launch_workfiles_app(event):
    """
    Event for launching workfiles after hiero start

    Args:
        event (obj): required but unused
    """
    from . import launch_workfiles_app
    launch_workfiles_app()

def remove_legacy_tags(item):
    """Remove legacy (OpenPype) tags from track or track item.

    Args:
        item (Union[hiero.core.TrackItem, hiero.core.VideoTrack]): hiero
            object
    """
    for tag in item.tags():
        if LEGACY_OPENPYPE_TAG_NAME in tag.name():
            item.removeTag(tag)

def set_favorites() -> None:
    """Add context-related favorites to Nuke's file browser.

    Favorites are derived from ``AYON_WORKDIR`` (or the currently opened
    workfile path) and split into:
    - project directory
    - folder directory
    - work directory

    Important limitations:
    - Project root detection assumes ``project_name`` is present in the path.
        If the project name is missing, or appears in an unexpected position,
        derived project paths may be incorrect.
    - Folder root detection assumes ``folder_name`` is present and uniquely
        identifiable in the path. If the folder name is missing or repeated,
        derived folder paths may be incorrect.

    In short, path derivation is template-dependent and works best when the
    current context tokens are explicitly represented in the work directory.
    """
    work_dir = os.getenv("AYON_WORKDIR")

    # Use workdir from current workfile
    host = registered_host()
    current_file = host.get_current_workfile()
    if current_file:
        work_dir = os.path.dirname(current_file)
    # Escape backslashes on windows
    if platform.system().lower() == "windows":
        work_dir = work_dir.replace("\\", "/")

    context = host.get_current_context()
    project_name = context["project_name"]
    folder_path = context["folder_path"]
    folder_name = folder_path.split("/")[-1]

    # Split workdir to parts by project name
    projects_root = work_dir.split(project_name)[0]
    project_dir = f"{projects_root}{project_name}/"

    folder_root = work_dir.split(folder_name)[0]
    folder_dir = f"{folder_root}{folder_name}/"

    icon_path = resources.get_resource("icons", "folder-favorite.png")
    for name, path in (
        ("Shot dir", folder_dir),
        ("Work dir", work_dir),
        ("Project dir", project_dir),
    ):
        # This only adds the favorite directory to the "Import File(s)"
        # and "Import Folder(s)" menus. It does not impact "Import EDL"
        # nor "Import OTIO" as those are handled natively by Hiero with
        # no public API.
        nuke.addFavoriteDir(
            name=name,
            directory=path,
            type=nuke.IMAGE | nuke.SCRIPT,
            icon=icon_path,
        )

def set_track_ayon_tag(track, data=None):
    """
    Set AYON track tag to input track object.

    Attributes:
        track (hiero.core.VideoTrack): hiero object

    Returns:
        hiero.core.Tag
    """
    return _set_ayon_tag(track, data)

def set_trackitem_ayon_tag(track_item, data=None):
    """
    Set AYON track item tag to input track item object.

    Attributes:
        track_item (hiero.core.TrackItem): hiero object

    Returns:
        hiero.core.Tag
    """
    return _set_ayon_tag(track_item, data)

def setup(console=False, port=None, menu=True):
    """Setup integration

    Registers Pyblish for Hiero plug-ins and appends an item to the File-menu

    Arguments:
        console (bool): Display console with GUI
        port (int, optional): Port from which to start looking for an
            available port to connect with Pyblish QML, default
            provided by Pyblish Integration.
        menu (bool, optional): Display file menu in Hiero.
    """

    if _CTX.has_been_setup:
        teardown()

    add_submission()
    # Add path mappings for the current session
    add_path_mapping()

    if menu:
        add_to_filemenu()
        _CTX.has_menu = True

    _CTX.has_been_setup = True
    log.debug("pyblish: Loaded successfully.")

def teardown():
    """Remove integration"""
    if not _CTX.has_been_setup:
        return

    if _CTX.has_menu:
        remove_from_filemenu()
        _CTX.has_menu = False

    _CTX.has_been_setup = False
    log.debug("pyblish: Integration torn down successfully")