class Sprockets::Manifest

def self.compile_match_filter(filter)
  # If the filter is already a proc, great nothing to do.
  if filter.respond_to?(:call)
    filter
  # If the filter is a regexp, wrap it in a proc that tests it against the
  # logical path.
  elsif filter.is_a?(Regexp)
    proc { |logical_path| filter.match(logical_path) }
  elsif filter.is_a?(String)
    # If its an absolute path, detect the matching full filename
    if PathUtils.absolute_path?(filter)
      proc { |logical_path, filename| filename == filter.to_s }
    else
      # Otherwise do an fnmatch against the logical path.
      proc { |logical_path| File.fnmatch(filter.to_s, logical_path) }
    end
  else
    raise TypeError, "unknown filter type: #{filter.inspect}"
  end
end

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

def clean(keep = 2)
  asset_versions = files.group_by { |_, attrs| attrs['logical_path'] }
  asset_versions.each do |logical_path, versions|
    current = assets[logical_path]
    backups = versions.reject { |path, _|
      path == current
    }.sort_by { |_, attrs|
      # Sort by timestamp
      Time.parse(attrs['mtime'])
    }.reverse
    # Keep the last N backups
    backups = backups[keep..-1] || []
    # Remove old assets
    backups.each { |path, _| remove(path) }
  end
end

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

def compile(*args)
  unless environment
    raise Error, "manifest requires environment for compilation"
  end
  filenames = []
  filter_logical_paths(*args).each do |_, filename|
    find_assets(filename) do |asset|
      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
      end
      filenames << filename
    end
  end
  save
  filenames
end

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

def filter_logical_paths(*args)
  filters = args.flatten.map { |arg| self.class.compile_match_filter(arg) }
  environment.logical_paths.select do |a, b|
    filters.any? { |f| f.call(a, b) }
  end
end

def find_assets(path)
  start = Utils.benchmark_start
  environment.find_all_linked_assets(path) do |asset|
    logger.debug do
      "Compiled #{asset.logical_path}  (#{Utils.benchmark_end(start)}ms)"
    end
    yield asset
    start = Utils.benchmark_start
  end
end

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

def json_decode(obj)
  JSON.parse(obj, create_additions: false)
end

def json_encode(obj)
  JSON.generate(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)
  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)
  save
  logger.info "Removed #{filename}"
  nil
end

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