defmodule Ton.Cell do
  @moduledoc """
  Cell data structure used in serialization and deserialization
  """
  import Bitwise

  defstruct [:refs, :data, :kind]

  alias Ton.Bitstring
  alias Ton.Boc.Header
  alias Ton.Cell.TopologicalOrder
  alias Ton.Utils

  @type cell_kind :: :pruned | :library_reference | :merkle_proof | :merkle_update | :ordinary

  @type t :: %__MODULE__{
          data: Bitstring.t(),
          kind: cell_kind()
        }

  @spec new(atom(), Bitstring.t() | nil) :: t()
  def new(kind \\ :ordinary, data \\ nil) do
    data = data || Bitstring.new(1023)

    %__MODULE__{
      data: data,
      kind: kind,
      refs: []
    }
  end

  @spec parse(binary(), non_neg_integer()) :: {t(), binary()} | no_return()
  def parse(binary_data, reference_index_size) do
    if byte_size(binary_data) < 2 do
      raise "Not enough bytes to encode cell descriptors"
    end

    <<d1::8, d2::8, cell_data::binary>> = binary_data

    is_exotic = (d1 &&& 8) != 0
    ref_num = rem(d1, 8)
    data_byte_size = Float.ceil(d2 / 2.0) |> trunc()
    fullfilled_bytes = rem(d2, 2) == 0

    if byte_size(cell_data) < data_byte_size + reference_index_size * ref_num do
      raise "Not enough bytes to encode cell data"
    end

    {kind, data_byte_size, cell_data} =
      if is_exotic do
        <<kind_byte::8, cell_data::binary>> = cell_data

        kind =
          case kind_byte do
            1 -> :pruned
            2 -> :library_reference
            3 -> :merkle_proof
            4 -> :merkle_update
            _ -> raise "Invalid cell type: #{kind_byte}"
          end

        {kind, data_byte_size - 1, cell_data}
      else
        {:ordinary, data_byte_size, cell_data}
      end

    <<data::binary-size(data_byte_size), cell_data::binary>> = cell_data

    bits = Bitstring.set_top_upped_array(data, fullfilled_bytes)

    {reversed_refs, residue} =
      if ref_num != 0 do
        Enum.reduce(1..ref_num, {[], cell_data}, fn _idx, {refs, current_cell_data} ->
          {ref, current_cell_data} =
            Utils.read_n_bytes_uint(current_cell_data, reference_index_size)

          {[ref | refs], current_cell_data}
        end)
      else
        {[], cell_data}
      end

    refs = Enum.reverse(reversed_refs)

    {%__MODULE__{refs: refs, data: bits, kind: kind}, residue}
  end

  @spec serialize(t(), Keyword.t()) :: binary()
  def serialize(root_cell, opts \\ []) do
    has_idx = Keyword.get(opts, :has_idx, true)
    hash_crc32 = Keyword.get(opts, :hash_crc32, true)
    has_cache_bits = Keyword.get(opts, :has_cache_bits, false)
    flags = Keyword.get(opts, :flags, 0)

    all_cells = TopologicalOrder.sort(root_cell)
    cells_num = Enum.count(all_cells)
    s = Integer.to_string(cells_num, 2) |> String.length()
    s_bytes = max(Float.ceil(s / 8.0) |> trunc(), 1)

    sizes =
      Enum.map(all_cells, fn cell ->
        calc_serialized_cell_size(cell.cell, s_bytes)
      end)

    {full_size, size_indexes_reversed} =
      Enum.reduce(sizes, {0, []}, fn size, {full_size_acc, size_indexes_acc} ->
        current_size = full_size_acc + size

        {current_size, [current_size | size_indexes_acc]}
      end)

    size_indexes = Enum.reverse(size_indexes_reversed)
    offset_bits = Integer.to_string(full_size, 2) |> String.length()
    offset_bytes = max(Float.ceil(offset_bits / 8.0) |> trunc(), 1)

    serialization = Header.reach_boc_magic_prefix()

    serialization =
      serialization <>
        <<if(has_idx, do: 1, else: 0) <<< 7 ||| if(hash_crc32, do: 1, else: 0) <<< 6 |||
            if(has_cache_bits, do: 1, else: 0) <<< 5 ||| flags <<< 3 ||| s_bytes>>

    serialization =
      (serialization <> <<offset_bytes>>)
      |> write_number(cells_num, s_bytes)
      |> write_number(1, s_bytes)
      |> write_number(0, s_bytes)
      |> write_number(full_size, offset_bytes)
      |> write_number(0, s_bytes)

    serialization =
      if has_idx do
        Enum.reduce(size_indexes, serialization, fn size_index, acc ->
          write_number(acc, size_index, offset_bytes)
        end)
      else
        serialization
      end

    serialization =
      Enum.reduce(all_cells, serialization, fn cell, acc ->
        serialize_for_boc(acc, cell.cell, cell.refs, s_bytes)
      end)

    if hash_crc32 do
      serialization <> EvilCrc32c.crc32c!(serialization)
    else
      serialization
    end
  end

  @spec hash(t()) :: binary()
  def hash(cell) do
    cell
    |> binary_repr()
    |> Utils.sha256()
  end

  @spec write_cell(t(), t()) :: t()
  def write_cell(cell, another_cell) do
    new_data = Bitstring.write_bistring(cell.data, another_cell.data)

    %{cell | refs: cell.refs ++ another_cell.refs, data: new_data}
  end

  defp calc_serialized_cell_size(cell, s) do
    2 +
      if(cell.kind == :ordinary, do: 0, else: 1) +
      Bitstring.get_top_upped_length(cell.data) +
      Enum.count(cell.refs) * s
  end

  defp serialize_for_boc(binary, cell, refs, s_size) do
    refs_descriptor = refs_descriptor(cell)
    bits_descriptor = bits_descriptor(cell)

    binary = binary <> refs_descriptor <> bits_descriptor

    binary =
      case cell.kind do
        :pruned -> binary <> <<1>>
        :library_reference -> binary <> <<2>>
        :merkle_proof -> binary <> <<3>>
        :merkle_update -> binary <> <<4>>
        :ordinary -> binary
      end

    binary = binary <> Bitstring.get_top_upped_array(cell.data)

    Enum.reduce(refs, binary, fn ref_index, acc ->
      write_number(acc, ref_index, s_size)
    end)
  end

  defp write_number(binary, number, bytes) do
    number_bin =
      Enum.reduce((bytes - 1)..0, <<>>, fn i, acc ->
        acc <> <<number >>> (i * 8) &&& 0xFF>>
      end)

    binary <> number_bin
  end

  defp binary_repr(cell) do
    data = data_with_descriptors(cell)

    data =
      Enum.reduce(cell.refs, data, fn ref_cell, acc ->
        max_depth_bin = max_depth_as_bin(ref_cell)
        acc <> max_depth_bin
      end)

    result =
      Enum.reduce(cell.refs, data, fn ref_cell, acc ->
        hash = hash(ref_cell)

        acc <> hash
      end)

    result
  end

  defp data_with_descriptors(cell) do
    d1 = refs_descriptor(cell)
    d2 = bits_descriptor(cell)

    tu_bits = Bitstring.get_top_upped_array(cell.data)

    d1 <> d2 <> tu_bits
  end

  defp refs_descriptor(cell) do
    # different for exotic cells
    <<Enum.count(cell.refs)>>
  end

  defp bits_descriptor(cell) do
    # different for exotic cells

    len = cell.data.cursor

    ceil = Float.ceil(len / 8.0) |> trunc()
    floor = Float.floor(len / 8.0) |> trunc()

    <<ceil + floor>>
  end

  defp max_depth_as_bin(cell) do
    max_depth = max_depth(cell)

    d1 = rem(max_depth, 256)
    d2 = Float.floor(max_depth / 256.0) |> trunc()

    <<d2, d1>>
  end

  defp max_depth(refs)

  defp max_depth(%__MODULE__{refs: []}), do: 0

  defp max_depth(%__MODULE__{refs: cells}) do
    result =
      Enum.reduce(cells, 0, fn ref_cell, acc ->
        current_cell_depth = max_depth(ref_cell)

        if current_cell_depth > acc do
          current_cell_depth
        else
          acc
        end
      end)

    result + 1
  end
end