class Rufus::Scheduler::SchedulerCore

def self.start_new(opts={})
  s = self.new(opts)
  s.start
  s
end

def add_cron_job(job)
  complain_if_blocking_and_timeout(job)
  @cron_jobs << job
  job
end

def add_job(job)
  complain_if_blocking_and_timeout(job)
  return nil if job.params[:discard_past] && Time.now.to_f >= job.at
  @jobs << job
  job
end

def all_jobs
  jobs.merge(cron_jobs)
end

def at(t, s=nil, opts={}, &block)
  add_job(AtJob.new(self, t, combine_opts(s, opts), &block))
end

def combine_opts(schedulable, opts)
  if schedulable.respond_to?(:trigger) || schedulable.respond_to?(:call)
    opts[:schedulable] = schedulable
  elsif schedulable != nil
    opts = schedulable.merge(opts)
  end
  opts
end

def complain_if_blocking_and_timeout(job)
  raise(
    ArgumentError.new('cannot set a :timeout on a :blocking job')
  ) if job.params[:blocking] and job.params[:timeout]
end

def cron(cronstring, s=nil, opts={}, &block)
  add_cron_job(CronJob.new(self, cronstring, combine_opts(s, opts), &block))
end

def cron_jobs
  @cron_jobs.to_h
end

def do_handle_exception(job, exception)
  begin
    [ :log_exception, :handle_exception, :on_exception ].each do |m|
      next unless self.respond_to?(m)
      if method(m).arity == 1
        self.send(m, exception)
      else
        self.send(m, job, exception)
      end
      return
        # exception was handled successfully
    end
  rescue Exception => e
    $stderr.puts '*' * 80
    $stderr.puts 'the exception handling method itself had an issue:'
    $stderr.puts e
    $stderr.puts *e.backtrace
    $stderr.puts '*' * 80
  end
  $stderr.puts '=' * 80
  $stderr.puts 'scheduler caught exception:'
  $stderr.puts exception
  $stderr.puts *exception.backtrace
  $stderr.puts '=' * 80
end

def every(t, s=nil, opts={}, &block)
  add_job(EveryJob.new(self, t, combine_opts(s, opts), &block))
end

def find(job_or_id)
  return job_or_id if job_or_id.respond_to?(:job_id)
  job = all_jobs[job_or_id]
  raise ArgumentError.new(
    "couldn't find job #{job_or_id.inspect}"
  ) unless job
  job
end

def find_by_tag(tag)
  all_jobs.values.select { |j| j.tags.include?(tag) }
end

def get_queue(type, opts)
  q = if type == :cron
    opts[:cron_job_queue] || Rufus::Scheduler::CronJobQueue.new
  else
    opts[:job_queue] || Rufus::Scheduler::JobQueue.new
  end
  q.scheduler = self if q.respond_to?(:scheduler=)
  q
end

def in(t, s=nil, opts={}, &block)
  add_job(InJob.new(self, t, combine_opts(s, opts), &block))
end

def initialize(opts={})
  @options = opts
  @jobs = get_queue(:at, opts)
  @cron_jobs = get_queue(:cron, opts)
  @frequency = @options[:frequency] || 0.330
  @mutexes = {}
end

def jobs
  @jobs.to_h
end

def pause(job_or_id)
  find(job_or_id).pause
end

def resume(job_or_id)
  find(job_or_id).resume
end

def running_jobs
  Thread.list.collect { |t|
    t["rufus_scheduler__trigger_thread__#{self.object_id}"]
  }.compact
end

def step
  @cron_jobs.trigger_matching_jobs
  @jobs.trigger_matching_jobs
end

def trigger_job(params, &block)
  if params[:blocking]
    block.call
  elsif m = params[:mutex]
    m = (@mutexes[m.to_s] ||= Mutex.new) unless m.is_a?(Mutex)
    Thread.new { m.synchronize { block.call } }
  else
    Thread.new { block.call }
  end
end

def trigger_threads
  Thread.list.select { |t|
    t["rufus_scheduler__trigger_thread__#{self.object_id}"]
  }
end

def unschedule(job_or_id)
  job_id = job_or_id.respond_to?(:job_id) ? job_or_id.job_id : job_or_id
  @jobs.unschedule(job_id) || @cron_jobs.unschedule(job_id)
end

def unschedule_by_tag(tag)
  jobs = find_by_tag(tag)
  jobs.each { |job| unschedule(job.job_id) }
  jobs
end