defmodule Hobbes.Structs do
  @moduledoc """
  This module contains data structures which are shared across
  multiple types of Server.
  """

  alias Hobbes.Utils

  defmodule Cluster do
    # Hide :servers from inspect output because they are spammy and unhelpful
    @derive {Inspect, except: [:servers]}
    @type t :: %__MODULE__{
      coordinators: [term],
      generation: non_neg_integer,
      tlog_generations: [TLogGeneration.t],
      status: :recovering | :normal,
      manager_pid: pid,
      servers: %{non_neg_integer => Hobbes.Structs.Server.t},
    }
    @enforce_keys [
      :coordinators,
      :generation,
      :tlog_generations,
      :status,
      :manager_pid,
      :servers,
    ]
    defstruct @enforce_keys
  end

  defmodule TLogGeneration do
    @type t :: %__MODULE__{
      generation: non_neg_integer,
      start_version: non_neg_integer,
      end_version: non_neg_integer | nil,
      replication_factor: 1 | 2 | 3,
      tlog_ids: [non_neg_integer],
    }
    @enforce_keys [:generation, :start_version, :replication_factor, :tlog_ids]
    defstruct @enforce_keys ++ [:end_version]
  end

  defmodule Server do
    @type t :: %__MODULE__{
      type: module,
      id: integer,
      pid: pid,
    }
    @enforce_keys [:type, :id, :pid]
    defstruct @enforce_keys
  end

  defmodule SupervisorStatus do
    @type t :: %__MODULE__{
      node: atom,
      pid: pid,
      generation_failed?: boolean,
      slots: map | nil,
    }
    @enforce_keys [
      :node,
      :pid,
      :generation_failed?,
      :slots,
    ]
    defstruct @enforce_keys
  end

  defmodule TLogStatus do
    @type t :: %__MODULE__{
      id: non_neg_integer,
      pid: pid,
      locked?: boolean,
      known_committed_version: non_neg_integer,
      durable_version: non_neg_integer,
    }
    @enforce_keys [
      :id,
      :pid,
      :locked?,
      :known_committed_version,
      :durable_version,
    ]
    defstruct @enforce_keys
  end

  defmodule CommitTxn do
    @type t :: %__MODULE__{
      read_version: non_neg_integer,
      read_conflicts: [binary | {binary, binary}],
      write_conflicts: [binary | {binary, binary}],
      mutations: [Utils.mutation],
      from: term,
      batch_index: non_neg_integer | nil,
    }
    @enforce_keys [:read_version, :read_conflicts, :write_conflicts, :mutations]
    defstruct @enforce_keys ++ [:from, :batch_index]
  end

  defmodule ResolveBatch do
    @type t :: %__MODULE__{
      commit_buffer_id: integer,
      commit_version: non_neg_integer,
      prev_commit_version: non_neg_integer,
      transactions: [
        # {read_version, read_conflicts, write_conflicts, meta_mutations}
        {
          non_neg_integer,
          [binary | {binary, binary}],
          [binary | {binary, binary}],
          [Utils.mutation],
        }
      ]
    }
    @enforce_keys [:commit_buffer_id, :commit_version, :prev_commit_version, :transactions]
    defstruct @enforce_keys
  end

  defmodule LogBatch do
    @type t :: %__MODULE__{
      commit_buffer_id: integer,
      commit_version: non_neg_integer,
      prev_commit_version: non_neg_integer,
      tagged_mutations: [{Utils.tag_list, Utils.numbered_mutation}],
      last_committed_version: non_neg_integer,
    }
    @enforce_keys [:commit_buffer_id, :commit_version, :prev_commit_version, :tagged_mutations, :last_committed_version]
    defstruct @enforce_keys
  end

  defmodule PeekResult do
    @type t :: %__MODULE__{
      tlog_id: non_neg_integer,
      nonce: reference,
      known_committed_version: non_neg_integer,
      start_version: non_neg_integer,
      end_version: non_neg_integer,
      batches: list,
    }
    @enforce_keys [:tlog_id, :nonce, :known_committed_version, :start_version, :end_version, :batches]
    defstruct @enforce_keys
  end

  defmodule RangeResult do
    @type t :: %__MODULE__{
      pairs: [{binary, binary | :deleted | nil}],
      count: non_neg_integer,
      range: {binary, binary} | nil,
      more: boolean,
    }
    @enforce_keys [:pairs, :more]
    defstruct [:pairs, :count, :range, :more]
  end

  defmodule StorageStats do
    @type t :: %__MODULE__{
      server_id: non_neg_integer,
      used_bytes: non_neg_integer,
      free_bytes: non_neg_integer,
    }
    @enforce_keys [:server_id, :used_bytes, :free_bytes]
    defstruct @enforce_keys
  end

  defmodule ShardStats do
    @type t :: %__MODULE__{
      start_key: binary,
      end_key: binary,
      size_bytes: non_neg_integer,
      midpoint_key: binary,
    }
    @enforce_keys [:start_key, :end_key, :size_bytes, :midpoint_key]
    defstruct @enforce_keys
  end
end