require 'thor'

module GoodJob
  class CLI < Thor
    RAILS_ENVIRONMENT_RB = File.expand_path("config/environment.rb")

    desc :start, "Start job worker"
    method_option :max_threads,
                  type: :numeric,
                  desc: "Maximum number of threads to use for working jobs (default: ActiveRecord::Base.connection_pool.size)"
    method_option :queues,
                  type: :string,
                  banner: "queue1,queue2",
                  desc: "Queues to work from. Separate multiple queues with commas (default: *)"
    method_option :poll_interval,
                  type: :numeric,
                  desc: "Interval between polls for available jobs in seconds (default: 1)"
    def start
      set_up_application!

      max_threads = (
        options[:max_threads] ||
        ENV['GOOD_JOB_MAX_THREADS'] ||
        ENV['RAILS_MAX_THREADS'] ||
        ActiveRecord::Base.connection_pool.size
      ).to_i

      queue_string = (
        options[:queues] ||
        ENV['GOOD_JOB_QUEUES'] ||
        '*'
      )

      poll_interval = (
        options[:poll_interval] ||
        ENV['GOOD_JOB_POLL_INTERVAL']
      ).to_i

      job_query = GoodJob::Job.queue_string(queue_string)
      job_performer = GoodJob::Performer.new(job_query, :perform_with_advisory_lock, name: queue_string)

      timer_options = {}
      timer_options[:execution_interval] = poll_interval if poll_interval.positive?

      pool_options = {
        max_threads: max_threads,
      }

      scheduler = GoodJob::Scheduler.new(job_performer, timer_options: timer_options, pool_options: pool_options)

      @stop_good_job_executable = false
      %w[INT TERM].each do |signal|
        trap(signal) { @stop_good_job_executable = true }
      end

      Kernel.loop do
        sleep 0.1
        break if @stop_good_job_executable || scheduler.shutdown?
      end

      scheduler.shutdown
    end

    default_task :start

    desc :cleanup_preserved_jobs, "Delete preserved job records"
    method_option :before_seconds_ago,
                  type: :numeric,
                  default: 24 * 60 * 60,
                  desc: "Delete records finished more than this many seconds ago"
    def cleanup_preserved_jobs
      set_up_application!

      timestamp = Time.current - options[:before_seconds_ago]
      ActiveSupport::Notifications.instrument("cleanup_preserved_jobs.good_job", { before_seconds_ago: options[:before_seconds_ago], timestamp: timestamp }) do |payload|
        deleted_records_count = GoodJob::Job.finished(timestamp).delete_all

        payload[:deleted_records_count] = deleted_records_count
      end
    end

    no_commands do
      def set_up_application!
        require RAILS_ENVIRONMENT_RB
      end
    end
  end
end