module ClusterFuncs

  def getNewInstanceName(klass)
    @instanceId||=0
    @instanceId+=1
    klass.to_s+@instanceId.to_s
  end
  def checkRequirements(appClass)
    reqs=appClass.requirements
    reqs.each{|req|
      if getApp(req).nil?
        f=@appClasses.select{|klass|klass.providing.member?(req)}
        if f.length==0
          raise "PROBLEM: #{req} not found!"
        else
          debug "STARTING REQUIRED #{f[0]}"
          run(f[0].to_s.gsub(/App$/,""))
        end
        
      end
    }
  end

  def getLocalApplications
    @apps
  end
  def getApps(type)
    if type.is_a?(Class)
      return @apps.select{|app|app.is_a?(type)}
    end

    if type.is_a?(String)
      type+="App" unless type=~/App$/
      return @apps.select{|app|app.class.to_s==type}
    end

    @apps.select{|app|
      app.provides?(type)
    }
  end

  def getApplicationTypes
    @appClasses
  end

  def getOrCreate(appName)
    a=getApp(appName)
    a=run(appName) unless a
    a
  end

  def allUpAndRunning
    @apps.select{|a|a.running==false}.length==0
  end

  def waitUntilAllUpAndRunning
    while not allUpAndRunning
      sleep 0.1
    end
  end

  def runAndWait(appName,*params)
    app=run(appName,*params)
    while app.running==false
      sleep 0.1
      log "WAIT for #{app} to startup"
    end
  end
  
  def run(appName,*params)
    return nil if @stopping
    log "Starting #{appName}"
    appClass=@appClasses.select{|appClass|
      appName.to_s+"App"==appClass.to_s
    }[0]
    raise "Class #{appName} not Found" unless appClass
    checkRequirements(appClass)


    log "NAME:",appName,params
    a=nil

    @stopMutex.synchronize {
      return if @stopped
      if params.is_a?(Array)
        params=params[0]
      end
      if params.is_a?(Hash)
        return if @apps.select{|app|app.getAppId==params[:appId]}.length>0

        # FIXME: support multiple apps of same type running
        return if @apps.select{|app|
          app.class==appClass
        }.length>0
      end

      #return if getAppById()
      log "Running Testbed #{self}"
      options=@options
      if params
      if params.length>0
        if params[-1].is_a?(Hash)
          options=params[-1]
        end
      end
      end
      a=appClass.new(self,options)
      i=a.object_id
      y=Thread.new(a) {|a|
        Thread.current[:appName2]=appName
        begin
          @apps<<a
          log "TRYING TO START #{a}"

          a.startup
          a.running=true
          a.run
          debug "FINISHED #{a}"
        rescue Exception=>e
          log e,e.backtrace
        end
      }
      loop  do
        sleep 0.01
        break if @apps.member?(a)
      end
      y[:appName]=appName
      @tbedThreads||={}
      @tbedThreads[i]=y
      a
    }
    a
  end

  def log_line(line)
    puts line
  end
  def debug(*p)
    log_direct(caller[0],nil,p.map{|x|x.to_s}.join(" "))
  end
  def log_direct(place,instance,what)
    place.gsub!(/\/.*\//,'/..../')
    i=""
    i="[#{instance}]" if instance

    t=Time.new.strftime("%Y-%m-%d %H:%M:%S")
    what.split("\n").each{|line|
      log_line "[#{t}][#{place}]#{i} "+line
    }

  end

  def createInstanceId
    Crypt::hexdigest(rand.to_s+Time.new.to_s)
  end

end