class Ferret::Index::Index

def add_document(doc, analyzer = nil)
  @dir.synchronize do
    ensure_writer_open()
    if doc.is_a?(String) or doc.is_a?(Array)
      doc = {@default_input_field => doc}
    end
    # delete existing documents with the same key
    if @key
      if @key.is_a?(Array)
        query = @key.inject(BooleanQuery.new()) do |bq, field|
          bq.add_query(TermQuery.new(field, doc[field].to_s), :must)
          bq
        end
        query_delete(query)
      else
        id = doc[@key].to_s
        if id
          @writer.delete(@key, id)
        end
      end
    end
    ensure_writer_open()
    if analyzer
      old_analyzer = @writer.analyzer
      @writer.analyzer = analyzer
      @writer.add_document(doc)
      @writer.analyzer = old_analyzer
    else
      @writer.add_document(doc)
    end
    flush() if @auto_flush
  end
end

def add_indexes(indexes)
  @dir.synchronize do
    ensure_writer_open()
    indexes = [indexes].flatten   # make sure we have an array
    return if indexes.size == 0 # nothing to do
    if indexes[0].is_a?(Index)
      indexes.delete(self) # don't merge with self
      indexes = indexes.map {|index| index.reader }
    elsif indexes[0].is_a?(Ferret::Store::Directory)
      indexes.delete(@dir) # don't merge with self
      indexes = indexes.map {|dir| IndexReader.new(dir) }
    elsif indexes[0].is_a?(IndexReader)
      indexes.delete(@reader) # don't merge with self
    else
      raise ArgumentError, "Unknown index type when trying to merge indexes"
    end
    ensure_writer_open
    @writer.add_readers(indexes)
  end
end

def batch_delete(docs)
  docs = docs.keys if docs.is_a?(Hash)
  raise ArgumentError, "must pass Array or Hash" unless docs.is_a? Array
  ids = []
  terms = []
  docs.each do |doc|
    case doc
    when String then  terms << doc
    when Symbol then  terms << doc.to_s
    when Integer then ids   << doc
    else
      raise ArgumentError, "Cannot delete for arg of type #{id.class}"
    end
  end
  if ids.size > 0
    ensure_reader_open
    ids.each {|id| @reader.delete(id)}
  end
  if terms.size > 0
    ensure_writer_open()
    @writer.delete(@id_field, terms)
  end
  return self
end

def batch_update(docs)
  @dir.synchronize do
    ids = values = nil
    case docs
    when Array
      ids = docs.collect{|doc| doc[@id_field].to_s}
      if ids.include?(nil)
        raise ArgumentError, "all documents must have an #{@id_field} " 
                             "field when doing a batch update"
      end
    when Hash
      ids = docs.keys
      docs = docs.values
    else
      raise ArgumentError, "must pass Hash or Array, not #{docs.class}"
    end
    batch_delete(ids)
    ensure_writer_open()
    docs.each {|new_doc| @writer << new_doc }
    flush()
  end
end

def close
  @dir.synchronize do
    if not @open
      raise(StandardError, "tried to close an already closed directory")
    end
    @searcher.close() if @searcher
    @reader.close() if @reader
    @writer.close() if @writer
    @dir.close() if @close_dir
    @open = false
  end
end

def close_all()
  @dir.synchronize do
    @searcher.close if @searcher
    @reader.close if @reader
    @writer.close if @writer
    @reader = nil
    @searcher = nil
    @writer = nil
  end
end

def delete(arg)
  @dir.synchronize do
    if arg.is_a?(String) or arg.is_a?(Symbol)
      ensure_writer_open()
      @writer.delete(@id_field, arg.to_s)
    elsif arg.is_a?(Integer)
      ensure_reader_open()
      cnt = @reader.delete(arg)
    elsif arg.is_a?(Hash) or arg.is_a?(Array)
      batch_delete(arg)
    else
      raise ArgumentError, "Cannot delete for arg of type #{arg.class}"
    end
    flush() if @auto_flush
  end
  return self
end

def deleted?(n)
  @dir.synchronize do 
    ensure_reader_open()
    return @reader.deleted?(n) 
  end
end

def do_process_query(query)
  if query.is_a?(String)
    if @qp.nil?
      @qp = Ferret::QueryParser.new(@options)
    end
    # we need to set this every time, in case a new field has been added
    @qp.fields =
        @reader.fields unless options[:all_fields] || options[:fields]
    @qp.tokenized_fields =
        @reader.tokenized_fields unless options[:tokenized_fields]
    query = @qp.parse(query)
  end
  return query
end

def do_search(query, options)
  ensure_searcher_open()
  query = do_process_query(query)
  return @searcher.search(query, options)
end

def doc(*arg)
  @dir.synchronize do
    id = arg[0]
    if id.kind_of?(String) or id.kind_of?(Symbol)
      ensure_reader_open()
      term_doc_enum = @reader.term_docs_for(@id_field, id.to_s)
      return term_doc_enum.next? ? @reader[term_doc_enum.doc] : nil
    else
      ensure_reader_open(false)
      return @reader[*arg]
    end
  end
end

def each
  @dir.synchronize do
    ensure_reader_open
    (0...@reader.max_doc).each do |i|
      yield @reader[i].load unless @reader.deleted?(i)
    end
  end
end

def ensure_reader_open(get_latest = true)
  raise "tried to use a closed index" if not @open
  if @reader
    if get_latest
      latest = false
      begin
        latest = @reader.latest?
      rescue Lock::LockError => le
        sleep(@options[:lock_retry_time]) # sleep for 2 seconds and try again
        latest = @reader.latest?
      end
      if not latest
        @searcher.close if @searcher
        @reader.close
        return @reader = IndexReader.new(@dir)
      end
    end
  else
    if @writer
      @writer.close
      @writer = nil
    end
    return @reader = IndexReader.new(@dir)
  end
  return false
end

def ensure_searcher_open()
  raise "tried to use a closed index" if not @open
  if ensure_reader_open() or not @searcher
    @searcher = Searcher.new(@reader)
  end
end

def ensure_writer_open()
  raise "tried to use a closed index" if not @open
  return if @writer
  if @reader
    @searcher.close if @searcher
    @reader.close
    @reader = nil
    @searcher = nil
  end
  @writer = IndexWriter.new(@options)
end

def explain(query, doc)
  @dir.synchronize do
    ensure_searcher_open()
    query = do_process_query(query)
    return @searcher.explain(query, doc)
  end
end

def field_infos
  @dir.synchronize do
    ensure_writer_open()
    return @writer.field_infos
  end
end

def flush()
  @dir.synchronize do
    if @reader
      if @searcher
        @searcher.close
        @searcher = nil
      end
      @reader.commit
    elsif @writer
      @writer.close
      @writer = nil
    end
  end
end

def has_deletions?()
  @dir.synchronize do
    ensure_reader_open()
    return @reader.has_deletions?
  end
end