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|
    file.write(client.get(download_uri))
  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 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
  @properties ||= client.get(File.join('/api/storage', relative_path), properties: nil)['properties']
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 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