# Copyright (c) 2011, uEncode, Cassio Marques

module UEncode

  module SizeBase
      ATTRIBUTES = [:width, :height]

      include AttrSetting      
      
      def to_xml
        %Q{
          <#{root_name}>
            <width>#{width}</width>
            <height>#{height}</height>
          </#{root_name}>
        }
      end
    end
                                                                

  class Size
    include UEncode::SizeBase
      
    private
    def root_name; "size"; end
  end
                
  class MaxSize
    include UEncode::SizeBase
    
    private
    def root_name; "max_size"; end
  end

  module RateElement
    ATTRIBUTES = [:numerator, :denominator]

    include AttrSetting

    def to_xml
      %Q{
        <#{root_name}>
          <numerator>#{numerator}</numerator>
          <denominator>#{denominator}</denominator>
        </#{root_name}>
      }
    end

    def ==(other)
      numerator == other.numerator && denominator == other.denominator
    end
  end

  module Transfer
    ATTRIBUTES = [:url, :authentication_type, :timeout, :public_read]
    
    include AttrSetting
    
    def to_xml
      %Q{
        <#{root_name}#{@authentication_type ? ' authentication_type="' + @authentication_type + '"' : ""}#{@timeout ? ' timeout="'+  @timeout.to_s + '"' : ""}#{@public_read ? ' public_read="' +  @public_read.to_s + '"' : ""}>#{@url}</#{root_name}>
      }
    end    
  end

  class Destination
    include Transfer
    
    private
    def root_name; "destination"; end      
  end
  
  class Source
    include Transfer
    
    private
    def root_name; "source"; end
  end

  class CaptureOutput
    ATTRIBUTES = [:rate, :stretch, :crop, :zip, :prefix]

    def initialize(options)
      @destinations = []
      super
    end

    def add_destination(dest)
      @destinations << dest
    end
    
    def size=(_size)
      _size = Size.new(_size) unless _size.instance_of?(Size) || _size.nil?
      instance_variable_set :@size, _size
    end
                    
    def size
      @size
    end
                                  
    def max_size=(_max_size)
      _max_size = MaxSize.new(_max_size) unless _max_size.instance_of?(MaxSize) || _max_size.nil?
      instance_variable_set :@max_size, _max_size
    end
                                                      
    def max_size
      @max_size
    end
                                                                        

    def to_xml
      %Q{
        <capture>
            <rate>#{rate}</rate>
            #{!zip.nil? ? '<zip>' + zip.to_s + '</zip>' : ""}
            #{!prefix.nil? ? '<prefix>' + prefix.to_s + '</prefix>' : ""}
            <destinations>
              #{@destinations.inject("") { |s, dest| s << dest.to_xml}}
            </destinations>
          #{@size ? @size.to_xml : ""}
          #{@max_size ? @max_size.to_xml : ""}                    
          </capture>
      }
    end
  end

  class VideoOutput
    ATTRIBUTES = [:destination, :container]

    include Enumerable

    attr_writer :container
    attr_accessor :streams

    def initialize(options)
      @streams = VideoStreams.new
      @destinations = []
      super
    end

    def each
      @items.each { |item|  yield item }
    end
    
    def add_destination(dest)
      @destinations << dest
    end

    def to_xml
      %Q{
          <video>
            <destinations>
              #{@destinations.inject("") { |s, dest| s << dest.to_xml}}                        
            </destinations>
            <container>#{container}</container>
            #{@streams.to_xml}
          </video>
      }
    end
  end

  # VideoStreams represents the audio and video streams for a single output
  class VideoStreams
    attr_reader :video_config, :audio_config

    def initialize
      @video_config = VideoConfig.new
      @audio_config = AudioConfig.new
    end

    # Configures the transcoding using a nested hash with the following format:
    #
    #   config = {:video => { ... }, :audio => { ... }
    #
    # The keys for the "video" hash can be any of the following: bitrate, codec, cbr, crop, 
    # deinterlace, framerate, height, keyframe_interval, maxbitrate, par, profile, passes,
    # stretch, width.
    #
    # The keys for the :audio hash can be any of the following:
    # codec, bitrate, channels, samplerate.
    #   
    def configure(hash)
      video = hash[:video]
      audio = hash[:audio]      
      if !video.nil?
        configure_video do |c|
          video.each_pair { |key, value| c.send("#{key}=", value) }
        end
      end

      if !audio.nil?
        configure_audio do |c|
          audio.each_pair { |key, value| c.send("#{key}=", value) }
        end
      end
    end

    def configure_video
      yield @video_config
    end

    def configure_audio
      yield @audio_config
    end     

    def video
      @video_config
    end

    def audio
      @audio_config
    end

    def to_xml
      %Q{
          <video>
            #{!video.bitrate.nil? ? '<bitrate>' + video.bitrate.to_s + '</bitrate>' : ""}
            #{!video.codec.nil? ? '<codec>' + video.codec + '</codec>' : ""}
            #{!video.profile.nil? ? '<profile>' + video.profile + '</profile>' : ""}
            #{!video.quality.nil? ? '<quality>' + video.quality.to_s + '</quality>' : ""}
            #{!video.framerate.nil? ? '<framerate>' + video.framerate.to_s + '</framerate>' : ""}
            #{!@video_config.size.nil? ? @video_config.size.to_xml : ""}
            #{@video_config.max_size ? @video_config.max_size.to_xml : ""}
            #{video.passes.nil? ? "" : '<passes>' + video.passes.to_s + '</passes>'}
            #{video.deinterlace.nil? ? "" : '<deinterlace>' + video.deinterlace.to_s + '</deinterlace>'}
            #{video.fix_rotation.nil? ? "" : '<fix_rotation>' + video.fix_rotation.to_s + '</fix_rotation>'}
            #{video.force_square_pixels.nil? ? "" : '<force_square_pixels>' + video.force_square_pixels.to_s + '</force_square_pixels>'}
          </video>
          <audio>
            #{audio.codec.nil? ? "" : '<codec>' + audio.codec + '</codec>'}
            #{audio.bitrate.nil? ? "" : '<bitrate>' + audio.bitrate.to_s + '</bitrate>'}
            #{audio.channels.nil? ? "" : '<channels>' + audio.channels.to_s + '</channels>'}
            #{audio.samplerate.nil? ? "" : '<samplerate>' + audio.samplerate.to_s + '</samplerate>'}
            #{audio.quality.nil? ? "" : '<quality>' + video.quality.to_s + '</quality>'}                        
          </audio>
      }
    end
  end

  # The video configs for each VideoStream
  class VideoConfig
    attr_accessor :bitrate, :codec, :profile, :quality, :framerate, :passes, :deinterlace, :fix_rotation, :force_square_pixels

    def initialize
      @deinterlace = false
      @profile     = "main"
      @passes      = 1
    end

    def size=(_size)
      _size = Size.new(_size) unless _size.instance_of?(Size) || _size.nil?
      instance_variable_set :@size, _size
    end
    
    def size
      @size
    end
    
    def max_size=(_max_size)
      _max_size = MaxSize.new(_max_size) unless _max_size.instance_of?(MaxSize) || _max_size.nil?
      instance_variable_set :@max_size, _max_size
    end    
    
    def max_size
      @max_size
    end
  end

  # The audio configs for each VideoStream
  class AudioConfig
    attr_accessor :codec, :bitrate, :channels, :samplerate, :quality
  end

  class JobStatus
    ATTRIBUTES = [:key, :userdata, :customerkey]
    
    include AttrSetting
  end

  class Job
    ATTRIBUTES = [:userdata, :callback, :customerkey]

    include AttrSetting

    def source_video=(_source)
      _source = Source.new(_source) unless _source.instance_of?(Source) || _source.nil?
      instance_variable_set :@source_video, _source
    end
    
    def source_video
      @source_video
    end

    def initialize(options)
      @video_outputs = []
      @captures = []
      source_video = options[:source_video]
      super
    end

    def add_video(video)
       @video_outputs << video      
    end

    def add_capture(capture)
      @captures << capture
    end

    def to_xml
      xml = %Q{
        <job>
          #{source_video.nil? ? "" : source_video.to_xml}
          #{userdata.nil? ? "" : '<userdata>' + userdata + '</userdata>'}
          #{callback.nil? ? "" : '<callback>' + callback + '</callback>'}
          <outputs>
            #{@video_outputs.inject("") { |s, vid| s << vid.to_xml}}
            #{@captures.inject("") { |s, cap| s << cap.to_xml }}
          </outputs>
        </job>
      }
      xml.gsub(/\n?/, "").gsub(/>\s+</, "><")
    end
  end

  [SizeBase, Size, MaxSize, VideoOutput, CaptureOutput, Job].each { |klass| klass.send :include, AttrSetting }
end