#Class to show how to add additional conform rules to the Match Media process.
import re
import os.path
from hiero.core import ConformRule
from hiero.core import Keys
from hiero.core import conformer

#------------------------------------------------------------------------------
class UmidConformRule(ConformRule):
  """Match Umid."""
  def __init__(self):
    ConformRule.__init__(self, "Umids")
	
  def compare( self, media, candidateMedia ):
    try:
      mediaUmid = media.value(Keys.kMediaUmid)
      candidateUmid = candidateMedia.value(Keys.kMediaUmid)
	
      return mediaUmid == candidateUmid
    except:
      return False

#------------------------------------------------------------------------------
class TapeNameConformRule(ConformRule):
  """Match tape names."""
  def __init__(self):
    ConformRule.__init__(self, "TapeName")
  
  def compare( self, media, candidateMedia ):
    try:
      tapeName = media[ Keys.kMediaTapeName ].lower()
      candidateName = candidateMedia[ Keys.kMediaTapeName ].lower()
      
      return tapeName == candidateName
    except KeyError:
      return False

#------------------------------------------------------------------------------
class NameConformRule(ConformRule):
  """Match media filenames."""
  def __init__(self):
    ConformRule.__init__(self, "Name")
  
  def compare( self, media, candidateMedia ):
    try:
      sourceName = media[ Keys.kMediaName ].lower()
      candidateName = candidateMedia[ Keys.kMediaName ].lower()
      
      return sourceName == candidateName
    
    except KeyError:
      return False

#------------------------------------------------------------------------------
class PartialNameConformRule(ConformRule):
  """Match partial media filenames."""
  def __init__(self):
    ConformRule.__init__(self, "PartialName")
  
  def compare( self, media, candidateMedia ):
    try:
      (sourcePath, sourceName ) = os.path.split( media[ Keys.kMediaName ].lower() )
      (candidatePath, candidateName ) = os.path.split( candidateMedia[ Keys.kMediaName ].lower() )
      (sourceRoot, sourceExt) = os.path.splitext( sourceName )
      (candidateRoot, candidateExt) = os.path.splitext( candidateName )
      
      # Peel off space, dot, or _ separated words from end of source looking for a
      # candidate that starts with that shortened source name.
      # There is probably some way of doing this with regex engine but I am keeping it like the C++ code
      lastSep = len( sourceRoot )
      candidateLen = len( candidateRoot )
      
      while (lastSep > 0 and lastSep >= candidateLen and lastSep != -1):
        sourceHead = sourceRoot[0:lastSep];
        if (candidateRoot.find(sourceHead, None, None) != -1):
          return True
        spaceSep = sourceRoot.rfind(" ", lastSep-1)
        dotSep = sourceRoot.rfind(".", lastSep-1)
        scoreSep = sourceRoot.rfind("_", lastSep-1)
        lastSep = max( spaceSep, dotSep, scoreSep )
      
      return False
    
    except KeyError:
      return False

#------------------------------------------------------------------------------
class TimecodeConformRule(ConformRule):
  """Match timecode values."""
  def __init__(self):
    ConformRule.__init__(self, "Timecode")
  
  def compare( self, media, candidateMedia ):
    try:
      mediaStartTimeValue = media[ Keys.kMediaStartTime ]
      mediaDurationValue = media[ Keys.kMediaDuration ]
      mediaTypeValue = media[ Keys.kMediaMasterMediaType ]
      candidateMediaStartTimeValue = candidateMedia[ Keys.kMediaStartTime ]
      candidateMediaDurationValue = candidateMedia[ Keys.kMediaDuration ]
      candidateMediaTypeValue = candidateMedia[ Keys.kMediaMasterMediaType ]
  
      if (mediaTypeValue == candidateMediaTypeValue):
        mediaStartTime = int(mediaStartTimeValue)
        mediaDuration = int(mediaDurationValue)
        candidateMediaStartTime = int(candidateMediaStartTimeValue)
        candidateMediaDuration = int(candidateMediaDurationValue)
        
        return (mediaStartTime >= candidateMediaStartTime and mediaStartTime + mediaDuration <= candidateMediaStartTime + candidateMediaDuration)
  
      return False
  
    except KeyError:
      return False

#------------------------------------------------------------------------------

# Construct instances of the rules to register them with Hiero.
umidRule = UmidConformRule()
nameRule = NameConformRule()
tapeNameRule = TapeNameConformRule()
partialNameRule = PartialNameConformRule()
timecodeRule = TimecodeConformRule()

# To turn off a rule:
# nameRule.deactivate()

# To return a tuple of the active conform rules:
activeRules = conformer().pythonRuleNames()
print(activeRules)