module Resque::Scheduler::Server::HelperMethods

def delayed_jobs_for_worker(_worker)
  [].tap do |dels|
    schedule_size = Resque.delayed_queue_schedule_size
    Resque.delayed_queue_peek(0, schedule_size).each do |d|
      Resque.delayed_timestamp_peek(
        d, 0, Resque.delayed_timestamp_size(d)
      ).each do |j|
        dels << j.merge!('timestamp' => d)
      end
    end
  end
end

def find_job(worker)
  worker = worker.downcase
  results = working_jobs_for_worker(worker)
  dels = delayed_jobs_for_worker(worker)
  results += dels.select do |j|
    j['class'].downcase.include?(worker) &&
      j.merge!('where_at' => 'delayed')
  end
  Resque.queues.each do |queue|
    queued = Resque.peek(queue, 0, Resque.size(queue))
    queued = [queued] unless queued.is_a?(Array)
    results += queued.select do |j|
      j['class'].downcase.include?(worker) &&
        j.merge!('queue' => queue, 'where_at' => 'queued')
    end
  end
  results
end

def format_time(t)
  t.strftime(::Resque::Scheduler::Server::TIMESTAMP_FORMAT)
end

def queue_from_class_name(class_name)
  Resque.queue_from_class(
    Resque::Scheduler::Util.constantize(class_name)
  )
end

def rails_env(name)
  Resque.schedule[name]['rails_env'] || Resque.schedule[name]['env']
end

def schedule_class(config)
  if config['class'].nil? && !config['custom_job_class'].nil?
    config['custom_job_class']
  else
    config['class']
  end
end

def schedule_interval(config)
  if config['every']
    schedule_interval_every(config['every'])
  elsif config['cron']
    'cron: ' + config['cron'].to_s
  else
    'Not currently scheduled'
  end
end

def schedule_interval_every(every)
  every = [*every]
  s = 'every: ' << every.first
  return s unless every.length > 1
  s << ' ('
  meta = every.last.map do |key, value|
    "#{key.to_s.tr('_', ' ')} #{value}"
  end
  s << meta.join(', ') << ')'
end

def scheduled_in_this_env?(name)
  return true if rails_env(name).nil?
  rails_env(name).split(/[\s,]+/).include?(Resque::Scheduler.env)
end

def scheduler_template(name)
  File.read(
    File.expand_path("../server/views/#{name}.erb", __FILE__)
  )
end

def scheduler_view(filename, options = {}, locals = {})
  source = File.read(File.join(VIEW_PATH, "#{filename}.erb"))
  erb source, options, locals
end

def show_job_arguments(args)
  Array(args).map(&:inspect).join("\n")
end

def working_jobs_for_worker(worker)
  [].tap do |results|
    working = [*Resque.working]
    work = working.select do |w|
      w.job && w.job['payload'] &&
        w.job['payload']['class'].downcase.include?(worker)
    end
    work.each do |w|
      results += [
        w.job['payload'].merge(
          'queue' => w.job['queue'], 'where_at' => 'working'
        )
      ]
    end
  end
end