class Falcon::Media

def self.default_options
  @default_options ||= {
    :profiles => ['web_mp4', 'web_ogg'],
    :metadata => {},
    :source => nil,
    :encode => nil
  }
end

def all_ready?
  instance.falcon_encodings.success.count == profiles.keys.size
end

def assign(source)
  if File.exist?(source)
    @source_path = source
    @dirty = true
  end
end

def create_encoding(profile_name)
  instance.falcon_encodings.create(
    :name => name, 
    :profile_name => profile_name, 
    :source_path => source_path)
end

def create_encodings
  profiles.each do |profile_name, profile|
    encoding = create_encoding(profile_name)
    start_encoding(encoding)
  end
end

def destroy
  flush_deletes
  @dirty = false
  true
end

def dirty?
  @dirty
end

def exist?
  File.exist?(source_path)
end

def flush_deletes
  profiles.each do |profile_name, profile|
    filepath = path(profile)
    FileUtils.rm(filepath, :force => true) if filepath && File.exists?(filepath)
  end
end

def initialize(name, instance, options = {})
  @name = name
  @instance = instance
  @options = self.class.default_options.merge(options)
  @profiles = @options[:profiles]
  @encode = @options[:encode]
  @dirty = false
end

def metadata
  @metadata ||= begin
    method = @options[:metadata]
    method.respond_to?(:call) ? method.call(self) : instance.send(method)
  end
end

def output_directory
  @output_directory ||= File.dirname(source_path)
end

def path(profile)
  Falcon::Profile.detect(profile).path(source_path, name)
end

def profiles
  unless @normalized_profiles
    @normalized_profiles = {}
    (@profiles.respond_to?(:call) ? @profiles.call(self) : @profiles).each do |name|
      @normalized_profiles[name] = Falcon::Profile.find(name)
    end
  end
  
  @normalized_profiles
end

def ready?(profile)
  instance.falcon_encodings.with_profile(profile).success.exists?
end

def save
  flush_deletes
  create_encodings
  @dirty = false
  true
end

def screenshots(&block)
  Dir.glob("#{output_directory}/*.{jpg,JPG}").each do |filepath|
   yield filepath
   FileUtils.rm(filepath, :force => true)
 end
end

def source_path
  @source_path ||= begin
    method = options[:source]
    method.respond_to?(:call) ? method.call(instance) : instance.send(method)
  end
end

def sources
  @sources ||= profiles.values.map{|profile| url(profile) }
end

def start_encoding(encoding)
  if @encode
    @encode.respond_to?(:call) ? @encode.call(encoding) : instance.send(@encode, encoding)
  else
    encoding.encode
  end
end

def url(profile)
  "/" + path(profile).relative_path_from( Rails.root.join('public') )
end