class Restforce::Client

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

def authenticate!
  raise 'No authentication middleware present' unless authentication_middleware
  middleware = authentication_middleware.new nil, self, @options
  middleware.authenticate!
end

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

def cache
  @options[:cache]
end

def connection
  @connection ||= Faraday.new(@options[:instance_url]) 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.response :json
    builder.use      Restforce::Middleware::Caching, cache, @options if cache
    builder.use      FaradayMiddleware::FollowRedirects
    builder.use      Restforce::Middleware::RaiseError
    builder.use      Restforce::Middleware::Logger, Restforce.configuration.logger, @options if Restforce.log?
    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 decode_signed_request(message)
  raise 'client_secret not set' unless @options[:client_secret]
  encryped_secret, payload = message.split('.')
  digest = OpenSSL::Digest::Digest.new('sha256')
  signature = Base64.encode64(OpenSSL::HMAC.hexdigest(digest, @options[:client_secret], payload))
  JSON.parse(Base64.decode64(payload)) if encryped_secret == signature
end

def describe(sobject=nil)
  if sobject
    response = api_get "sobjects/#{sobject.to_s}/describe"
    response.body
  else
    response = api_get 'sobjects'
    response.body['sobjects']
  end
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
  raise 'Instance URL missing. Call .authenticate! first.' unless @options[:instance_url]
  @faye ||= Faye::Client.new("#{@options[:instance_url]}/cometd/#{@options[:api_version]}").tap do |client|
    raise 'OAuth token missing. Call .authenticate! first.' unless @options[:oauth_token]
    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, :cache, :authentication_retries].each do |option|
      options[option] = Restforce.configuration.send option
    end
  end
  @options.merge!(options)
end

def list_sobjects
  describe.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')
  raise 'Id field missing.' unless 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

def without_caching(&block)
  @options[:perform_caching] = false
  block.call
ensure
  @options.delete(:perform_caching)
end