# Example of a custom transcoder

import sys
import os.path

import hiero.core
from hiero.exporters import FnTranscodeExporter


class CustomTranscode(FnTranscodeExporter.TranscodeExporter):
  def __init__(self, initDict):
    """Initialize"""
    FnTranscodeExporter.TranscodeExporter.__init__( self, initDict )
        
  def startTask(self):   
    # Call parent startTask
    FnTranscodeExporter.TranscodeExporter.startTask(self)
    
    # This only works if the export item is a Sequence
    if isinstance(self._item, hiero.core.Sequence):
      
      sequence = self._item
      
      isQuicktime = self._preset.properties()["file_type"] == "mov"
      platformUsesQuicktime = sys.platform.startswith("win32") or sys.platform.startswith("darwin")
      includeAudio = self._preset.properties()["insertAudio"]      
      
      # Only the quicktime write node has the audio file knob
      if includeAudio and isQuicktime and platformUsesQuicktime:        
        
        # Get audiotracks
        audioTracks = sequence.audioTracks()
        if audioTracks:
        
          # Grab first audio track
          audioTrack = audioTracks[0]
          
          # Get list of items on track
          audioTrackItems = list(audioTrack.items())
          
          if audioTrackItems:
                      
            # Get first item on Track
            firstAudioTrackItem = audioTrackItems[0]
            
            firstSrcFile, firstSrcExt = self.sourceFileFromTrackItem(firstAudioTrackItem)
            
            offset = firstAudioTrackItem.timelineIn() - firstAudioTrackItem.sourceIn()
                        
            for node in self._script._nodes:
              if node.type() == "Write":              
                node.setKnob("audiofile", firstSrcFile)
                node.setKnob("units", 'Frames')
                node.setKnob("audio_offset",  offset)
            
      else:
        print("Error: Cannot add audio to non-quicktime format")  
        
        # Set error will end execution of task and show an error in the export queue
        # self.setError("Error: Cannot add audio to non-quicktime format")
      

  def taskStep(self):
    # The parent implementation of taskstep
    #  - Calls self.writeScript() which writes the script to the path in self._scriptfile
    #  - Executes script in Nuke with either HieroNuke or local Nuke as defined in preferences
    #  - Parses the output over frame until complete
    
    return FnTranscodeExporter.TranscodeExporter.taskStep(self)    
    
    ###############################################
    # Alternative implementation for a render farm
    #  - Calls self.writeScript() which writes the script to the path in self._scriptfile
    #  - Copy the script somewhere e.g. shutil.copyfile(self._scriptfile, "/mnt/somewhere/over/the/rainbow/")
    #  - Poll for completion
    #  - Return True whilst incomplete and Return False when no more updates required

    return False
    
  def forcedAbort (self):
    # Parent impliementation terminates nuke process
    FnTranscodeExporter.TranscodeExporter.forcedAbort(self)    
    return
    
    # Cancel render farm job
    
    return
  
  def finishTask (self):  
    FnTranscodeExporter.TranscodeExporter.finishTask(self)

    # Called when task step signals completion
    
    return
    
  def progress(self):
    # Parent implimentation returns a float between 0.0-1.0 representing progress
    # Progress is monitored by parsing frame progress in stdout from Nuke 
    
    # Ensure return type is float or shiboken will throw an error
    return float(FnTranscodeExporter.TranscodeExporter.progress(self))

  def sourceFileFromTrackItem( self, trackItem ):
    
    # Get Clip
    clip = trackItem.source()
    
    # Get Clip Source
    source = clip.mediaSource()
    
    # Get Source Filename
    filename = source.firstpath()
    
    # Split off the extension
    base, extension = os.path.splitext(filename)
    
    # Return filename and extension
    return filename, extension.lower()

  
  
class CustomTranscodePreset(FnTranscodeExporter.TranscodePreset):
  def __init__(self, name, properties):
    FnTranscodeExporter.TranscodePreset.__init__(self, name, properties)
    self._parentType = CustomTranscode
    
    # Set default values
    self._properties["insertAudio"] = True
    
    # Update properties dictionary with data from file
    self._properties.update(properties)
    
  # Override supported types to be Sequences only
  def supportedItems(self):
    return hiero.core.TaskPresetBase.kSequence

    
# Register this CustomTask and its associated Preset
hiero.core.taskRegistry.registerTask(CustomTranscodePreset, CustomTranscode)