class Rufus::Scheduler

def self.is_cron_string (s)
  s.match ".+ .+ .+ .+ .+" # well...
end

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

def all_jobs
  find_jobs()
end

def at_job_count
  @non_cron_jobs.values.select { |j| j.class == AtJob }.size
end

def at_to_f (at)
  at = Rufus::to_ruby_time(at) if at.kind_of?(String)
  at = Rufus::to_gm_time(at) if at.kind_of?(DateTime)
  at = at.to_f if at.kind_of?(Time)
  raise "cannot schedule at : #{at.inspect}" unless at.is_a?(Float)
  at
end

def cron_job_count
  @cron_jobs.size
end

def do_schedule_at (at, params={}, &block)
  job = params.delete(:job)
  unless job
    jobClass = params[:every] ? EveryJob : AtJob
    b = to_block(params, &block)
    job = jobClass.new(self, at_to_f(at), params[:job_id], params, &b)
  end
  if jobClass == AtJob && job.at < (Time.new.to_f + @precision)
    job.trigger() unless params[:discard_past]
    @non_cron_jobs.delete job.job_id # just to be sure
    return nil
  end
  @non_cron_jobs[job.job_id] = job
  @schedule_queue << job
  job.job_id
end

def do_unschedule (job_id)
  job = get_job job_id
  return (@cron_jobs.delete(job_id) != nil) if job.is_a?(CronJob)
  return false unless job # not found
  if job.is_a?(AtJob) # catches AtJob and EveryJob instances
    @non_cron_jobs.delete(job_id)
    job.params[:dont_reschedule] = true # for AtJob as well, no worries
  end
  for i in 0...@pending_jobs.length
    if @pending_jobs[i].job_id == job_id
      @pending_jobs.delete_at i
      return true # asap
    end
  end
  true
end

def duration_to_f (s)
  Rufus.duration_to_f(s)
end

def every_job_count
  @non_cron_jobs.values.select { |j| j.class == EveryJob }.size
end

def find_jobs (tag=nil)
  jobs = @cron_jobs.values + @non_cron_jobs.values
  jobs = jobs.select { |job| job.has_tag?(tag) } if tag
  jobs
end

def find_schedulables (tag)
  find_jobs(tag).find_all { |job| job.respond_to?(:schedulable) }
end

def get_job (job_id)
  @cron_jobs[job_id] || @non_cron_jobs[job_id]
end

def get_schedulable (job_id)
  j = get_job(job_id)
  j.respond_to?(:schedulable) ? j.schedulable : nil
end

def initialize (params={})
  super()
  @pending_jobs = []
  @cron_jobs = {}
  @non_cron_jobs = {}
  @schedule_queue = Queue.new
  @unschedule_queue = Queue.new
    #
    # sync between the step() method and the [un]schedule
    # methods is done via these queues, no more mutex
  @scheduler_thread = nil
  @precision = 0.250
    # every 250ms, the scheduler wakes up (default value)
  begin
    self.precision = Float(params[:scheduler_precision])
  rescue Exception => e
    # let precision at its default value
  end
  @thread_name = params[:thread_name] || "rufus scheduler"
  #@correction = 0.00045
  @exit_when_no_more_jobs = false
  #@dont_reschedule_every = false
  @last_cron_second = -1
  @stopped = true
end

def join
  @scheduler_thread.join
end

def join_until_no_more_jobs
  @exit_when_no_more_jobs = true
  join
end

def log_exception (e)
  message =
    "trigger() caught exception\n" +
    e.to_s + "\n" +
    e.backtrace.join("\n")
  if self.respond_to?(:lwarn)
    lwarn { message }
  else
    puts message
  end
end

def pending_job_count
  @pending_jobs.size
end

def precision= (f)
  raise 'precision must be 0.0 < p <= 1.0' \
    if f <= 0.0 or f > 1.0
  @precision = f
end

def prepare_params (params)
  params.is_a?(Schedulable) ? { :schedulable => params } : params
end

def push_pending_job (job)
  old = @pending_jobs.find { |j| j.job_id == job.job_id }
  @pending_jobs.delete(old) if old
    #
    # override previous job with same id
  if @pending_jobs.length < 1 or job.at >= @pending_jobs.last.at
    @pending_jobs << job
    return
  end
  for i in 0...@pending_jobs.length
    if job.at <= @pending_jobs[i].at
      @pending_jobs[i, 0] = job
      return # right place found
    end
  end
end

def schedule (cron_line, params={}, &block)
  params = prepare_params(params)
  #
  # is a job with the same id already scheduled ?
  cron_id = params[:cron_id] || params[:job_id]
  #@unschedule_queue << cron_id
  #
  # schedule
  b = to_block(params, &block)
  job = CronJob.new(self, cron_id, cron_line, params, &b)
  @schedule_queue << job
  job.job_id
end

def schedule_at (at, params={}, &block)
  do_schedule_at(
    at,
    prepare_params(params),
    &block)
end

def schedule_every (freq, params={}, &block)
  params = prepare_params(params)
  params[:every] = freq
  first_at = params[:first_at]
  first_in = params[:first_in]
  #params[:delayed] = true if first_at or first_in
  first_at = if first_at
    at_to_f(first_at)
  elsif first_in
    Time.now.to_f + Rufus.duration_to_f(first_in)
  else
    Time.now.to_f + Rufus.duration_to_f(freq) # not triggering immediately
  end
  do_schedule_at(first_at, params, &block)
end

def schedule_in (duration, params={}, &block)
  do_schedule_at(
    Time.new.to_f + Rufus.duration_to_f(duration),
    prepare_params(params),
    &block)
end

def start
  @stopped = false
  @scheduler_thread = Thread.new do
    Thread.current[:name] = @thread_name
    if defined?(JRUBY_VERSION)
      require 'java'
      java.lang.Thread.current_thread.name = @thread_name
    end
    loop do
      break if @stopped
      t0 = Time.now.to_f
      step
      d = Time.now.to_f - t0 # + @correction
      next if d > @precision
      sleep(@precision - d)
    end
  end
end

def step
  step_unschedule
    # unschedules any job in the unschedule queue before
    # they have a chance to get triggered.
  step_trigger
    # triggers eligible jobs
  step_schedule
    # schedule new jobs
  # done.
end

def step_schedule
  loop do
    break if @schedule_queue.empty?
    j = @schedule_queue.pop
    if j.is_a?(CronJob)
      @cron_jobs[j.job_id] = j
    else # it's an 'at' job
      push_pending_job j
    end
  end
end

def step_trigger
  now = Time.now
  if @exit_when_no_more_jobs && @pending_jobs.size < 1
    @stopped = true
    return
  end
  # TODO : eventually consider running cron / pending
  # job triggering in two different threads
  #
  # but well... there's the synchronization issue...
  #
  # cron jobs
  if now.sec != @last_cron_second
    @last_cron_second = now.sec
    @cron_jobs.each do |cron_id, cron_job|
      #trigger(cron_job) if cron_job.matches?(now, @precision)
      cron_job.trigger if cron_job.matches?(now)
    end
  end
  #
  # pending jobs
  now = now.to_f
    #
    # that's what at jobs do understand
  loop do
    break if @pending_jobs.length < 1
    job = @pending_jobs[0]
    break if job.at > now
    #if job.at <= now
      #
      # obviously
    job.trigger
    @pending_jobs.delete_at 0
  end
end

def step_unschedule
  loop do
    break if @unschedule_queue.empty?
    do_unschedule(@unschedule_queue.pop)
  end
end

def stop
  @stopped = true
end

def to_block (params, &block)
  return block if block
  schedulable = params.delete(:schedulable)
  return nil unless schedulable
  l = lambda do
    schedulable.trigger(params)
  end
  class << l
    attr_accessor :schedulable
  end
  l.schedulable = schedulable
  l
end

def unschedule (job_id)
  @unschedule_queue << job_id
end

def unschedule_cron_job (job_id)
  unschedule(job_id)
end