class Sprockets::Manifest

def assets
  @data['assets'] ||= {}
end

def backups_for(logical_path)
  files.select { |filename, attrs|
    # Matching logical paths
    attrs['logical_path'] == logical_path &&
      # Excluding whatever asset is the current
      assets[logical_path] != filename
  }.sort_by { |filename, attrs|
    # Sort by timestamp
    Time.parse(attrs['mtime'])
  }.reverse
end

def benchmark
  start_time = Time.now.to_f
  yield
  ((Time.now.to_f - start_time) * 1000).to_i
end

def clean(keep = 2)
  self.assets.keys.each do |logical_path|
    # Get assets sorted by ctime, newest first
    assets = backups_for(logical_path)
    # Keep the last N backups
    assets = assets[keep..-1] || []
    # Remove old assets
    assets.each { |path, _| remove(path) }
  end
end

def clobber
  FileUtils.rm_r(@dir) if File.exist?(@dir)
  logger.info "Removed #{@dir}"
  nil
end

def compile(*args)
  unless environment
    raise Error, "manifest requires environment for compilation"
  end
  paths = environment.each_logical_path(*args).to_a +
    args.flatten.select { |fn| Pathname.new(fn).absolute? if fn.is_a?(String)}
  paths.each do |path|
    if asset = find_asset(path)
      files[asset.digest_path] = {
        'logical_path' => asset.logical_path,
        'mtime'        => asset.mtime.iso8601,
        'size'         => asset.bytesize,
        'digest'       => asset.digest
      }
      assets[asset.logical_path] = asset.digest_path
      target = File.join(dir, asset.digest_path)
      if File.exist?(target)
        logger.debug "Skipping #{target}, already exists"
      else
        logger.info "Writing #{target}"
        asset.write_to target
        asset.write_to "#{target}.gz" if asset.is_a?(BundledAsset)
      end
      save
      asset
    end
  end
end

def files
  @data['files'] ||= {}
end

def find_asset(logical_path)
  asset = nil
  ms = benchmark do
    asset = environment.find_asset(logical_path)
  end
  logger.debug "Compiled #{logical_path}  (#{ms}ms)"
  asset
end

def initialize(*args)
  if args.first.is_a?(Base) || args.first.nil?
    @environment = args.shift
  end
  @dir, @path = args[0], args[1]
  # Expand paths
  @dir  = File.expand_path(@dir) if @dir
  @path = File.expand_path(@path) if @path
  # If path is given as the second arg
  if @dir && File.extname(@dir) != ""
    @dir, @path = nil, @dir
  end
  # Default dir to the directory of the path
  @dir ||= File.dirname(@path) if @path
  # If directory is given w/o path, pick a random manifest.json location
  if @dir && @path.nil?
    # Find the first manifest.json in the directory
    paths = Dir[File.join(@dir, "manifest*.json")]
    if paths.any?
      @path = paths.first
    else
      @path = File.join(@dir, "manifest-#{SecureRandom.hex(16)}.json")
    end
  end
  unless @dir && @path
    raise ArgumentError, "manifest requires output path"
  end
  data = nil
  begin
    if File.exist?(@path)
      data = json_decode(File.read(@path))
    end
  rescue MultiJson::DecodeError => e
    logger.error "#{@path} is invalid: #{e.class} #{e.message}"
  end
  @data = data.is_a?(Hash) ? data : {}
end

def json_decode(obj)
  MultiJson.load(obj)
end

def json_decode(obj)
  MultiJson.decode(obj)
end

def json_encode(obj)
  MultiJson.dump(obj)
end

def json_encode(obj)
  MultiJson.encode(obj)
end

def logger
  if environment
    environment.logger
  else
    logger = Logger.new($stderr)
    logger.level = Logger::FATAL
    logger
  end
end

def remove(filename)
  path = File.join(dir, filename)
  gzip = "#{path}.gz"
  logical_path = files[filename]['logical_path']
  if assets[logical_path] == filename
    assets.delete(logical_path)
  end
  files.delete(filename)
  FileUtils.rm(path) if File.exist?(path)
  FileUtils.rm(gzip) if File.exist?(gzip)
  save
  logger.info "Removed #{filename}"
  nil
end

def save
  FileUtils.mkdir_p dir
  File.open(path, 'w') do |f|
    f.write json_encode(@data)
  end
end