defstruct [:parsers, :acc]

  defstruct parsers: []

  def parse(enum) do
    Stream.transform(
      enum,
      %__MODULE__{
        parsers: [
          magic: bytes(<<0x00, 0x61, 0x73, 0x6D>>)
        ],
        acc: <<>>
      },
      fn
        _, :stop ->
          {:halt, :stop}

  def new() do
    %__MODULE__{
      parsers: [
        magic: bytes(<<0x00, 0x61, 0x73, 0x6D>>)
      ]
    }
  end
  def parse_one(<<>>, state) do
    {nil, state, <<>>}
  end

        chunk, state ->
          chunk = state.acc <> chunk

  def parse_one(chunk, state = %__MODULE__{parsers: []}) do
    {{:error, :no_parsers}, state, chunk}
  end

          case state do
            %__MODULE__{parsers: []} ->
              {[{:error, {:no_parsers, chunk}}], :stop}

  def parse_one(chunk, state = %__MODULE__{parsers: [{tag, parser} | rest_parsers]}) do
    case parser.(chunk) do
      :not_matched ->
        {{:error, {:not_matched, chunk, tag}}, state, chunk}

            %__MODULE__{parsers: [{tag, parser} | rest]} ->
              case parser.(chunk) do
                :need_more ->
                  {[], %{state | acc: chunk}}

      :need_more ->
        {{:error, :need_more}, state, chunk}

                {:matched, data, <<>>} ->
                  {[{tag, data}], %{state | acc: <<>>, parsers: rest}}

      {:matched, data, tail} ->
        new_state = %{state | parsers: rest_parsers}
        {{tag, data}, new_state, tail}
    end
  end

                {:matched, data, tail} ->
                  res =
                    Enum.reduce_while(
                      rest,
                      {[], tail, rest},
                      fn parser, acc = {_res, chunk, _rest_parsers} ->
                        case parser.(chunk) do
                          :need_more -> {:halt, acc}
                        end
                      end
                    )

  def parse_all(chunk, state) do
    parse_all(chunk, state, [])
  end

                  case res do
                    {res, <<>>, rest_parsers} ->
                      {[{tag, data} | res], %{state | acc: <<>>, parsers: rest_parsers}}

  defp parse_all(<<>>, state, results) do
    {results |> Enum.reverse(), state, <<>>}
  end

                    {res, tail, []} ->
                      {[{tag, data} | res ++ [{:error, {:no_parsers, tail}}]], :stop}
                  end

  defp parse_all(chunk, state, results) do
    {result, state, tail} = parse_one(chunk, state)

                :not_matched ->
                  {[{:error, {:not_matched, chunk, tag}}], :stop}
              end
          end
      end
    )

    case result do
      {:error, _} -> {[result | results] |> Enum.reverse(), state, tail}
      _ -> parse_all(tail, state, [result | results])
    end