require 'thread'
require 'ftools'

require 'parallel_each.rb'
require 'tools/thread_tool.rb'

def asBaseDir
  File.expand_path('../..',__FILE__)
end

class File
  def self.load(filename)
    return nil unless File.file?(filename)
    File.open(filename) {|f|f.read}
  end
end

class Class
  def deprecated(*funcs)
    #puts "WARNING: #{funcs} are deprecated!!!"
  end
end

class Dir
  def self.mkdir_save(*args)
      return if File.directory?(*args)
    begin
      self.mkdir(*args)
    rescue Object=>e
      d=*args
      p=File.split(d)[0]
      self.mkdir_save(p) if p!=d
      self.mkdir(*args)
    end
  end

  def self.rmdir_f(dir)
    if File.directory?(dir)
      files=Dir[File.join(dir,"*")]
      files.each{|f|rmdir_f(f)}
      Dir.delete(dir)
    elsif File.file?(dir)
      File.delete(dir)
    end
  end
end

class String
  # convert lowercase underscored strings to camelcase
  def camelCase
    return self if length<2
    (self[0..0].upcase+self[1..-1]).gsub(/(_.)/){|s|s[1..-1].upcase}
  end

  def underscored
    (self[0..0].downcase+self[1..-1]).gsub(/([A-Z])/){|s|"_"+s.downcase}
  end
  
  # convert camelcase to lowercase underscored
  def dirName
    underscored
  end
  
  # convvert (some) html-entities
  def to_hents
    self.gsub("&","&amp;").gsub("<","&lt;").gsub(">","&gt;")
  end
  
  # convert plaintext to html (entities and newlines)
  def to_h
    self.to_hents.gsub("\n","<br>\n")
  end

  def to_base64
    [self].pack("m")
  end
end

class AssertionFailed<Exception
  
end

def assert(&b)
  unless b.call
    dcaller=caller[0]
    file,line,func=dcaller.split(":")
    content=assertReadLine(file,line.to_i)
    s="Assertion failed #{content} in #{file}:#{line}"
    body=caller.join("\n")
    glog(s+"\n"+body)
    puts s
    raise AssertionFailed.new   
  end
end


def assertReadLine(file,line)
  f=File.open(file,"r")
  all=f.read
  lines=all.split("\n")
  l=lines[line-1]
  f.close
  l
end

class Array
  
  class Groups<Hash
    def max_by_value(&block)
      r={}
      each{|k,vs|
        value=nil
        vs.each{|e|
          curValue=block.call(e)
          value||=curValue
          value=[curValue,value].max
        }
        r[k]=value
      }
      r
    end
  end
  
  alias :oldUniq :uniq 
  def uniq(&block)
    if block.nil?
      return oldUniq
    else
      a=[]
      ks=[]
      each{|v|
        k=block.call(v)
        unless ks.member?(k)
          ks<<k
          a<<v
        end
      }
      a
    end
  end
  
  def shuffle!
    sort_by {|a,b|rand}
  end
  def shuffle
    dup.sort_by {|a,b|rand}
  end
  def map2hash(&b)
    h={}
    each{|e|
      res=b.call(e)
      h[e]=res
    }
    h
  end
  
  def uniq_count(&b)
    h={}
    each{|e|
      v=b.call(e)
      h[v]||=0
      h[v]+=1
    }
    h
  end
  
  def group_by(&block)
    groups=Groups.new
    
    each{|e|
      g=block.call(e)
      groups[g]||=[]
      groups[g] << e
    }
    groups
  end
end

class Hash
  def map_to_h(&b)
    h={}
    self.each{|k,v|
      h[k]=b.call(k,v)
    }
    h
  end
  def map_to_a(&b)
    h=[]
    self.each{|k,v|
      h << b.call(k,v)
    }
    h
  end
  alias :select_to_a :select
  def select(&b)
    h={}
    self.each{|k,v|
      if b.call(k,v)
        h[k]=v
      end
    }
    h
  end
end

class Symbol
  def <=>(o)
    self.to_s<=>o.to_s
  end
end

def getClass(name)
  #pp "TRY GETCLASS #{name}"
  $CLASS_CACHE||={}

  unless $CLASS_CACHE.key?(name)
    c=nil
    begin
      ObjectSpace.each_object{|o|
        c=o if o.to_s==name and o.is_a?(Class)
      }
    rescue
      c=instance_eval(name)
    end

    $CLASS_CACHE[name]=c
  end
  $CLASS_CACHE[name]  
end

class FalseClass
  # make booleans sortable
  def <=>(o)
    case o
      when FalseClass
        0
      when TrueClass
        1
      else
        0
    end
  end
end


class TrueClass
  def <=>(o)
    case o
      when FalseClass
        -1
      when TrueClass
        0
      else
        0
    end
  end
end

def hexDist(hash1,hash2)
  assert{hash1.length==hash2.length}
  dist=0
  (0...hash1.length).each{|i|
     current=(hash1[i]^hash2[i])
     dist*=256
     dist+=current
     #r+=c
  }
  dist
  
end


def glog(*s)
  #puts "GLOBAL LOG #{caller[0]} #{Time.now} "+(s.map{|x|x.to_s}.join("; "))
end

def measureTime(depth=1,&block)
  startTime=Time.now
  r=block.call
  endTime=Time.now
  glog caller[0...depth],"TIME:",(endTime-startTime)
  r
end