#!/usr/bin/env ruby

require "rubygems"
require "sinatra/base"
require "sinatra/streaming"
require "fileutils"
require "wisper"

$:.push File.dirname(__FILE__)
require "db/exceptions/invalid_record"
require "db/exceptions/record_not_found"
require "exceptions/dependency_error"
require "db/validators/all"
require "db/mongo/mongo_connector"
require "providers/provider_factory"

require "loader"

require "routes/v2.0"
require "helpers/version_2"

require "test_subscriber"
require "test_subscriber_2"

class DevopsService < Sinatra::Base

  helpers Sinatra::Streaming

  include Wisper::Publisher

  helpers Devops::Version2_0::Helpers
  include Devops::Loader
  register Devops::Version2_0::Routes

  def initialize config
    super()
    puts "Devops home: #{config[:devops_dir]}"
    unless File.exists?(config[:devops_dir])
      FileUtils.mkdir_p config[:devops_dir]
      puts "Directory '#{config[:devops_dir]}' has been created"
    end
    self.class.set :devops_home, config[:devops_dir]

    self.class.set :config, config
    @@config = config
    root = File.dirname(__FILE__)
    @@config[:keys_dir] = File.join(root, "../.devops_files/keys")
    if @@config[:scripts_dir].nil?
      #default scripts dir
      @@config[:scripts_dir] = File.join(root, "../.devops_files/scripts")
    end
    [:keys_dir, :scripts_dir].each {|key| d = @@config[key]; FileUtils.mkdir_p(d) unless File.exists?(d) }
    mongo = DevopsService.mongo
    self.class.set :mongo, mongo
    mongo.create_root_user
    ::Provider::ProviderFactory.init(config)
    #set_up_providers_keys!(::Provider::ProviderFactory.all, mongo)
    Wisper::GlobalListeners.subscribe(TestSubscriber2.new)
    Wisper.subscribe(TestSubscriber.new)
  end

  @@mongo
  # Returns mongo connector
  def self.mongo
    @@mongo ||= MongoConnector.new(@@config[:mongo_db], @@config[:mongo_host], @@config[:mongo_port], @@config[:mongo_user], @@config[:mongo_password])
  end

  # Returns config hash
  def self.config
    @@config
  end

  use Rack::Auth::Basic do |username, password|
    begin
      settings.mongo.user_auth(username, password)
      true
    rescue RecordNotFound => e
      false
    end
  end

  def self.create_method name, &block
    send(:generate_method, name, &block)
  end

  include Sinatra::JSON

  configure :production do
    disable :dump_errors
    disable :show_exceptions
    set :logging, Logger::INFO
    puts "TODO2"
  end

  configure :development do
    set :logging, Logger::DEBUG
    disable :raise_errors
#      disable :dump_errors
    set :show_exceptions, :after_handler
    puts "TODO1"
  end

  not_found do
    "Not found"
  end

  error RecordNotFound do
    e = env["sinatra.error"]
    logger.warn e.message
    halt_response(e.message, 404)
  end

  error InvalidRecord do
    e = env["sinatra.error"]
    logger.warn e.message
    logger.warn "Request body: #{request.body.read}"
    halt_response(e.message, 400)
  end

  error InvalidCommand do
    e = env["sinatra.error"]
    logger.warn e.message
    halt_response(e.message, 400)
  end

  error DependencyError do
    e = env["sinatra.error"]
    logger.warn e.message
    halt_response(e.message, 400)
  end

  error InvalidPrivileges do
    e = env["sinatra.error"]
    logger.warn e.message
    halt_response(e.message, 401)
  end

  error Excon::Errors::Unauthorized do
    e = env["sinatra.error"]
    resp = e.response
    ct = resp.headers["Content-Type"]
    msg = unless ct.nil?
      if ct.include?("application/json")
        json = ::Chef::JSONCompat.from_json(resp.body)
        m = "ERROR: Unauthorized (#{json['error']['code']}): #{json['error']['message']}"
        logger.error(m)
      else
      end
      m
    else
      "Unauthorized: #{e.inspect}"
    end
    halt_response(msg, 500)
  end

  error Fog::Compute::AWS::Error do
    e = env["sinatra.error"]
    logger.error e.message
    halt_response(e.message, 500)
  end

  error do
    e = env["sinatra.error"]
    logger.error e.message
    halt_response(e.message, 500)
  end

#  def self.mongo
#    DevopsService.mongo
#  end


#  use ::Version2_0::V2_0

  private

  def set_up_providers_keys!(providers, mongo)
    providers.each do |provider|
      next if provider.certificate_path.nil?
      begin
        mongo.key provider.ssh_key, Key::SYSTEM
      rescue RecordNotFound => e
        k = Key.new({"id" => provider.ssh_key, "path" => provider.certificate_path, "scope" => Key::SYSTEM})
        mongo.key_insert k
      end
    end
  end

end

require "wisper_fix"