class Middleman::Server

def self.after_feature_init(&block)
  @@run_after_features << block
end

def self.current_layout
  @layout
end

def self.mime(ext, type)
  ext = ".#{ext}" unless ext.to_s[0] == ?.
  ::Rack::Mime::MIME_TYPES[ext.to_s] = type
end

def self.new(*args, &block)  
  # Check for and evaluate local configuration
  local_config = File.join(self.root, "config.rb")
  if File.exists? local_config
    $stderr.puts "== Reading:  Local config" if logging?
    Middleman::Server.class_eval File.read(local_config)
    set :app_file, File.expand_path(local_config)
  end
  
  @@run_after_features.each { |block| class_eval(&block) }
  
  super
end

def self.page(url, options={}, &block)
  url = url.gsub(%r{#{settings.index_file}$}, "")
  url = url.gsub(%r{(\/)$}, "") if url.length > 1
  
  paths = [url]
  paths << "#{url}/" if url.length > 1 && url.split("/").last.split('.').length <= 1
  paths << "/#{path_to_index(url)}"
  options[:layout] = current_layout if options[:layout].nil?
  paths.each do |p|
    get(p) do
      return yield if block_given?
      process_request(options)
    end
  end
end

def self.path_to_index(path)
  parts = path ? path.split('/') : []
  if parts.last.nil? || parts.last.split('.').length == 1
    path = File.join(path, settings.index_file) 
  end
  path.gsub(%r{^/}, '')
end

def self.set(option, value=self, &block)
  if block_given?
    value = Proc.new { block }
  end
  
  super(option, value, &nil)
end

def self.with_layout(layout_name, &block)
  old_layout = current_layout
  
  layout(layout_name)
  class_eval(&block) if block_given?
ensure
  layout(old_layout)
end

def process_request(options={})
  # Normalize the path and add index if we're looking at a directory
  path = self.class.path_to_index(request.path)
  
  extensionless_path, template_engine = resolve_template(path)
  
  if !::Tilt.mappings.has_key?(template_engine.to_s)
    content_type mime_type(File.extname(path)), :charset => 'utf-8'
    status 200
    send_file File.join(Middleman::Server.views, path)
    return
  end
  
  full_file_path = "#{extensionless_path}.#{template_engine}"
  system_path = File.join(settings.views, full_file_path)
  data, content = self.class.parse_front_matter(File.read(system_path))
  
  %w(layout layout_engine).each do |opt|
    if data.has_key?(opt)
      options[opt.to_sym] = data.delete(opt)
    end
  end
  
  # Forward remaining data to helpers
  self.class.data_content("page", data)
  
  old_layout = settings.current_layout
  settings.layout(options[:layout]) if !options[:layout].nil?
  layout = settings.fetch_layout_path.to_sym
  layout = false if options[:layout] == false or path =~ /\.(css|js)$/
  
  render_options = { :layout => layout }
  render_options[:layout_engine] = options[:layout_engine] if options.has_key? :layout_engine
  result = render(path, render_options)
  settings.layout(old_layout)
  
  if result
    content_type mime_type(File.extname(path)), :charset => 'utf-8'
    status 200
    return result
  end
  
  status 404
rescue Padrino::Rendering::TemplateNotFound
  $stderr.puts "File not found: #{request.path}"
  status 404
end