class Sprockets::Manifest

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

def clean(count = 2, age = 3600)
  asset_versions = files.group_by { |_, attrs| attrs['logical_path'] }
  asset_versions.each do |logical_path, versions|
    current = assets[logical_path]
    versions.reject { |path, _|
      path == current
    }.sort_by { |_, attrs|
      # Sort by timestamp
      Time.parse(attrs['mtime'])
    }.reverse.each_with_index.drop_while { |(_, attrs), index|
      _age = [0, Time.now - Time.parse(attrs['mtime'])].max
      # Keep if under age or within the count limit
      _age < age || index < count
    }.each { |(path, _), _|
       # Remove old assets
      remove(path)
    }
  end
end

def clobber
  FileUtils.rm_r(directory) if File.exist?(directory)
  logger.info "Removed #{directory}"
  # if we have an environment clear the cache too
  environment.cache.clear if environment
  nil
end

def compile(*args)
  unless environment
    raise Error, "manifest requires environment for compilation"
  end
  filenames            = []
  concurrent_exporters = []
  assets_to_export = Concurrent::Array.new
  find(*args) do |asset|
    assets_to_export << asset
  end
  assets_to_export.each do |asset|
    mtime = Time.now.iso8601
    files[asset.digest_path] = {
      'logical_path' => asset.logical_path,
      'mtime'        => mtime,
      'size'         => asset.bytesize,
      'digest'       => asset.hexdigest,
      # Deprecated: Remove beta integrity attribute in next release.
      # Callers should DigestUtils.hexdigest_integrity_uri to compute the
      # digest themselves.
      'integrity'    => DigestUtils.hexdigest_integrity_uri(asset.hexdigest)
    }
    assets[asset.logical_path] = asset.digest_path
    filenames << asset.filename
    promise      = nil
    exporters_for_asset(asset) do |exporter|
      next if exporter.skip?(logger)
      if promise.nil?
        promise = Concurrent::Promise.new(executor: executor) { exporter.call }
        concurrent_exporters << promise.execute
      else
        concurrent_exporters << promise.then { exporter.call }
      end
    end
  end
  # make sure all exporters have finished before returning the main thread
  concurrent_exporters.each(&:wait!)
  save
  filenames
end

def executor
  @executor ||= environment.export_concurrent ? :fast : :immediate
end

def exporters_for_asset(asset)
  exporters = [Exporters::FileExporter]
  environment.exporters.each do |mime_type, exporter_list|
    next unless asset.content_type
    next unless environment.match_mime_type? asset.content_type, mime_type
    exporter_list.each do |exporter|
      exporters << exporter
    end
  end
  exporters.uniq!
  exporters.each do |exporter|
    yield exporter.new(asset: asset, environment: environment, directory: dir)
  end
end

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

def find(*args, &block)
  unless environment
    raise Error, "manifest requires environment for compilation"
  end
  return to_enum(__method__, *args) unless block_given?
  environment = self.environment.cached
  promises = args.flatten.map do |path|
    Concurrent::Promise.execute(executor: executor) do
      environment.find_all_linked_assets(path).to_a
    end
  end
  promises.each do |promise|
    promise.value!.each(&block)
  end
  nil
end

def find_sources(*args)
  return to_enum(__method__, *args) unless block_given?
  if environment
    find(*args).each do |asset|
      yield asset.source
    end
  else
    args.each do |path|
      asset = assets[path]
      yield File.binread(File.join(dir, asset)) if asset
    end
  end
end

def initialize(*args)
  if args.first.is_a?(Base) || args.first.nil?
    @environment = args.shift
  end
  @directory, @filename = args[0], args[1]
  # Whether the manifest file is using the old manifest-*.json naming convention
  @legacy_manifest = false
  # 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 location
  if @directory && @filename.nil?
    @filename = find_directory_manifest(@directory, logger)
  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)
  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
  data = json_encode(@data)
  FileUtils.mkdir_p File.dirname(@filename)
  PathUtils.atomic_write(@filename) do |f|
    f.write(data)
  end
end