# Copyright (c) 2011, uEncode, Cássio 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 OverlayUrl
    include Transfer
    
    private
    def root_name; "url"; end
  end
  
  class Position
    ATTRIBUTES = [:x, :y]
    
    include AttrSetting

    def to_xml
      %Q{
      <position>
      <#{x.nil? ? '<x>' + x.to_s + '</x>' : ""}
      <#{y.nil? ? '<y>' + y.to_s + '</y>' : ""}
      </position>
      }
    end
  end
  
  class Overlay
    ATTRIBUTES = [:quadrant]
    
    include AttrSetting

    def position=(_position)
      _position = Position.new(_position) unless _position.instance_of?(Position) || _position.nil?
      instance_variable_set :@position, _position
    end
    
    def position
      @position
    end
    
    def source_image=(_source)
       _source = OverlayUrl.new(_source) unless _source.instance_of?(OverlayUrl) || _source.nil?
       instance_variable_set :@source_image, _source
    end
                    
    def source_image
      @source_image
    end                                          
    
    def to_xml
      %Q{
        <overlay>
          #{!source_image.nil? ? source_image.to_xml : ""}
          #{!@position.nil? ? @position.to_xml : ""}
          #{!quadrant.nil? ? '<quadrant>' + quadrant.to_s + '</quadrant>' : ""}
        </overlay>
      }
    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 overlay=(_overlay)
      _overlay = Overlay.new(_overlay) unless _overlay.instance_of?(Overlay) || _overlay.nil?
      instance_variable_set :@overlay, _overlay
    end

    def overlay
      @overlay
    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 : ""}                    
          #{@overlay ? @overlay.to_xml : ""}
          </capture>
      }
    end
  end

  class Metadata
    ATTRIBUTES = [:title, :author, :composer, :album, :year, :track, :comment, :genre, :copyright, :description, :synopsis, :show, :episode_id, :network]

    include AttrSetting

    def to_xml
      %Q{
        <meta>
        #{!title.nil? ? '<title>' + title.to_s + '</title>' : ""}
        #{!author.nil? ? '<author>' + author.to_s + '</author>' : ""}
        #{!composer.nil? ? '<composer>' + composer.to_s + '</composer>' : ""}
        #{!album.nil? ? '<album>' + album.to_s + '</album>' : ""}
        #{!year.nil? ? '<year>' + year.to_s + '</year>' : ""}
        #{!track.nil? ? '<track>' + track.to_s + '</track>' : ""}
        #{!comment.nil? ? '<comment>' + comment.to_s + '</comment>' : ""}
        #{!genre.nil? ? '<genre>' + genre.to_s + '</genre>' : ""}
        #{!copyright.nil? ? '<copyright>' + copyright.to_s + '</copyright>' : ""}
        #{!description.nil? ? '<description>' + description.to_s + '</description>' : ""}
        #{!synopsis.nil? ? '<synopsis>' + synopsis.to_s + '</synopsis>' : ""}
        #{!show.nil? ? '<show>' + show.to_s + '</show>' : ""}
        #{!episode_id.nil? ? '<episode_id>' + episode_id.to_s + '</episode_id>' : ""}
        #{!network.nil? ? '<network>' + network.to_s + '</network>' : ""}
        </meta>
      }
    end
  end                      

  class Clip
    ATTRIBUTES = [:start, :duration]

    include AttrSetting
    
    def to_xml
      %Q{
        <clip>
        #{!start.nil? ? '<start>' + start.to_s + '</start>' : ""}
        #{!duration.nil? ? '<duration>' + duration.to_s + '</duration>' : ""}
        </clip>
      }
    end
  end
  
  class VideoOutput
    ATTRIBUTES = [:destination, :container]

    include AttrSetting

    include Enumerable

    attr_writer :container
    attr_accessor :streams


    def overlay=(_overlay)
      _overlay = Overlay.new(_overlay) unless _overlay.instance_of?(Overlay) || _overlay.nil?
      instance_variable_set :@overlay, _overlay
    end

    def overlay
      @overlay
    end

    def clip=(_clip)
      _clip = Clip.new(_clip) unless _clip.instance_of?(Clip) || _clip.nil?
      instance_variable_set :@clip, _clip
    end

    def clip
      @clip
    end

    def metadata=(_metadata)
      _metadata = Metadata.new(_metadata) unless _metadata.instance_of?(Metadata) || _metadata.nil?
      instance_variable_set :@metadata, _metadata
    end

    def metadata
      @metadata
    end


    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>
            #{metadata.nil? ? "" : metadata.to_xml}
            #{clip.nil? ? "" : clip.to_xml}
            #{overlay.nil? ? "" : overlay.to_xml}
            <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)
      vid = hash[:video]
      aud = hash[:audio]      
      if !vid.nil?
        configure_video do |c|
          vid.each_pair { |key, value| c.send("#{key}=", value)}
        end
      end

      if !aud.nil?
        configure_audio do |c|
          aud.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 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