TimerThreadInterval = 1

class AsyncTimer
    include Singleton
    include ClassLevelLogger
    include StatsWrapper


    def initialize()
        @timers = ThreadSafe::Array.new    #<--- array of hashes of timers this Timer class is processing
                                           #<--- hash structure of timer:
                                           #  :timer_id    #<---- random timer id used later for killing this timer
                                           #  :timeout     #<---- timeout in seconds from timer start that this timer fires
                                           #  :lam_block   #<---- lambda block to call when this timer fires
                                           #  :event       #<---- if we have an event associated with the timer

        @timer_thread = nil  #<--- this is the timer thread processing the timers

        start_timer_thread
    end

    def execute_timer(timer)
      AsyncReactor.instance.add_job lambda {
        begin

            timer[:lam_block].call

        rescue => err
            alert_pop("Fire Timer Execution Error: #{err.message}\n#{err.backtrace}")
        end
      }
    end

    def execute_interval(timer)
        AsyncReactor.instance.add_job lambda {
          begin

            timer[:interval_start] = Time.now.to_i
            timer[:interval_block].call if timer[:interval_block]

          rescue => err
              alert_pop("Fire Timer Execution Error: #{err.message}\n#{err.backtrace.join("\n")}")
          end
        }
    end

    def timer_id()
        Time.now.to_i + rand(99999999)
    end

    def kill_timer(timer_id)
        index = @timers.find_index{ |ele| ele[:timer_id] == timer_id }
        return if !index

        timer_deleted = @timers.delete_at(index)
        debug("Deleted Timer: #{timer_deleted.inspect}")
    end

    def start_timer(timeout, lam_block, event=nil, interval=nil, lam_interval_block=nil)

        @timers.push( {
                        :timeout      => timeout,
                        :start_time   => Time.now.to_i,
                        :timer_id     => timer_id,
                        :lam_block    => lam_block,
                        :event        => event,
                        :interval     => interval,
                        :interval_block => lam_interval_block,
                        :interval_start => Time.now.to_i
                      } )

        debug("Added Timer: #{@timers.last.inspect}")

        @timers.last[:timer_id]

    end

    def fire_timer?(timer)
        time_now = Time.now.to_i
        time_start = timer[:start_time]
        diff = ( time_now - time_start )
        alert_pop("Got Negative Timer!") if diff.negative?
        diff >= timer[:timeout]
    end

    def fire_interval?(timer)
        return false if !timer[:interval]
        time_now = Time.now.to_i
        interval_start = timer[:interval_start]
        diff = ( time_now - interval_start )
        diff >= timer[:interval]
    end

    def dead_event?(timer)
        return false if timer[:event].nil?
        return true if !timer[:event].share_id_exists?
        false
    end

    def check_timers()
        return if @timers.empty?

        timers_to_fire =    @timers.find_all{ |timer| fire_timer?(timer) }
        intervals_to_fire = @timers.find_all{ |timer| fire_interval?(timer) }

        #run our intervals to fire first
        intervals_to_fire.each do |timer| execute_interval( timer ) end

        #fire and delete the timers here
        timers_to_fire.each do |timer|
            execute_timer( @timers.delete(timer) )
        end
    end

    def start_timer_thread()
      @timer_thread = Thread.new {
          loop do
            begin
                check_timers()
                stat_sharemediator_checked_inc
                stat_sharemediator_timers_set(@timers.length)
                sleep(TimerThreadInterval)
            rescue => err
                alert_pop("Main Timer Thread Error : #{err.message}\n#{err.backtrace}")
            end
          end
      }
    end
end