class Artifactory::Resource::Artifact

def checksum_search(options = {})
  client = extract_client!(options)
  params = Util.slice(options, :md5, :sha1, :repos)
  format_repos!(params)
  client.get("/api/search/checksum", params)["results"].map do |artifact|
    from_url(artifact["uri"], client: client)
  end
end

def compliance
  @compliance ||= client.get(File.join("/api/compliance", relative_path))
end

def copy(destination, options = {})
  copy_or_move(:copy, destination, options)
end

def copy_or_move(action, destination, options = {})
  params = {}.tap do |param|
    param[:to]              = destination
    param[:failFast]        = 1 if options[:fail_fast]
    param[:suppressLayouts] = 1 if options[:suppress_layouts]
    param[:dry]             = 1 if options[:dry_run]
  end
  endpoint = File.join("/api", action.to_s, relative_path) + "?#{to_query_string_parameters(params)}"
  client.post(endpoint, {})
end

def creation_search(options = {})
  client = extract_client!(options)
  params = Util.slice(options, :from, :to, :repos)
  format_repos!(params)
  client.get("/api/search/creation", params)["results"].map do |artifact|
    from_url(artifact["uri"], client: client)
  end
end

def delete
  !!client.delete(download_uri)
rescue Error::HTTPError
  false
end

def download(target = Dir.mktmpdir, options = {})
  target = File.expand_path(target)
  # Make the directory if it doesn't yet exist
  FileUtils.mkdir_p(target) unless File.exists?(target)
  # Use the server artifact's filename if one wasn't given
  filename = options[:filename] || File.basename(download_uri)
  # Construct the full path for the file
  destination = File.join(target, filename)
  File.open(destination, "wb") do |file|
    client.get(download_uri) do |chunk|
      file.write chunk
    end
  end
  destination
end

def from_hash(hash, options = {})
  super.tap do |instance|
    instance.created       = Time.parse(instance.created) rescue nil
    instance.last_modified = Time.parse(instance.last_modified) rescue nil
    instance.last_updated  = Time.parse(instance.last_updated)  rescue nil
    instance.size          = instance.size.to_i
  end
end

def gavc_search(options = {})
  client = extract_client!(options)
  options = Util.rename_keys(options,
    :group      => :g,
    :name       => :a,
    :version    => :v,
    :classifier => :c
  )
  params = Util.slice(options, :g, :a, :v, :c, :repos)
  format_repos!(params)
  client.get("/api/search/gavc", params)["results"].map do |artifact|
    from_url(artifact["uri"], client: client)
  end
end

def get_properties(refresh_cache = false)
  if refresh_cache || @properties.nil?
    @properties = client.get(File.join("/api/storage", relative_path), properties: nil)["properties"]
  end
  @properties
end

def latest_version(options = {})
  client = extract_client!(options)
  options = Util.rename_keys(options,
    :group   => :g,
    :name    => :a,
    :version => :v
  )
  params = Util.slice(options, :g, :a, :v, :repos, :remote)
  format_repos!(params)
  # For whatever reason, Artifactory won't accept "true" - they want a
  # literal "1"...
  params[:remote] = 1 if options[:remote]
  client.get("/api/search/latestVersion", params)
rescue Error::HTTPError => e
  raise unless e.code == 404
  nil
end

def md5
  checksums && checksums["md5"]
end

def move(destination, options = {})
  copy_or_move(:move, destination, options)
end

def properties(props = nil)
  if props.nil? || props.empty?
    get_properties
  else
    set_properties(props)
    get_properties(true)
  end
end

def property_search(options = {})
  client = extract_client!(options)
  params = options.dup
  format_repos!(params)
  client.get("/api/search/prop", params)["results"].map do |artifact|
    from_url(artifact["uri"], client: client)
  end
end

def relative_path
  @relative_path ||= uri.split("/api/storage", 2).last
end

def search(options = {})
  client = extract_client!(options)
  params = Util.slice(options, :name, :repos)
  format_repos!(params)
  client.get("/api/search/artifact", params)["results"].map do |artifact|
    from_url(artifact["uri"], client: client)
  end
end

def set_properties(properties)
  matrix = to_matrix_properties(properties)
  endpoint = File.join("/api/storage", relative_path) + "?properties=#{matrix}"
  client.put(endpoint, nil)
end

def sha1
  checksums && checksums["sha1"]
end

def upload(repo, remote_path, properties = {}, headers = {})
  file     = File.new(File.expand_path(local_path))
  matrix   = to_matrix_properties(properties)
  endpoint = File.join("#{url_safe(repo)}#{matrix}", remote_path)
  # Include checksums in headers if given.
  headers["X-Checksum-Md5"] = md5   if md5
  headers["X-Checksum-Sha1"] = sha1 if sha1
  response = client.put(endpoint, file, headers)
  return unless response.is_a?(Hash)
  self.class.from_hash(response)
end

def upload_checksum(repo, remote_path, type, value)
  file = Tempfile.new("checksum.#{type}")
  file.write(value)
  file.rewind
  endpoint = File.join(url_safe(repo), "#{remote_path}.#{type}")
  client.put(endpoint, file)
  true
ensure
  if file
    file.close
    file.unlink
  end
end

def upload_from_archive(repo, remote_path, properties = {})
  upload(repo, remote_path, properties,
    "X-Explode-Archive" => true
  )
end

def upload_with_checksum(repo, remote_path, checksum, properties = {})
  upload(repo, remote_path, properties,
    "X-Checksum-Deploy" => true,
    "X-Checksum-Sha1"   => checksum
  )
end

def usage_search(options = {})
  client = extract_client!(options)
  params = Util.slice(options, :notUsedSince, :createdBefore, :repos)
  format_repos!(params)
  client.get("/api/search/usage", params)["results"].map do |artifact|
    from_url(artifact["uri"], client: client)
  end
end

def versions(options = {})
  client  = extract_client!(options)
  options = Util.rename_keys(options,
    :group   => :g,
    :name    => :a,
    :version => :v
  )
  params = Util.slice(options, :g, :a, :v, :repos)
  format_repos!(params)
  client.get("/api/search/versions", params)["results"]
rescue Error::HTTPError => e
  raise unless e.code == 404
  []
end