class RSolr::Client

def adapt_response request, response
  raise "The response does not have the correct keys => :body, :headers, :status" unless
    %W(body headers status) == response.keys.map{|k|k.to_s}.sort
  raise RSolr::Error::Http.new request, response unless
    [200,302].include? response[:status]
  result = request[:params][:wt] == :ruby ? evaluate_ruby_response(request, response) : response[:body]
  result.extend Context
  result.request = request
  result.response = response
  result
end

def add doc, opts = {}
  add_attributes = opts.delete :add_attributes
  update opts.merge(:data => xml.add(doc, add_attributes))
end

def base_request_uri
  base_uri.request_uri
end

def base_uri
  @proxy || @uri
end

def build_request path, opts
  raise "path must be a string or symbol, not #{path.inspect}" unless [String,Symbol].include?(path.class)
  path = path.to_s
  opts[:proxy] = proxy unless proxy.nil?
  opts[:method] ||= :get
  raise "The :data option can only be used if :method => :post" if opts[:method] != :post and opts[:data]
  opts[:params] = opts[:params].nil? ? {:wt => :ruby} : {:wt => :ruby}.merge(opts[:params])
  query = RSolr::Uri.params_to_solr(opts[:params]) unless opts[:params].empty?
  opts[:query] = query
  if opts[:data].is_a? Hash
    opts[:data] = RSolr::Uri.params_to_solr opts[:data]
    opts[:headers] ||= {}
    opts[:headers]['Content-Type'] ||= 'application/x-www-form-urlencoded'
  end
  opts[:path] = path
  opts[:uri] = base_uri.merge(path.to_s + (query ? "?#{query}" : "")) if base_uri
  opts
end

def commit opts = {}
  commit_attrs = opts.delete :commit_attributes
  update opts.merge(:data => xml.commit( commit_attrs ))
end

def delete_by_id id, opts = {}
  update opts.merge(:data => xml.delete_by_id(id))
end

def delete_by_query query, opts = {}
  update opts.merge(:data => xml.delete_by_query(query))
end

def evaluate_ruby_response request, response
  begin
    Kernel.eval response[:body].to_s
  rescue SyntaxError
    raise RSolr::Error::InvalidRubyResponse.new request, response
  end
end

def execute request_context
  raw_response = connection.execute self, request_context
  adapt_response(request_context, raw_response) unless raw_response.nil?
end

def initialize connection, options = {}
  @connection = connection
  url = options[:url] || 'http://127.0.0.1:8983/solr/'
  url << "/" unless url[-1] == ?/
  proxy_url = options[:proxy]
  proxy_url << "/" unless proxy_url.nil? or proxy_url[-1] == ?/
  @uri = RSolr::Uri.create url
  @proxy = RSolr::Uri.create proxy_url if proxy_url
  @options = options
  extend RSolr::Pagination::Client
end

def method_missing name, *args
  send_and_receive name, *args
end

def optimize opts = {}
  optimize_attributes = opts.delete :optimize_attributes
  update opts.merge(:data => xml.optimize(optimize_attributes))
end

def rollback opts = {}
  update opts.merge(:data => xml.rollback)
end

def send_and_receive path, opts
  request_context = build_request path, opts
  execute request_context
end

def update opts = {}
  opts[:headers] ||= {}
  opts[:headers]['Content-Type'] ||= 'text/xml'
  post 'update', opts
end

def xml
  @xml ||= RSolr::Xml::Generator.new
end