defmodule Mongo.InsertOneResult do
  @moduledoc """
  The successful result struct of `Mongo.insert_one/4`. Its fields are:

    * `:inserted_id` - The id of the inserted document
  """

  @type t :: %__MODULE__{
    inserted_id: nil | BSON.ObjectId.t
  }

  defstruct [acknowledged: true, inserted_id: nil]
end

defmodule Mongo.InsertManyResult do
  @moduledoc """
  The successful result struct of `Mongo.insert_many/4`. Its fields are:

    * `:inserted_ids` - The ids of the inserted documents indexed by their order
  """

  @type t :: %__MODULE__{
    inserted_ids: %{non_neg_integer => BSON.ObjectId.t}
  }

  defstruct [acknowledged: true, inserted_ids: nil]
end

defmodule Mongo.DeleteResult do
  @moduledoc """
  The successful result struct of `Mongo.delete_one/4` and `Mongo.delete_many/4`.
  Its fields are:

    * `:deleted_count` - Number of deleted documents
    * `:acknowledged` - Write-concern
  """

  @type t :: %__MODULE__{
    acknowledged: boolean,
    deleted_count: non_neg_integer
  }

  defstruct [acknowledged: true, deleted_count: 0]
end

defmodule Mongo.UpdateResult do
  @moduledoc """
  The successful result struct of `Mongo.update_one/5`, `Mongo.update_many/5`
  and `Mongo.replace_one/5`. Its fields are:

    * `:matched_count` - Number of matched documents
    * `:modified_count` - Number of modified documents
    * `:upserted_ids` - If the operation was an upsert, the upserted ids
  """

  @type t :: %__MODULE__{
    acknowledged: boolean,
    matched_count: non_neg_integer,
    modified_count: non_neg_integer,
    upserted_ids: list(BSON.ObjectId.t)
  }

  defstruct [acknowledged: true, matched_count: 0, modified_count: 0, upserted_ids: []]
end

defmodule Mongo.BulkWriteResult do

  @moduledoc """
  The successful result struct of `Mongo.BulkWrite.write`. Its fields are:

    * `:acknowledged` - Write-concern
    * `:matched_count` - Number of matched documents
    * `:modified_count` - Number of modified documents
    * `:inserted_count` - Number of inserted documents
    * `:deleted_count` - Number of deleted documents
    * `:upserted_count` - Number of upserted documents
    * `:upserted_ids` - If the operation was an upsert, the upserted ids
    * `:inserted_ids` - If the operation was an insert, the inserted ids
    * `:errors` - If the operation results in an error, the error is collected

  """

  @type t :: %__MODULE__{
               acknowledged: boolean,
               matched_count: non_neg_integer,
               modified_count: non_neg_integer,
               inserted_count: non_neg_integer,
               deleted_count: non_neg_integer,
               upserted_count: non_neg_integer,
               upserted_ids: list(BSON.ObjectId.t),
               inserted_ids: list(BSON.ObjectId.t),
               errors: list(Map.t)
             }

   alias Mongo.BulkWriteResult

  defstruct [acknowledged: true, matched_count: 0, modified_count: 0, inserted_count: 0, deleted_count: 0, upserted_count: 0, inserted_ids: [], upserted_ids: [], errors: []]

  def insert_result(count, ids, errors) do
    %BulkWriteResult{inserted_count: count, inserted_ids: ids, errors: errors}
  end

  def update_result(matched_count, modified_count, upserted_count, ids, errors) do
    %BulkWriteResult{matched_count: matched_count, modified_count: modified_count, upserted_count: upserted_count, upserted_ids: ids, errors: errors}
  end

  def delete_result(count, errors) do
    %BulkWriteResult{deleted_count: count, errors: errors}
  end

  def error(error) do
    %BulkWriteResult{errors: [error]}
  end

  def empty() do
    %BulkWriteResult{}
  end

  def add(%BulkWriteResult{} = src, %BulkWriteResult{} = dest) do
    %BulkWriteResult{acknowledged: src.acknowledged,
      matched_count: src.matched_count + dest.matched_count,
      modified_count: src.modified_count + dest.modified_count,
      inserted_count: src.inserted_count + dest.inserted_count,
      deleted_count: src.deleted_count + dest.deleted_count,
      upserted_count: src.upserted_count + dest.upserted_count,
      inserted_ids: src.inserted_ids ++ dest.inserted_ids,
      upserted_ids: src.upserted_ids ++ dest.upserted_ids,
      errors: src.errors ++ dest.errors
    }
  end

  def reduce(results, acc) do
    Enum.reduce(results, acc, fn x, acc -> BulkWriteResult.add(acc, x) end)
  end

  def reduce(results) do
    reduce(results, %BulkWriteResult{})
  end

end