class Rufus::Scheduler

def self.start_new
  s = self.new
  s.start
  s
end

def at_job_count
  @pending_jobs.select { |j| j.instance_of?(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)
  at
end

def cron_job_count
  @cron_jobs.size
end

def do_schedule_at (at, params={}, &block)
  #puts "0 at is '#{at.to_s}' (#{at.class})"
  at = at_to_f at
  #puts "1 at is '#{at.to_s}' (#{at.class})"}"
  jobClass = params[:every] ? EveryJob : AtJob
  job_id = params[:job_id]
  b = to_block params, &block
  job = jobClass.new self, at, job_id, params, &b
  #do_unschedule(job_id) if job_id
  if at < (Time.new.to_f + @precision)
    job.trigger() unless params[:discard_past]
    return nil
  end
  @schedule_queue << job
  job.job_id
end

def do_unschedule (job_id)
  for i in 0...@pending_jobs.length
    if @pending_jobs[i].job_id == job_id
      @pending_jobs.delete_at i
      return true
    end
  end
    #
    # not using delete_if because it scans the whole list
  do_unschedule_cron_job job_id
end

def do_unschedule_cron_job (job_id)
  (@cron_jobs.delete(job_id) != nil)
end

def duration_to_f (s)
  return s if s.kind_of?(Float)
  return Rufus::parse_time_string(s) if s.kind_of?(String)
  Float(s.to_s)
end

def every_job_count
  @pending_jobs.select { |j| j.is_a?(EveryJob) }.size
end

def find_jobs (tag)
  @cron_jobs.values.find_all { |job| job.has_tag?(tag) } +
  @pending_jobs.find_all { |job| job.has_tag?(tag) }
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] || @pending_jobs.find { |job| job.job_id == job_id }
end

def get_schedulable (job_id)
  #return nil unless job_id
  j = get_job(job_id)
  return j.schedulable if j.respond_to?(:schedulable)
  nil
end

def initialize (params={})
  super()
  @pending_jobs = []
  @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 = { :schedulable => params } \
    if params.is_a?(Schedulable)
  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]
  cron_id = params[:job_id] unless cron_id
  #unschedule(cron_id) if cron_id
  @unschedule_queue << [ :cron, cron_id ]
  #
  # schedule
  b = to_block(params, &block)
  job = CronJob.new(self, cron_id, cron_line, params, &b)
  #@cron_jobs[job.job_id] = job
  @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)
  f = duration_to_f freq
  params = prepare_params params
  schedulable = params[:schedulable]
  params[:every] = freq
  first_at = params.delete :first_at
  first_in = params.delete :first_in
  previous_at = params[:previous_at]
  next_at = if first_at
    first_at
  elsif first_in
    Time.now.to_f + duration_to_f(first_in)
  elsif previous_at
    previous_at + f
  else
    Time.now.to_f + f
  end
  do_schedule_at(next_at, params) do |job_id, at|
    #
    # trigger ...
    hit_exception = false
    begin
      if schedulable
        schedulable.trigger params
      else
        block.call job_id, at, params
      end
    rescue Exception => e
      log_exception e
      hit_exception = true
    end
    # cannot use a return here !!! (block)
    unless \
      @dont_reschedule_every or
      (params[:dont_reschedule] == true) or
      (hit_exception and params[:try_again] == false)
      #
      # ok, reschedule ...
      params[:job_id] = job_id
      params[:previous_at] = at
      schedule_every params[:every], params, &block
        #
        # yes, this is a kind of recursion
        # note that params[:every] might have been changed
        # by the block/schedulable code
    end
    job_id
  end
end

def schedule_in (duration, params={}, &block)
  do_schedule_at(
    Time.new.to_f + 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
  #puts Time.now.to_f
  #puts @pending_jobs.collect { |j| [ j.job_id, j.at ] }.inspect
  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.new
  if @exit_when_no_more_jobs
    if @pending_jobs.size < 1
      @stopped = true
      return
    end
    @dont_reschedule_every = true if at_job_count < 1
  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
    #puts "step() @cron_jobs.size #{@cron_jobs.size}"
    @cron_jobs.each do |cron_id, cron_job|
      #puts "step() cron_id : #{cron_id}"
      #trigger(cron_job) if cron_job.matches?(now, @precision)
      trigger(cron_job) 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
    trigger job
    @pending_jobs.delete_at 0
  end
end

def step_unschedule
  loop do
    break if @unschedule_queue.empty?
    type, job_id = @unschedule_queue.pop
    if type == :cron
      do_unschedule_cron_job job_id
    else
      do_unschedule job_id
    end
  end
end

def stop
  @stopped = true
end

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

def trigger (job)
  Thread.new do
    begin
      job.trigger
    rescue Exception => e
      log_exception e
    end
  end
end

def unschedule (job_id)
  @unschedule_queue << [ :at, job_id ]
end

def unschedule_cron_job (job_id)
  @unschedule_queue << [ :cron, job_id ]
end