class Restforce::Client

def api_path(path)
  "/services/data/v#{@options[:api_version]}/#{path}"
end

def authenticate!
  connection.headers['X-ForceAuthenticate'] = true
  get nil
ensure
  connection.headers.delete('X-ForceAuthenticate')
end

def authentication_middleware
  if username_password?
    Restforce::Middleware::Authentication::Password
  elsif oauth_refresh?
    Restforce::Middleware::Authentication::Token
  end
end

def connection
  @connection ||= Faraday.new do |builder|
    builder.use Restforce::Middleware::Mashify, self, @options
    builder.use Restforce::Middleware::Multipart
    builder.request :json
    builder.use authentication_middleware, self, @options if authentication_middleware
    builder.use Restforce::Middleware::Authorization, self, @options
    builder.use Restforce::Middleware::InstanceURL, self, @options
    builder.use Restforce::Middleware::RaiseError
    builder.response :logger, Restforce.configuration.logger if Restforce.log?
    builder.response :json
    builder.adapter Faraday.default_adapter
  end
  @connection
end

def create(sobject, attrs)
  create!(sobject, attrs)
rescue *exceptions
  false
end

def create!(sobject, attrs)
  response = api_post "sobjects/#{sobject}", attrs
  response.body['id']
end

def describe(sobject)
  response = api_get "sobject/#{sobject.to_s}/describe"
  response.body
end

def describe_sobjects
  response = api_get 'sobjects'
  response.body['sobjects']
end

def destroy(sobject, id)
  destroy!(sobject, id)
rescue *exceptions
  false
end

def destroy!(sobject, id)
  api_delete "sobjects/#{sobject}/#{id}"
  true
end

def exceptions
  [Faraday::Error::ClientError]
end

def faye
  @faye ||= Faye::Client.new("#{@options[:instance_url]}/cometd/#{@options[:api_version]}").tap do |client|
    client.set_header 'Authorization', "OAuth #{@options[:oauth_token]}"
    client.bind 'transport:down' do
      Restforce.log "[COMETD DOWN]"
    end
    client.bind 'transport:up' do
      Restforce.log "[COMETD UP]"
    end
  end
end

def initialize(options = {})
  raise 'Please specify a hash of options' unless options.is_a?(Hash)
  @options = {}.tap do |options|
    [:username, :password, :security_token, :client_id, :client_secret, :host,
     :api_version, :oauth_token, :refresh_token, :instance_url].each do |option|
      options[option] = Restforce.configuration.send option
    end
  end
  @options.merge!(options)
end

def list_sobjects
  describe_sobjects.collect { |sobject| sobject['name'] }
end

def mashify?
  connection.builder.handlers.find { |handler| handler == Restforce::Middleware::Mashify }
end

def oauth_refresh?
  @options[:refresh_token] &&
    @options[:client_id] &&
    @options[:client_secret]
end

def org_id
  query('select id from Organization').first['Id']
end

def query(soql)
  response = api_get 'query', q: soql
  mashify? ? response.body : response.body['records']
end

def search(sosl)
  response = api_get 'search', q: sosl
  response.body
end

def subscribe(channel, &block)
  faye.subscribe "/topic/#{channel}", &block
end

def update(sobject, attrs)
  update!(sobject, attrs)
rescue *exceptions
  false
end

def update!(sobject, attrs)
  id = attrs.has_key?(:Id) ? attrs.delete(:Id) : attrs.delete('Id')
  api_patch "sobjects/#{sobject}/#{id}", attrs
  true
end

def upsert(sobject, field, attrs)
  upsert!(sobject, field, attrs)
rescue *exceptions
  false
end

def upsert!(sobject, field, attrs)
  external_id = attrs.has_key?(field.to_sym) ? attrs.delete(field.to_sym) : attrs.delete(field.to_s)
  response = api_patch "sobjects/#{sobject}/#{field.to_s}/#{external_id}", attrs
  (response.body && response.body['id']) ? response.body['id'] : true
end

def username_password?
  @options[:username] &&
    @options[:password] &&
    @options[:security_token] &&
    @options[:client_id] &&
    @options[:client_secret]
end