module Padrino

def self.bin(*args)
  @_padrino_bin ||= [self.ruby_command, File.expand_path("../../../bin/padrino", __FILE__)]
  args.empty? ? @_padrino_bin : system(args.unshift(@_padrino_bin).join(" "))
end

def self.caller_files
  caller(1).
    map    { |line| line.split(/:(?=\d|in )/)[0,2] }.
    reject { |file,line| PADRINO_IGNORE_CALLERS.any? { |pattern| file =~ pattern } }.
    map    { |file,line| file }
end

def self.first_caller
  caller_files.first
end

def self.logger
  Padrino::Logger.logger
end

def self.logger=(value)
  Padrino::Logger.logger = value
end

def self.ruby_command
  @ruby_command ||= begin
    ruby = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
    ruby << RbConfig::CONFIG['EXEEXT']
    # escape string in case path to ruby executable contain spaces.
    ruby.sub!(/.*\s.*/m, '"\&"')
    ruby
  end
end

def self.run!(options={})
  Padrino.load!
  Server.start(Padrino.application, options)
end

def self.version
  VERSION
end

def after_load(&block)
  @_after_load ||= []
  @_after_load << block if block_given?
  @_after_load
end

def application
  raise ApplicationLoadError, "At least one app must be mounted!" unless Padrino.mounted_apps && Padrino.mounted_apps.any?
  router = Padrino::Router.new
  Padrino.mounted_apps.each { |app| app.map_onto(router) }
  if middleware.present?
    builder = Rack::Builder.new
    middleware.each { |c,a,b| builder.use(c, *a, &b) }
    builder.run(router)
    builder.to_app
  else
    router
  end
end

def apps_configuration
  @_global_configuration
end

def before_load(&block)
  @_before_load ||= []
  @_before_load << block if block_given?
  @_before_load
end

def called_from
  @_called_from || first_caller
end

def clear!
  Padrino.clear_middleware!
  Padrino.mounted_apps.clear
  @_load_paths = nil
  @_dependency_paths = nil
  @_global_configuration = nil
  Padrino.before_load.clear
  Padrino.after_load.clear
  Padrino::Reloader.clear!
  Thread.current[:padrino_loaded] = nil
end

def clear_middleware!
  @middleware = []
end

def configure_apps(&block)
  return  unless block_given?
  @@_global_configurations ||= []
  @@_global_configurations << block
  @_global_configuration = lambda do |app|
    @@_global_configurations.each do |configuration|
      app.class_eval(&configuration)
    end
  end
end

def dependency_paths
  @_dependency_paths ||= (dependency_paths_was + Array(module_paths))
end

def dependency_paths_was
  [
    "#{root}/config/database.rb", 
    "#{root}/lib/**/*.rb", 
    "#{root}/shared/lib/**/*.rb",
    "#{root}/models/**/*.rb", 
    "#{root}/shared/models/**/*.rb", 
    "#{root}/config/apps.rb"
  ]
end

def env
  @_env ||= PADRINO_ENV.to_s.downcase.to_sym
end

def gem(name, main_module)
  _,spec = Gem.loaded_specs.find { |spec_name, spec| spec_name == name }
  gems << spec
  modules << main_module
  spec.full_gem_path
end

def gems
  @gems ||= []
end

def insert_mounted_app(mounter)
  Padrino.mounted_apps.push(mounter) unless Padrino.mounted_apps.include?(mounter)
end

def load!
  return false if loaded?
  t = Time.now
  @_called_from = first_caller
  Padrino.set_encoding
  Padrino.set_load_paths(*load_paths) # We set the padrino load paths
  Padrino::Logger.setup! # Initialize our logger
  Padrino.require_dependencies("#{root}/config/database.rb", :nodeps => true) # Be sure to don't remove constants from dbs.
  Padrino::Reloader.lock! # Now we can remove constant from here to down
  Padrino.before_load.each(&:call) # Run before hooks
  Padrino.dependency_paths.each { |path| Padrino.require_dependencies(path) }
  Padrino.after_load.each(&:call) # Run after hooks
  Padrino::Reloader.run!
  Thread.current[:padrino_loaded] = true
  Padrino.logger.devel "Loaded Padrino in #{Time.now - t} seconds"
end

def load_paths
  @_load_paths_was = %w(lib models shared).map { |path| Padrino.root(path) }
  @_load_paths ||= @_load_paths_was
end

def loaded?
  Thread.current[:padrino_loaded]
end

def middleware
  @middleware ||= []
end

def module_paths
  Padrino.modules.map(&:dependency_paths).flatten!
end

def modules
  @modules ||= []
end

def mount(name, options={})
  Mounter.new(name, options)
end

def mounted_apps
  @mounted_apps ||= []
end

def mounted_root(*args)
  Padrino.root(@mounted_root ||= "", *args)
end

def reload!
  return unless Padrino::Reloader.changed?
  Padrino.before_load.each(&:call) # Run before hooks
  Padrino::Reloader.reload! # detects the modified files
  Padrino.after_load.each(&:call) # Run after hooks
end

def require_dependencies(*paths)
  options = paths.extract_options!
  # Extract all files to load
  files = paths.flatten.map { |path| Dir[path] }.flatten.uniq.sort
  while files.present?
    # List of errors and failed files
    errors, failed = [], []
    # We need a size to make sure things are loading
    size_at_start = files.size
    # Now we try to require our dependencies, we dup files
    # so we don't perform delete on the original array during
    # iteration, this prevent problems with rubinus
    files.dup.each do |file|
      begin
        Padrino::Reloader.safe_load(file, options.dup)
        files.delete(file)
      rescue NameError, LoadError => e
        Padrino.logger.devel "Problem while loading #{file}: #{e.to_s}"
        errors << e
        failed << file
      rescue Exception => e
        raise e
      end
    end
    # Stop processing if nothing loads or if everything has loaded
    raise errors.last if files.size == size_at_start && files.present?
    break if files.empty?
  end
end

def root(*args)
  File.expand_path(File.join(PADRINO_ROOT, *args))
end

def set_encoding
  if RUBY_VERSION < '1.9'
    $KCODE='u'
  else
    Encoding.default_external = Encoding::UTF_8
    Encoding.default_internal = Encoding::UTF_8
  end
  nil
end

def set_load_paths(*paths)
  $:.concat(paths); load_paths.concat(paths)
  $:.uniq!; load_paths.uniq!
end

def use(m, *args, &block)
  middleware << [m, args, block]
end