defmodule HPack do
  @moduledoc """
    Implementation of the [HPack](https://http2.github.io/http2-spec/compression.html) protocol, a compression format for efficiently representing HTTP header fields, to be used in HTTP/2.
  """

  use Bitwise
  alias HPack.Huffman
  alias HPack.Table

  @type header :: {String.t(), String.t()}
  @type header_block_fragment :: binary

  @doc """
  Encodes a list of headers into a `header block fragment` as specified in RFC 7541.

  Returns the `header block fragment`.

  ### Examples

      iex> {:ok, ctx} = HPack.Table.start_link(1000)
      iex> HPack.encode([{":method", "GET"}], ctx)
      << 0b10000010 >>

  """
  @spec encode([header], Table.t()) :: header_block_fragment
  def encode(headers, table) when is_list(headers), do: encode(headers, <<>>, table)

  defp encode([], hbf, _), do: hbf

  defp encode([{key, value} | headers], hbf, table) do
    partial =
      case Table.find(key, value, table) do
        {:fullindex, index} -> encode_indexed(index)
        {:keyindex, index} -> encode_literal_indexed(index, value, table)
        {:none} -> encode_literal_not_indexed(key, value, table)
      end

    encode(headers, hbf <> partial, table)
  end

  defp encode_indexed(index), do: <<1::1, encode_int7(index)::bitstring>>

  defp encode_literal_indexed(index, value, table) do
    {name, _} = Table.lookup(index, table)
    Table.add({name, value}, table)
    <<0::1, 1::1, encode_int6(index)::bitstring, encode_string(value)::binary>>
  end

  defp encode_literal_not_indexed(name, value, table) do
    Table.add({name, value}, table)
    <<0::1, 1::1, 0::6, encode_string(name)::binary, encode_string(value)::binary>>
  end

  # defp encode_literal_never_indexed(key, value)

  defp encode_string(string) do
    huffman = Huffman.encode(string)
    length = byte_size(huffman)
    <<1::1, encode_int7(length)::bitstring, huffman::binary>>
  end

  defp encode_int6(i) when i < 0b111111, do: <<i::6>>
  defp encode_int6(i), do: <<0b111111::6, encode_big_int(i - 0b111111)::bitstring>>

  defp encode_int7(i) when i < 0b1111111, do: <<i::7>>
  defp encode_int7(i), do: <<0b1111111::7, encode_big_int(i - 0b1111111)::bitstring>>

  defp encode_big_int(i) when i < 0b10000000, do: <<0::1, i::7>>
  defp encode_big_int(i), do: <<1::1, i::7, encode_big_int(i >>> 7)::binary>>

  @doc """
  Decodes a `header block fragment` as specified in RFC 7541.

  Returns the decoded headers as a List.

  ### Examples

      iex> {:ok, ctx} = HPack.Table.start_link(1000)
      iex> HPack.decode(<< 0x82 >>, ctx)
      [{":method", "GET"}]

  """
  @spec decode(header_block_fragment, Table.t()) :: [header]
  def decode(hbf, table) do
    parse(hbf, [], table)
  end

  defp parse(<<>>, headers, _), do: Enum.reverse(headers)

  #   0   1   2   3   4   5   6   7
  # +---+---+---+---+---+---+---+---+
  # | 1 |        Index (7+)         |
  # +---+---------------------------+
  #  Figure 5: Indexed Header Field
  defp parse(<<1::1, rest::bitstring>>, headers, table) do
    {index, rest} = parse_int7(rest)
    parse(rest, [Table.lookup(index, table) | headers], table)
  end

  #   0   1   2   3   4   5   6   7
  # +---+---+---+---+---+---+---+---+
  # | 0 | 1 |           0           |
  # +---+---+-----------------------+
  # | H |     Name Length (7+)      |
  # +---+---------------------------+
  # |  Name String (Length octets)  |
  # +---+---------------------------+
  # | H |     Value Length (7+)     |
  # +---+---------------------------+
  # | Value String (Length octets)  |
  # +-------------------------------+
  # Figure 7: Literal Header Field with Incremental Indexing — New Name
  defp parse(<<0::1, 1::1, 0::6, rest::binary>>, headers, table) do
    {name, rest} = parse_string(rest)
    {value, more_headers} = parse_string(rest)
    Table.add({name, value}, table)
    parse(more_headers, [{name, value} | headers], table)
  end

  #  0   1   2   3   4   5   6   7
  # +---+---+---+---+---+---+---+---+
  # | 0 | 1 |      Index (6+)       |
  # +---+---+-----------------------+
  # | H |     Value Length (7+)     |
  # +---+---------------------------+
  # | Value String (Length octets)  |
  # +-------------------------------+
  # Figure 6: Literal Header Field with Incremental Indexing — Indexed Name
  defp parse(<<0::1, 1::1, rest::bitstring>>, headers, table) do
    {index, rest} = parse_int6(rest)
    {value, more_headers} = parse_string(rest)
    {header, _} = Table.lookup(index, table)
    Table.add({header, value}, table)
    parse(more_headers, [{header, value} | headers], table)
  end

  #   0   1   2   3   4   5   6   7
  # +---+---+---+---+---+---+---+---+
  # | 0 | 0 | 0 | 0 |       0       |
  # +---+---+-----------------------+
  # | H |     Name Length (7+)      |
  # +---+---------------------------+
  # |  Name String (Length octets)  |
  # +---+---------------------------+
  # | H |     Value Length (7+)     |
  # +---+---------------------------+
  # | Value String (Length octets)  |
  # +-------------------------------+
  # Figure 9: Literal Header Field without Indexing — New Name
  defp parse(<<0::4, 0::4, rest::binary>>, headers, table) do
    {name, rest} = parse_string(rest)
    {value, more_headers} = parse_string(rest)
    parse(more_headers, [{name, value} | headers], table)
  end

  #   0   1   2   3   4   5   6   7
  # +---+---+---+---+---+---+---+---+
  # | 0 | 0 | 0 | 0 |  Index (4+)   |
  # +---+---+-----------------------+
  # | H |     Value Length (7+)     |
  # +---+---------------------------+
  # | Value String (Length octets)  |
  # +-------------------------------+
  # Figure 8: Literal Header Field without Indexing — Indexed Name
  defp parse(<<0::4, rest::bitstring>>, headers, table) do
    {index, rest} = parse_int4(rest)
    {value, more_headers} = parse_string(rest)
    {header, _} = Table.lookup(index, table)
    parse(more_headers, [{header, value} | headers], table)
  end

  #   0   1   2   3   4   5   6   7
  # +---+---+---+---+---+---+---+---+
  # | 0 | 0 | 0 | 1 |       0       |
  # +---+---+-----------------------+
  # | H |     Name Length (7+)      |
  # +---+---------------------------+
  # |  Name String (Length octets)  |
  # +---+---------------------------+
  # | H |     Value Length (7+)     |
  # +---+---------------------------+
  # | Value String (Length octets)  |
  # +-------------------------------+
  # Figure 11: Literal Header Field Never Indexed — New Name
  defp parse(<<0::3, 1::1, 0::4, rest::binary>>, headers, table) do
    {name, rest} = parse_string(rest)
    {value, more_headers} = parse_string(rest)
    parse(more_headers, [{name, value} | headers], table)
  end

  #   0   1   2   3   4   5   6   7
  # +---+---+---+---+---+---+---+---+
  # | 0 | 0 | 0 | 1 |  Index (4+)   |
  # +---+---+-----------------------+
  # | H |     Value Length (7+)     |
  # +---+---------------------------+
  # | Value String (Length octets)  |
  # +-------------------------------+
  # Figure 10: Literal Header Field Never Indexed — Indexed Name
  defp parse(<<0::3, 1::1, rest::bitstring>>, headers, table) do
    {index, rest} = parse_int4(rest)
    {value, more_headers} = parse_string(rest)
    {header, _} = Table.lookup(index, table)
    parse(more_headers, [{header, value} | headers], table)
  end

  #   0   1   2   3   4   5   6   7
  # +---+---+---+---+---+---+---+---+
  # | 0 | 0 | 1 |   Max size (5+)   |
  # +---+---------------------------+
  # Figure 12: Maximum Dynamic Table Size Change
  defp parse(<<0::2, 1::1, rest::bitstring>>, headers, table) do
    {size, rest} = parse_int5(rest)
    Table.resize(size, table)
    parse(rest, headers, table)
  end

  defp parse_string(<<0::1, rest::bitstring>>) do
    {length, rest} = parse_int7(rest)
    <<value::binary-size(length), rest::binary>> = rest
    {value, rest}
  end

  defp parse_string(<<1::1, rest::bitstring>>) do
    {length, rest} = parse_int7(rest)
    <<value::binary-size(length), rest::binary>> = rest
    {Huffman.decode(value), rest}
  end

  defp parse_int4(<<0b1111::4, rest::binary>>), do: parse_big_int(rest, 15, 0)
  defp parse_int4(<<int::4, rest::binary>>), do: {int, rest}

  defp parse_int5(<<0b11111::5, rest::binary>>), do: parse_big_int(rest, 31, 0)
  defp parse_int5(<<int::5, rest::binary>>), do: {int, rest}

  defp parse_int6(<<0b111111::6, rest::binary>>), do: parse_big_int(rest, 63, 0)
  defp parse_int6(<<int::6, rest::binary>>), do: {int, rest}

  defp parse_int7(<<0b1111111::7, rest::binary>>), do: parse_big_int(rest, 127, 0)
  defp parse_int7(<<int::7, rest::binary>>), do: {int, rest}

  defp parse_big_int(<<0::1, value::7, rest::binary>>, int, m), do: {int + (value <<< m), rest}

  defp parse_big_int(<<1::1, value::7, rest::binary>>, int, m),
    do: parse_big_int(rest, int + (value <<< m), m + 7)
end