class Artifactory::Cleaner::Controller

# File lib/artifactory/cleaner/controller.rb, line 26
def initialize(artifactory_config)
  @artifactory_client = client = Artifactory::Client.new(**artifactory_config)
  @verbose = false
  initialize_queues
  @workers = []
  @num_workers = 6
end

# File lib/artifactory/cleaner/controller.rb, line 346
def archive_artifact(artifact, path)
  debuglog "[DEBUG] downloading #{artifact} (#{artifact.uri}) to #{path}"
  timing = Benchmark.measure do
    artifact.download(path)
  end
  debuglog "[DEBUG] #{artifact.uri} #{Util.filesize artifact.size} downloaded in #{timing.real.round(2)} seconds (#{Util.filesize(artifact.size/timing.real)})/s"
end

# File lib/artifactory/cleaner/controller.rb, line 173
def artifact_usage_search(from: nil, to: nil, repos: nil, threads: 4)
  to = Time.now if to.nil?

  params = {
    dateFields: 'created,lastModified,lastDownloaded',
    from: from.is_a?(Time) ? from.to_i * 1000 : from.to_i,
    to: to.is_a?(Time) ? to.to_i * 1000 : to.to_i
  }
  repos = repos.compact.join(",") unless repos.nil?
  params[:repos] = repos unless repos.nil?

  result = nil

  debuglog("[DEBUG] Making Artifactory request /api/search/dates for #{params.inspect}")
  timing = {}
  timing[:search] = Benchmark.measure do
    begin
      result = @artifactory_client.get("/api/search/dates", params)
    rescue Artifactory::Error::HTTPError => err
      if err.code == 404
        debuglog "  HTTP 404 Not Found fetching: /api/search/dates -- assuming no assets for this date range"
        result = []
        #Pry::rescued(err) if defined?(Pry::rescue)
      else
        STDERR.puts "HTTP Error while performing an artifact usage search: #{err}"
        STDERR.puts err.full_message
        STDERR.puts "Parameters were: #{params.inspect}"
        STDERR.puts "Caused by #{err.cause.full_message}" if err.cause
        Pry::rescued(err) if defined?(Pry::rescue)
      end
    end
  end
  debuglog("[DEBUG] Got #{result["results"].length} results from search in #{timing[:search].real} seconds") unless result.nil? or result.empty?
  timing[:fetch] = Benchmark.measure do
    if threads > 1
      unless result.nil? or result.empty?
        result = discover_artifacts_from_search(result["results"], threads: threads)
      end
    else
      unless result.nil? or result.empty?
        result = result["results"].map do |artifact|
          a = nil
          retries = 10
          while a.nil? and retries > 0
            begin
              retries -= 1
              a = Artifactory::Cleaner::DiscoveredArtifact.from_url(artifact["uri"], client: @artifactory_client)
              a.last_downloaded = Time.parse(artifact["lastDownloaded"]) unless artifact["lastDownloaded"].to_s.empty?
            rescue Net::OpenTimeout, Artifactory::Error::ConnectionError => err
              STDERR.puts "[WARN] Connection Failure attempting to reach Artifactory API: #{err}"
              debuglog "  Parameters were: #{params.inspect}"
              debuglog "  Caused by #{err.cause.full_message}" if err.cause
              STDERR.puts "  Retrying in 10 seconds" if retries
              sleep 10
            rescue Artifactory::Error::HTTPError => err
              if err.code == 404
                STDERR.puts "[WARN] HTTP 404 Not Found fetching: #{artifact["uri"]}"
                retries = 0
              else
                retries = min(retries, 1)
                STDERR.puts "[ERROR] HTTP Error while fetching an artifact from a usage search: #{err}"
                debuglog err.full_message
                debuglog "  Artifact was: #{artifact.inspect}"
                debuglog "  Parameters were: #{params.inspect}"
                debuglog "  Caused by #{err.cause.full_message}" if err.cause
                Pry::rescued(err) if defined?(Pry::rescue)
                STDERR.puts "  Will retry download once" if retries
              end
            end
          end
          a
        end
      end
      result.compact!
    end
  end
  debuglog("[DEBUG][Perfdata] Artifactory request /api/search/dates timing: #{timing[:search]}")
  debuglog("[DEBUG][Perfdata] Fetching artifacts timing: #{timing[:fetch]}")
  total_time = timing.values.reduce(0) {|s,t| s + t.real}
  debuglog("[DEBUG] #{result.length} artifacts fetched in #{total_time.round 2} seconds")
  result
end

# File lib/artifactory/cleaner/controller.rb, line 289
def bucketize_artifacts(from: nil, to: nil, increment: 30 * 24 * 3600, repos: nil, buckets: nil, threads: 4)
  buckets = ArtifactBucketCollection.new unless buckets.is_a? ArtifactBucketCollection
  with_discovered_artifacts(from: from, to: to, repos: repos, increment: increment, threads: threads) do |artifact|
    buckets << artifact
  end
  buckets
end

# File lib/artifactory/cleaner/controller.rb, line 301
def bucketized_artifact_report(buckets)
  total_size = 0
  total_count = 0
  lines = buckets.map do |bucket|
    total_size += bucket.filesize
    total_count += bucket.length
    "#{bucket.length} artifacts between #{bucket.min} and #{bucket.max} days, totaling #{Artifactory::Cleaner::Util::filesize bucket.filesize}"
  end
  lines << "Total: #{Artifactory::Cleaner::Util::filesize total_size} across #{total_count} artifacts"
end

# File lib/artifactory/cleaner/controller.rb, line 370
def catagorize_old_assets(days)
  buckets = {
      730 => {count: 0, size: 0},
      365 => {count: 0, size: 0},
      180 => {count: 0, size: 0},
      90  => {count: 0, size: 0},
      30  => {count: 0, size: 0},
  }
  discover_repos
  @repos[:local].each_pair do |id,repo|
    begin
      pkgs = 0
      purgable = 0
      timings = Benchmark.bm(12) do |bm|
        debuglog "Searching Repo #{id}:"
        old_packages = nil
        bm.report('api call') {
          old_packages = @artifactory_client.artifact_usage_search(
              notUsedSince: (Time.now.to_i - 24 * 3600 * days) * 1000,
              createdBefore: (Time.now.to_i - 24 * 3600 * days) * 1000,
              repos: id
          )
        }
        debuglog "  Artifactory search returned #{old_packages.length} assets older than #{days}..."
        bm.report('loop') { old_packages.each_with_index do |pkg,i|
          pkgs += 1
          uri = URI(pkg.uri)
          purgable += pkg.size
          # Calculate the age of this package in days and increment the bucket it belongs in
          age = (Time.now - pkg.last_modified)/(3600*24)
          if (bucket = buckets.keys.find {|v| age >= v })
            buckets[bucket][:count] += 1
            buckets[bucket][:size] += pkg.size
          end
          debuglog "  ##{i}: #{File.basename(uri.path)} #{Util.filesize pkg.size} Created #{pkg.created} Modified #{pkg.last_modified}"
        end }
      end
      debuglog "Found #{pkgs} assets from #{id} older than #{days} days totaling #{Util.filesize purgable} in #{timings.reduce {|sum, t| sum + t.real}} seconds"
    rescue => ex
      STDERR.puts "Caught an exception trying to handle repo #{id}: #{ex}"
      STDERR.puts ex.full_message
      STDERR.puts "Caused by #{ex.cause.full_message}" if ex.cause
    end
  end

  buckets.each_pair do |age,bucket|
    debuglog "#{bucket[:count]} packages older than #{age} days, totaling #{Util.filesize bucket[:size]}"
  end
  
  buckets
end

# File lib/artifactory/cleaner/controller.rb, line 363
def delete_artifact(artifact)
  debuglog "[DEBUG] DELETE Artifact #{artifact} at #{artifact.uri}!"
  artifact.delete
end

# File lib/artifactory/cleaner/controller.rb, line 96
def discover_artifacts_from_search(artifact_list, threads: 4)
  result = []
  timing = {}
  #kill_threads
  @num_workers = threads
  timing[:enqueue] = Benchmark.measure do
    artifact_list.each {|a| queue_discovery_of_artifact a}
  end

  timing[:dequeue] = Benchmark.measure do
    until @discovery_queues.incoming.empty? and @discovery_queues.outgoing.empty? and not @workers.any? &:working?
      begin
        item = @discovery_queues.outgoing.pop
        if item.kind_of? Artifactory::Resource::Artifact
          result << item
          #debuglog "[DEBUG] Discovered #{item} from a child thread"
        elsif item.kind_of? Error
          STDERR.puts "[ERROR] Error from artifact fetch: #{item}"
          STDERR.puts item.full_message
          STDERR.puts "Caused by #{item.cause.full_message}" if item.cause
        elsif !artifact.nil?
          STDERR.puts "[ERROR] Got #{item} back from the discovery queue, expected an Artifactory::Resource::Artifact"
        end
      rescue => processing_ex
        STDERR.puts "[ERROR] Caught an exception when processing from the outgoing discovery queue: #{processing_ex}"
        STDERR.puts processing_ex.full_message
        STDERR.puts "Caused by #{processing_ex.cause.full_message}" if processing_ex.cause
      end
    end
  end

  begin
    kill_threads
  rescue => ex
    STDERR.puts "[ERROR] Caught an exception when killing threads: #{ex}"
    STDERR.puts ex.full_message
    STDERR.puts "Caused by #{ex.cause.full_message}" if ex.cause
  end

  debuglog("[DEBUG][Perfdata] Enqueue URLs for workers to discover: #{timing[:enqueue]}")
  debuglog("[DEBUG][Perfdata] Dequeue found Artifacts from workers: #{timing[:dequeue]}")
  total_time = timing.values.reduce(0) {|s,t| s + t.real}
  debuglog("[DEBUG] #{result.length} artifacts fetched in #{total_time.round 2} seconds")
  result
end

# File lib/artifactory/cleaner/controller.rb, line 57
def discover_repos
  timing = {}
  @repos = {
      local: {},
      remote: {},
      virtual: {},
  }
  i = 0
  timing[:loop] = Benchmark.measure do
    @artifactory_client.repository_all.each do |repo|
      debuglog "[DEBUG] Found #{repo.package_type} repo: #{repo.key}"
      if repo.rclass == 'remote' && repo.url
        debuglog " +-> repo #{repo.key} is a mirror of remote at #{repo.url}"
        @repos[:remote][repo.key] = repo
      elsif repo.rclass == 'virtual' && repo.repositories
        debuglog " +-> repo #{repo.key} is a virtual repo containing: #{repo.repositories.join ', '}"
        @repos[:remote][repo.key] = repo
      else
        @repos[:local][repo.key] = repo
      end
      i += 1
    end
  end
  debuglog("[DEBUG][Perfdata] Fetched #{i} repos; timing: #{timing[:loop]}")
  @repos
end

# File lib/artifactory/cleaner/controller.rb, line 43
def verbose=(val)
  @verbose = !!val
end

# File lib/artifactory/cleaner/controller.rb, line 36
def verbose?
  @verbose
end

# File lib/artifactory/cleaner/controller.rb, line 277
def with_discovered_artifacts(from: nil, to: nil, repos: nil, increment: 30 * 24 * 3600, threads: 4)
  chunk_end = to || Time.now
  while chunk_end > from
    chunk_start = chunk_end - increment
    chunk_start = from if chunk_start < from
    artifact_usage_search(from: chunk_start, to: chunk_end, repos: repos, threads: threads).each do |pkg|
      yield pkg
    end
    chunk_end = chunk_start
  end
end

# File lib/artifactory/cleaner/controller.rb, line 319
def yaml_format(artifact, indent = 0)
  properties = [:uri, :last_downloaded, :repo, :created, :last_modified, :last_updated, :download_uri, :mime_type, :size, :checksums ]
  result = YAML.dump(properties.each_with_object({}) {|prop,export| export[prop] = artifact.send(prop) })
  if indent
    i = 0
    result.each_line.reduce('') do |str,line|
      if (i += 1) > 2
        str + (' ' * indent) + line
      elsif i == 2
          str + line
      else
        str
      end
    end
  end
end