defmodule Bio.Enum do
  @moduledoc """
  Implements a wrapper around the `Enum` module's public interface.

  The semantics of the `Enum` module don't always match up with what I would think
  is best for certain cases. The best example of this is the `slide/3` function.
  Because of the `Enum` implementation, there is no way to coerce the return
  value back into a struct. So for example, given a `Bio.Sequence.DnaStrand` it
  would return a list of graphemes. This is not what I want users to expect.

  That said, there are other functions that _do_ behave well. Or at the very
  least, their semantics seem meaningfully useful. So in order to preserve the
  maximum utility, I wrap the module.

  The expectation should be as follows:
  `Enum` functions will return bare data.
  `Bio.Enum` functions will return the closest thing to the struct as is
  reasonable.

  There are cases where it doesn't make much sense to return more than is
  required. For example, the `Bio.Enum.at/2` function will return a binary
  grapheme. I have a hard time imagining a case where the user would want a
  struct with a sequence of a single character instead of the character itself.

  Contrast that with the `Enum.at/2` function, which will return a raw char.
  """
  @type acc() :: any()
  @type default() :: any()
  @type element() :: any()
  @type index() :: integer()
  @type t() :: Enumerable.t()

  # def all?(enumerable), do: Enum.all?(enumerable)
  # def all?(enumerable, func), do: Enum.all?(enumerable, func)

  # @spec any?(t()) :: boolean()
  # def any?(enumerable), do: Enum.any?(enumerable)

  # TODO: add a check for `func` in `any?/2` is_binary to allow
  # `any?(seq, "char")` as a valid approach.
  # @spec any?(t(), (element() -> as_boolean(term()))) :: boolean()
  # def any?(enumerable, func), do: Enum.any?(enumerable, func)

  def at(enumerable, index) when is_integer(index) do
    Enum.at(enumerable, index)
    |> then(&[&1])
    |> List.to_string()
  end

  def at(enumerable, index, default) when is_integer(index) do
    Enum.at(enumerable, index, default)
    |> then(&[&1])
    |> List.to_string()
  end

  # def chunk_by(enumerable, func) do
  #   Enum.chunk_by(enumerable, func)
  #   |> Enum.map(&Enum.join/1)
  #   |> Enum.map(&apply(enumerable.__struct__, :new, [&1, [label: enumerable.label]]))
  # end

  def chunk_every(enumerable, count),
    do:
      Enum.chunk_every(enumerable, count)
      |> Enum.map(&Enum.join/1)
      |> Enum.map(&new(&1, enumerable))

  def chunk_every(enumerable, count, step),
    do:
      Enum.chunk_every(enumerable, count, step)
      |> Enum.map(&Enum.join/1)
      |> Enum.map(&new(&1, enumerable))

  def chunk_every(enumerable, count, step, options),
    do:
      Enum.chunk_every(enumerable, count, step, options)
      |> Enum.map(&Enum.join/1)
      |> Enum.map(&new(&1, enumerable))

  def chunk_while(enumerable, acc, chunk_fun, after_fun),
    do:
      Enum.chunk_while(enumerable, acc, chunk_fun, after_fun)
      |> Enum.map(&Enum.join/1)
      |> Enum.map(&new(&1, enumerable))

  # TODO: figure out the semantics for concatenation with non-sequence
  # enumerables
  # def concat(a), do: {a}
  # def concat(a, b), do: {a, b}

  # def count(enumerable), do: Enum.count(enumerable)
  # def count(enumerable, fun), do: Enum.count(enumerable, fun)

  # def count_until(a), do: {a}
  # def count_until(a, b), do: {a, b}

  # def dedup(), do: {}

  # def dedup_by(), do: {}

  # def drop(), do: {}
  #
  # def drop_every(), do: {}
  #
  # def drop_while(), do: {}
  #
  # def each(), do: {}
  #
  # def empty?(), do: {}
  #
  # def fetch!(), do: {}
  #
  # def fetch(), do: {}
  #
  # def filter(), do: {}
  #
  # def find(a), do: {a}
  # def find(a, b), do: {a, b}
  #
  # def find_index(), do: {}
  #
  # def find_value(a), do: {a}
  # def find_value(a, b), do: {a, b}
  #
  # def flat_map(), do: {}
  #
  # def flat_map_reduce(), do: {}
  #
  # def frequencies(), do: {}
  #
  # def frequencies_by(), do: {}
  #
  # def group_by(a), do: {a}
  # def group_by(a, b), do: {a, b}
  #
  # def intersperse(), do: {}
  #
  # def into(a), do: {a}
  # def into(a, b), do: {a, b}
  #
  # def join(a), do: {a}
  # def join(a, b), do: {a, b}

  def map(enumerable, func),
    do:
      Enum.map(enumerable, func)
      |> Enum.join()
      |> new(enumerable)

  # def map_every(), do: {}
  #
  # def map_intersperse(), do: {}
  #
  # def map_join(a), do: {a}
  # def map_join(a, b), do: {a, b}
  #
  # def map_reduce(), do: {}
  #
  # def max(), do: {}
  #
  # def max_by(a), do: {a}
  # def max_by(a, b), do: {a, b}
  #
  # def member?(), do: {}
  #
  # def min(), do: {}
  #
  # def min_by(a), do: {a}
  # def min_by(a, b), do: {a, b}
  #
  # def min_max(a), do: {a}
  # def min_max(a, b), do: {a, b}
  #
  # def min_max_by(a), do: {a}
  # def min_max_by(a, b), do: {a, b}
  #
  # def product(), do: {}
  #
  # def random(), do: {}
  #
  # def reduce(a), do: {a}
  # def reduce(a, b), do: {a, b}
  #
  # def reduce_while(), do: {}
  #
  # def reject(), do: {}

  def reverse(enumerable),
    do:
      Enum.reverse(enumerable)
      |> Enum.join()
      |> new(enumerable)

  # TODO: what type is tail?
  def reverse(enumerable, tail),
    do:
      Enum.reverse(enumerable, tail)
      |> Enum.join()
      |> new(enumerable)

  # def reverse_slice(), do: {}
  #
  # def scan(a), do: {a}
  # def scan(a, b), do: {a, b}
  #
  # def shuffle(), do: {}

  def slice(enumerable, index_range),
    do:
      Enum.slice(enumerable, index_range)
      |> List.to_string()
      |> new(enumerable)

  def slice(enumerable, start_index, amount),
    do:
      Enum.slice(enumerable, start_index, amount)
      |> List.to_string()
      |> new(enumerable)

  # def slide(), do: {}
  #
  # def sort(a), do: {a}
  # def sort(a, b), do: {a, b}
  #
  # def sort_by(a), do: {a}
  # def sort_by(a, b), do: {a, b}
  #
  # def split(), do: {}
  #
  # def split_while(), do: {}
  #
  # def split_with(), do: {}
  #
  # def sum(), do: {}
  #
  # def take(), do: {}
  #
  # def take_every(), do: {}
  #
  # def take_random(), do: {}
  #
  # def take_while(), do: {}
  #
  # def to_list(), do: {}
  #
  # def uniq(), do: {}
  #
  # def uniq_by(), do: {}
  #
  # def unzip(), do: {}

  # def zip(a), do: {a}
  # def zip(a, b), do: {a, b}
  #
  # def zip_reduce(a), do: {a}
  # def zip_reduce(a, b), do: {a, b}
  #
  # def zip_with(a), do: {a}
  # def zip_with(a, b), do: {a, b}
  defp new(seq, enumerable) do
    data =
      enumerable
      |> Map.from_struct()
      |> Map.drop([:sequence, :length])
      |> Map.to_list()

    apply(enumerable.__struct__, :new, [seq, data])
  end
end