class Rufus::Scheduler

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)
    result = @cron_jobs.values.find_all do |job|
        job.has_tag?(tag)
    end
    result + @pending_jobs.find_all do |job|
        job.has_tag?(tag)
    end
end

def find_schedulables (tag)
    #jobs = find_jobs(tag)
    #result = []
    #jobs.each do |job|
    #    result.push(job.schedulable) if job.respond_to?(:schedulable)
    #end
    #result
    find_jobs(tags).inject([]) do |result, job|
        result.push(job.schedulable) if job.respond_to?(:schedulable)
        result
    end
end

def get_job (job_id)
    job = @cron_jobs[job_id]
    return job if job
    @pending_jobs.find do |job|
        job.job_id == job_id
    end
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
        @precision = Float(params[:scheduler_precision])
    rescue Exception => e
        # let precision at its default value
    end
    @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 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
        if defined?(JRUBY_VERSION)
            require 'java'
            java.lang.Thread.current_thread.name = \
                "openwferu scheduler (Ruby Thread)"
        end
        loop do
            break if @stopped
            step
            sleep @precision
                # TODO : adjust precision
        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)
        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