require 'action_controller'
require 'active_record'
require 'dispatcher'

Dependencies.mechanism = :require

ActionView::Base.cache_template_loading = true
ActionController::Base.view_paths = [File.join(File.dirname(__FILE__), "views")]
ActionController::Dispatcher.unprepared = false

class ActionController::Dispatcher
  def prepare_application
  end
end

def session(key, secret)
  ActionController::Base.session = { :session_key => key, :secret => secret }
end

def routes(&block)
  ActionController::Routing::Routes.draw do |map|
    map.instance_eval(&block)
  end
end

def controller(name, &block)
  ActionController::Routing.controller_paths << name

  klass = Object.const_set("#{name.camelize}Controller", Class.new(ActionController::Base))
  klass.class_eval(&block)
end

def start_webrick(host, port)
  require 'webrick'
  require 'webrick_server'

  puts
  puts "Booting WEBrick"

  puts "-- WEBrick listening at #{host}:#{port}"
  puts "-- Use CTRL-C to stop"

  DispatchServlet.dispatch(
    :port         => port,
    :ip           => host,
    :server_root  => File.dirname(__FILE__),
    :server_type  => WEBrick::SimpleServer,
    :charset      => "UTF-8",
    :mime_types   => WEBrick::HTTPUtils::DefaultMimeTypes,
    :debugger     => false)
end

def start_mongrel(host, port)
  require 'mongrel'
  require 'mongrel/rails'

  puts
  puts "Booting Mongrel"

  config = Mongrel::Configurator.new :host => host do
    listener :port => port do
      uri "/", :handler => Mongrel::Rails::RailsHandler.new(File.dirname(__FILE__))

      trap("INT") { stop }
      run
    end
  end

  puts "-- Mongrel listening at #{host}:#{port}"
  puts "-- Use CTRL-C to stop"

  config.join
end

def start(host, port)
  ActionController::Routing.use_controllers! ActionController::Routing.controller_paths

  begin
    require_library_or_gem 'mongrel'
  rescue Exception
    # Mongrel not available
  end

  if defined?(Mongrel)
    start_mongrel(host, port)
  else
    start_webrick(host, port)
  end
end

require 'microrails'

session("key", "secret" * 15)

routes do
  root :controller => 'home'
end

controller "home" do
  def index
    render :text => 'Hello World!'
  end
end

start "0.0.0.0", "5000"

if ARGV.length != 3
  STDERR.puts "usage: microrest.rb   "
  exit(1)
end

require 'microrails'

puts
puts "Starting Ruby On Rails"
puts "-- Establish connection"

ActiveRecord::Base.logger = Logger.new("#{File.dirname(__FILE__)}/microrest-ar.log")
ActiveRecord::Base.establish_connection(
  :adapter  => "sqlite3",
  :database => ARGV[2],
  :timeout  => 5000
)

puts "-- Setting secret key"

session(ARGV[2], ARGV[2] * 10)

puts "-- Mapping routes"

routes do
  ActiveRecord::Base.connection.tables.each do |t|
    resources t
  end
end

puts "-- Creating models and controllers"

ActiveRecord::Base.connection.tables.each do |t|
  class_name    = ActiveRecord::Base.class_name(t)
  singular_name = class_name.downcase
  plural_name   = t

  puts "-- -- Creating model #{class_name}"

  Object.const_set("#{class_name}", Class.new(ActiveRecord::Base))

  puts "-- -- Creating controller #{plural_name.camelize}Controller"

  controller t do
    module_eval <<-"end_eval"

      def index
        @#{plural_name} = #{class_name}.find(:all)

        respond_to do |format|
          format.html
          format.xml  { render :xml  => @#{plural_name} }
        end
      end

      def show
        @#{singular_name} = #{class_name}.find(params[:id])

        respond_to do |format|
          format.html
          format.xml  { render :xml  => @#{singular_name} }
        end
      end

      def new
        @#{singular_name} = #{class_name}.new

        respond_to do |format|
          format.html
          format.xml  { render :xml  => @#{singular_name} }
        end
      end

      def edit
        @#{singular_name} = #{class_name}.find(params[:id])
      end

      def create
        @#{singular_name} = #{class_name}.new(params[:#{singular_name}])

        puts
        params.each { |p| puts p.inspect }

        respond_to do |format|
          if @#{singular_name}.save
            flash[:notice] = '#{class_name} was successfully created.'

            format.html { redirect_to(@#{singular_name}) }
            format.xml  { render :xml  => @#{singular_name}, :status => :created, :location => @#{singular_name} }
          else
            format.html { render :action => "new" }
            format.xml  { render :xml  => @#{singular_name}.errors, :status => :unprocessable_entity }
          end
        end
      end

      def update
        @#{singular_name} = #{class_name}.find(params[:id])

        respond_to do |format|
          if @#{singular_name}.update_attributes(params[:#{singular_name}])
            flash[:notice] = '#{class_name} was successfully updated.'

            format.html { redirect_to(@#{singular_name} ) }
            format.xml  { head :ok }
          else
            format.html { render :action => "edit" }
            format.xml  { render :xml  => @#{singular_name}.errors, :status => :unprocessable_entity }
          end
        end
      end

      def destroy
        @#{singular_name} = #{class_name}.find(params[:id])
        @#{singular_name}.destroy

        respond_to do |format|
          format.html { redirect_to(@#{plural_name}_url) }
          format.xml  { head :ok }
        end
      end
    end_eval
  end
end

start(ARGV[0], ARGV[1])