# Example for how to override hiero versioning

import os.path
import glob
import re


from hiero.core import BinItem
from hiero.core import VersionScanner


# We want to redefine some of the methods of VersionScanner, but may still need to use the default functionality within our custom methods.
# Therefore, we need to save a reference to the default methods, and then we will be able to call them from ours.
if not hasattr(VersionScanner, "default_filterVersion"):
    VersionScanner.default_filterVersion = VersionScanner.filterVersion
if not hasattr(VersionScanner, "default_versionLessThan"):
    VersionScanner.default_versionLessThan = VersionScanner.versionLessThan
if not hasattr(VersionScanner, "default_findNewVersions"):
    VersionScanner.default_findNewVersions = VersionScanner.findNewVersions



# Determine whether the file newVersionFile should be included as a new version of originalVersion
# This filtering method only allows to add versions that have the same file format as the active one.
def filterVersionSameFormat(self, binItem, newVersionFile):
    activeVersion = binItem.activeItem()
    if binItem.activeItem() and binItem.activeItem().mediaSource():
        # Obtain active item's filename
        activeVersionFile = binItem.activeItem().mediaSource().firstpath()
        # Obtain extensions:
        ext1 = os.path.splitext(activeVersionFile)[1]
        ext2 = os.path.splitext(newVersionFile)[1]
        return ext1 == ext2
    return False

# Compare method for sorting.
# Sort according to file formats first, then default to Hiero's original sorting (which uses version indices as first criterion).
def versionLessThanOrderByFormat(self, filename1, filename2):
    # Obtain extensions:
    ext1 = os.path.splitext(filename1)[1]
    ext2 = os.path.splitext(filename2)[1]

    # If extensions are different, then sort according to extension:
    if ext1 != ext2:
        return ext1 < ext2

    # If extensions are equal, then default to Hiero's original sorting.
    # NB: For this to work, ensure that the original method has been saved with a different name as shown above!
    return self.default_versionLessThan(filename1, filename2)


# Scan for additional versions that belong to the specified version
# We are having a simple system that looks for new versions in a naming convention where artists add their name
# to the version, e.g: "/files/clip_v1.Mike.mov", "/files/clip_v2.Andrew.0000.dpx"
def findNewVersionsWithArtistName(self, version):
    if not(version.item() and version.item().mediaSource()):
        return

    activeVersionFilename = version.item().mediaSource().firstpath()

    # We use the glob function to find files that look similar to ours.
    # We start with the active version file, and substitute relevant bits with * or ? wildcards.
    globExpression = activeVersionFilename

    # Substitute version index with * wildcard.
    # This will also allow for artist names to appear right after the version index
    versionRegex = "v\\d+[a-zA-Z]*" # e.g.: "v1", "v002Alex", "v100Bella", "v3Clark42", "v4a"
    globExpression = re.sub(versionRegex, "v*", globExpression)

    # Substitute extension with * wildcard.
    # This will also allow for frame numbers to be present before the extension if they were not before
    globExpression = os.path.splitext(globExpression)[0] + ".*"

    # Substitute frame number with * wildcard
    # Need to match files with different frame numbers.
    # This will also allow for frame numbers not to be present before the extension when they were before
    frameNumberRegex = "(\\.|_)\\d+\\." # e.g.: ".000.", "_001.", ".1000."
    globExpression = re.sub(frameNumberRegex, "*.", globExpression)

    # Use glob to find files that match globExpression.
    # We store found files in 'files', and we use 'visitedSequences' to avoid adding more than one frame of the same sequence.
    files = set()
    visitedSequences = set()
    for foundFile in glob.iglob(globExpression):
        # Fix path separators if on Windows!
        foundFile = re.sub("\\\\", "/", foundFile)
        # Now we need to make sure that we only add one frame from each sequence:
        trimmedFileName = re.sub(frameNumberRegex, "", foundFile)
        if not trimmedFileName in visitedSequences:
            visitedSequences.add(trimmedFileName)
            # Finally add the new found file!
            files.add(foundFile)

    return files


# Override the default VersionScanner functions with the custom ones.
VersionScanner.filterVersion = filterVersionSameFormat
VersionScanner.versionLessThan = versionLessThanOrderByFormat
VersionScanner.findNewVersions = findNewVersionsWithArtistName