defmodule OpcUA.Common do
  @moduledoc """
  This module covers common functions for Client & Server behavior.
  """

  alias OpcUA.QualifiedName
  alias OpcUA.{ExpandedNodeId, NodeId, QualifiedName}

  defmacro __using__(opts) do
    quote location: :keep, bind_quoted: [opts: opts] do
      use GenServer, opts

      require Logger

      @c_timeout 5000

      @mix_env Mix.env()

      defmodule State do
        @moduledoc false

        # port: C port process
        # controlling_process: parent process

        defstruct port: nil,
                  controlling_process: nil
      end

      # Write nodes Attributes functions

      @doc """
      Change the browse name of a node in the server.
      """
      @spec write_node_browse_name(GenServer.server(), %NodeId{}, %QualifiedName{}) ::
              :ok | {:error, binary()} | {:error, :einval}
      def write_node_browse_name(pid, %NodeId{} = node_id, browse_name) do
        GenServer.call(pid, {:write, {:browse_name, node_id, browse_name}})
      end

      @doc """
      Change the display name attribute of a node in the server.
      """
      @spec write_node_display_name(GenServer.server(), %NodeId{}, binary(), binary()) ::
              :ok | {:error, binary()} | {:error, :einval}
      def write_node_display_name(pid, %NodeId{} = node_id, locale, name) do
        GenServer.call(pid, {:write, {:display_name, node_id, {locale, name}}})
      end

      @doc """
      Change description attribute of a node in the server.
      """
      @spec write_node_description(GenServer.server(), %NodeId{}, binary(), binary()) ::
              :ok | {:error, binary()} | {:error, :einval}
      def write_node_description(pid, %NodeId{} = node_id, locale, description) do
        GenServer.call(pid, {:write, {:description, node_id, {locale, description}}})
      end

      # TODO: friendlier write_mask params
      @doc """
      Change 'Write Mask' attribute of a node in the server.
      """
      @spec write_node_write_mask(GenServer.server(), %NodeId{}, integer()) ::
              :ok | {:error, binary()} | {:error, :einval}
      def write_node_write_mask(pid, %NodeId{} = node_id, write_mask) do
        GenServer.call(pid, {:write, {:write_mask, node_id, write_mask}})
      end

      @doc """
      Change 'Is Abstract' attribute of a node in the server.
      """
      @spec write_node_is_abstract(GenServer.server(), %NodeId{}, boolean()) ::
              :ok | {:error, binary()} | {:error, :einval}
      def write_node_is_abstract(pid, %NodeId{} = node_id, is_abstract?) do
        GenServer.call(pid, {:write, {:is_abstract, node_id, is_abstract?}})
      end

      @doc """
      Change 'Inverse name' attribute of a node in the server.
      """
      @spec write_node_inverse_name(GenServer.server(), %NodeId{}, binary(), binary()) ::
              :ok | {:error, binary()} | {:error, :einval}
      def write_node_inverse_name(pid, %NodeId{} = node_id, locale, inverse_name) do
        GenServer.call(pid, {:write, {:inverse_name, node_id, {locale, inverse_name}}})
      end

      @doc """
      Change 'data_type' attribute of a node in the server.
      """
      @spec write_node_data_type(GenServer.server(), %NodeId{}, %NodeId{}) ::
              :ok | {:error, binary()} | {:error, :einval}
      def write_node_data_type(pid, %NodeId{} = node_id, %NodeId{} = data_type_node_id) do
        GenServer.call(pid, {:write, {:data_type, node_id, data_type_node_id}})
      end

      @doc """
      Change 'Value rank' of a node in the server.

      This attribute indicates whether the value attribute of the variable is an array and how many dimensions the array has.
      It may have the following values:

      value_rank >= 1: the value is an array with the specified number of dimensions
      value_rank =  0: the value is an array with one or more dimensions
      value_rank = -1: the value is a scalar
      value_rank = -2: the value can be a scalar or an array with any number of dimensions
      value_rank = -3: the value can be a scalar or a one dimensional array

      """
      @spec write_node_value_rank(GenServer.server(), %NodeId{}, integer()) ::
              :ok | {:error, binary()} | {:error, :einval}
      def write_node_value_rank(pid, %NodeId{} = node_id, value_rank)
          when value_rank >= -3 and is_integer(value_rank) do
        GenServer.call(pid, {:write, {:value_rank, node_id, value_rank}})
      end

      @doc """
      Change 'Array Dimensions' of a node in the server.
      """
      @spec write_node_array_dimensions(GenServer.server(), %NodeId{}, list()) ::
              :ok | {:error, binary()} | {:error, :einval}
      def write_node_array_dimensions(pid, %NodeId{} = node_id, array_dimensions)
          when is_list(array_dimensions) do
        GenServer.call(pid, {:write, {:array_dimensions, node_id, array_dimensions}})
      end

      @doc """
      Change 'Access level' of a node in the server.
      """
      @spec write_node_access_level(GenServer.server(), %NodeId{}, integer()) ::
              :ok | {:error, binary()} | {:error, :einval}
      def write_node_access_level(pid, %NodeId{} = node_id, access_level) do
        GenServer.call(pid, {:write, {:access_level, node_id, access_level}})
      end

      @doc """
      Change 'Minimum Sampling Interval level' of a node in the server.
      """
      @spec write_node_minimum_sampling_interval(GenServer.server(), %NodeId{}, integer()) ::
              :ok | {:error, binary()} | {:error, :einval}
      def write_node_minimum_sampling_interval(
            pid,
            %NodeId{} = node_id,
            minimum_sampling_interval
          ) do
        GenServer.call(
          pid,
          {:write, {:minimum_sampling_interval, node_id, minimum_sampling_interval}}
        )
      end

      @doc """
      Change 'Historizing' attribute of a node in the server.
      """
      @spec write_node_historizing(GenServer.server(), %NodeId{}, boolean()) ::
              :ok | {:error, binary()} | {:error, :einval}
      def write_node_historizing(pid, %NodeId{} = node_id, historizing?) do
        GenServer.call(pid, {:write, {:historizing, node_id, historizing?}})
      end

      @doc """
      Change 'Executable' attribute of a node in the server.
      """
      @spec write_node_executable(GenServer.server(), %NodeId{}, boolean()) ::
              :ok | {:error, binary()} | {:error, :einval}
      def write_node_executable(pid, %NodeId{} = node_id, executable?) do
        GenServer.call(pid, {:write, {:executable, node_id, executable?}})
      end

      @doc """
      Change 'event_notifier' attribute of a node in the server.
      """
      @spec write_node_event_notifier(GenServer.server(), %NodeId{}, integer()) ::
              :ok | {:error, binary()} | {:error, :einval}
      def write_node_event_notifier(pid, %NodeId{} = node_id, event_notifier) when is_integer(event_notifier) do
        GenServer.call(pid, {:write, {:event_notifier, node_id, event_notifier}})
      end

      @doc """
      Change 'Value' attribute of a node in the server.
      """
      @spec write_node_value(GenServer.server(), %NodeId{}, integer(), term()) ::
              :ok | {:error, binary()} | {:error, :einval}
      def write_node_value(pid, %NodeId{} = node_id, data_type, value, index \\ 0) do
        GenServer.call(pid, {:write, {:value, node_id, {data_type, value, index}}})
      end

      @doc """
      Creates a blank 'value array' attribute of a node in the server.
      Note: the array must match with 'value_rank' and 'array_dimensions' attribute.
      """
      @spec write_node_blank_array(GenServer.server(), %NodeId{}, integer(), list()) ::
              :ok | {:error, binary()} | {:error, :einval}
      def write_node_blank_array(pid, %NodeId{} = node_id, data_type, array_dimensions)
          when is_integer(data_type) and is_list(array_dimensions) do
        GenServer.call(pid, {:write, {:array, node_id, {data_type, array_dimensions}}})
      end

      # Read nodes Attributes function

      @doc """
      Reads the node_id attribute of a node in the server.
      """
      @spec read_node_node_id(GenServer.server(), %NodeId{}) ::
              {:ok, %NodeId{}} | {:error, binary()} | {:error, :einval}
      def read_node_node_id(pid, %NodeId{} = node_id) do
        GenServer.call(pid, {:read, {:node_id, node_id}})
      end

      @doc """
      Reads the node_class attribute of a node in the server.
      """
      @spec read_node_node_class(GenServer.server(), %NodeId{}) ::
              {:ok, %NodeId{}} | {:error, binary()} | {:error, :einval}
      def read_node_node_class(pid, %NodeId{} = node_id) do
        GenServer.call(pid, {:read, {:node_class, node_id}})
      end

      @doc """
      Reads the browse name attribute of a node in the server.
      """
      @spec read_node_browse_name(GenServer.server(), %NodeId{}) ::
              {:ok, %QualifiedName{}} | {:error, binary()} | {:error, :einval}
      def read_node_browse_name(pid, %NodeId{} = node_id) do
        GenServer.call(pid, {:read, {:browse_name, node_id}})
      end

      @doc """
      Reads the display name attribute of a node in the server.
      """
      @spec read_node_display_name(GenServer.server(), %NodeId{}) ::
              {:ok, {binary(), binary()}} | {:error, binary()} | {:error, :einval}
      def read_node_display_name(pid, %NodeId{} = node_id) do
        GenServer.call(pid, {:read, {:display_name, node_id}})
      end

      @doc """
      Reads description attribute of a node in the server.
      """
      @spec read_node_description(GenServer.server(), %NodeId{}) ::
              {:ok, {binary(), binary()}} | {:error, binary()} | {:error, :einval}
      def read_node_description(pid, node_id) do
        GenServer.call(pid, {:read, {:description, node_id}})
      end

      @doc """
      Reads 'Is Abstract' attribute of a node in the server.
      """
      @spec read_node_is_abstract(GenServer.server(), %NodeId{}) ::
              {:ok, boolean()} | {:error, binary()} | {:error, :einval}
      def read_node_is_abstract(pid, node_id) do
        GenServer.call(pid, {:read, {:is_abstract, node_id}})
      end

      @doc """
      Reads 'Symmetric' attribute of a node in the server.
      """
      @spec read_node_symmetric(GenServer.server(), %NodeId{}) ::
              {:ok, boolean()} | {:error, binary()} | {:error, :einval}
      def read_node_symmetric(pid, node_id) do
        GenServer.call(pid, {:read, {:symmetric, node_id}})
      end

      # TODO: friendlier write_mask params
      @doc """
      Reads 'Write Mask' attribute of a node in the server.
      """
      @spec read_node_write_mask(GenServer.server(), %NodeId{}) ::
              {:ok, integer()} | {:error, binary()} | {:error, :einval}
      def read_node_write_mask(pid, node_id) do
        GenServer.call(pid, {:read, {:write_mask, node_id}})
      end

      @doc """
      Reads 'data_type' attribute of a node in the server.
      """
      @spec read_node_data_type(GenServer.server(), %NodeId{}) ::
              {:ok, %NodeId{}} | {:error, binary()} | {:error, :einval}
      def read_node_data_type(pid, node_id) do
        GenServer.call(pid, {:read, {:data_type, node_id}})
      end

      @doc """
      Reads 'Inverse name' attribute of a node in the server.
      """
      @spec read_node_inverse_name(GenServer.server(), %NodeId{}) ::
              {:ok, {binary(), binary()}} | {:error, binary()} | {:error, :einval}
      def read_node_inverse_name(pid, node_id) do
        GenServer.call(pid, {:read, {:inverse_name, node_id}})
      end

      @doc """
      Reads 'contains_no_loops' attribute of a node in the server.
      """
      @spec read_node_contains_no_loops(GenServer.server(), %NodeId{}) ::
              {:ok, {binary(), binary()}} | {:error, binary()} | {:error, :einval}
      def read_node_contains_no_loops(pid, node_id) do
        GenServer.call(pid, {:read, {:contains_no_loops, node_id}})
      end

      @doc """
      Reads 'Value Rank' of a node in the server.
      """
      @spec read_node_value_rank(GenServer.server(), %NodeId{}) ::
              {:ok, integer()} | {:error, binary()} | {:error, :einval}
      def read_node_value_rank(pid, node_id) do
        GenServer.call(pid, {:read, {:value_rank, node_id}})
      end

      @doc """
      Reads 'array_dimensions' of a node in the server.
      """
      @spec read_node_array_dimensions(GenServer.server(), %NodeId{}) ::
              {:ok, list()} | {:error, binary()} | {:error, :einval}
      def read_node_array_dimensions(pid, node_id) do
        GenServer.call(pid, {:read, {:array_dimensions, node_id}})
      end

      @doc """
      Reads 'Access level' of a node in the server.
      """
      @spec read_node_access_level(GenServer.server(), %NodeId{}) ::
              {:ok, integer()} | {:error, binary()} | {:error, :einval}
      def read_node_access_level(pid, node_id) do
        GenServer.call(pid, {:read, {:access_level, node_id}})
      end

      @doc """
      Reads 'Minimum Sampling Interval level' of a node in the server.
      """
      @spec read_node_minimum_sampling_interval(GenServer.server(), %NodeId{}) ::
              {:ok, integer()} | {:error, binary()} | {:error, :einval}
      def read_node_minimum_sampling_interval(pid, node_id) do
        GenServer.call(pid, {:read, {:minimum_sampling_interval, node_id}})
      end

      @doc """
      Reads 'Historizing' attribute of a node in the server.
      """
      @spec read_node_historizing(GenServer.server(), %NodeId{}) ::
              {:ok, boolean()} | {:error, binary()} | {:error, :einval}
      def read_node_historizing(pid, node_id) do
        GenServer.call(pid, {:read, {:historizing, node_id}})
      end

      @doc """
      Reads 'Executable' attribute of a node in the server.
      """
      @spec read_node_executable(GenServer.server(), %NodeId{}) ::
              {:ok, boolean()} | {:error, binary()} | {:error, :einval}
      def read_node_executable(pid, node_id) do
        GenServer.call(pid, {:read, {:executable, node_id}})
      end

      @doc """
      Reads 'event_notifier' attribute of a node in the server.
      """
      @spec read_node_event_notifier(GenServer.server(), %NodeId{}) ::
              {:ok, term()} | {:error, binary()} | {:error, :einval}
      def read_node_event_notifier(pid, node_id) do
        GenServer.call(pid, {:read, {:event_notifier, node_id}})
      end

      @doc """
      Reads 'value' attribute of a node in the server.
      Note: If the value is an array you can search a scalar using `index` parameter.
      """
      @spec read_node_value(GenServer.server(), %NodeId{}, integer()) ::
              {:ok, term()} | {:error, binary()} | {:error, :einval}
      def read_node_value(pid, node_id, index \\ 0) do
        if(@mix_env != :test) do
          GenServer.call(pid, {:read, {:value, {node_id, index}}})
        else
          # Valgrind
          GenServer.call(pid, {:read, {:value, {node_id, index}}}, :infinity)
        end
      end

      @doc """
      Reads 'value' attribute of a node in the server.
      Note: If the value is an array you can search a scalar using `index` parameter.
      """
      @spec read_node_value_by_index(GenServer.server(), %NodeId{}, integer()) ::
              {:ok, term()} | {:error, binary()} | {:error, :einval}
      def read_node_value_by_index(pid, node_id, index \\ 0) do
        if(@mix_env != :test) do
          GenServer.call(pid, {:read, {:value_by_index, {node_id, index}}})
        else
          # Valgrind
          GenServer.call(pid, {:read, {:value_by_index, {node_id, index}}}, :infinity)
        end
      end

      @doc """
      Reads 'Value' attribute (matching data type) of a node in the server.
      """
      @spec read_node_value_by_data_type(GenServer.server(), %NodeId{}, integer()) ::
              {:ok, term()} | {:error, binary()} | {:error, :einval}
      def read_node_value_by_data_type(pid, node_id, data_type) when is_integer(data_type) do
        GenServer.call(pid, {:read, {:value_by_data_type, {node_id, data_type}}})
      end

      # Write nodes Attributes handlers
      def handle_call({:write, {:browse_name, node_id, browse_name}}, caller_info, state) do
        c_args = {to_c(node_id), to_c(browse_name)}
        call_port(state, :write_node_browse_name, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:write, {:display_name, node_id, {locale, name}}}, caller_info, state)
          when is_binary(locale) and is_binary(name) do
        c_args = {to_c(node_id), locale, name}
        call_port(state, :write_node_display_name, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call(
            {:write, {:description, node_id, {locale, description}}},
            caller_info,
            state
          )
          when is_binary(locale) and is_binary(description) do
        c_args = {to_c(node_id), locale, description}
        call_port(state, :write_node_description, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:write, {:write_mask, node_id, write_mask}}, caller_info, state)
          when is_integer(write_mask) do
        c_args = {to_c(node_id), write_mask}
        call_port(state, :write_node_write_mask, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:write, {:is_abstract, node_id, is_abstract?}}, caller_info, state)
          when is_boolean(is_abstract?) do
        c_args = {to_c(node_id), is_abstract?}
        call_port(state, :write_node_is_abstract, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call(
            {:write, {:inverse_name, node_id, {locale, inverse_name}}},
            caller_info,
            state
          )
          when is_binary(locale) and is_binary(inverse_name) do
        c_args = {to_c(node_id), locale, inverse_name}
        call_port(state, :write_node_inverse_name, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:write, {:data_type, node_id, data_type_node_id}}, caller_info, state) do
        c_args = {to_c(node_id), to_c(data_type_node_id)}
        call_port(state, :write_node_data_type, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:write, {:value_rank, node_id, value_rank}}, caller_info, state)
          when is_integer(value_rank) do
        c_args = {to_c(node_id), value_rank}
        call_port(state, :write_node_value_rank, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:write, {:array_dimensions, node_id, array_dimensions}}, caller_info, state)
          when is_list(array_dimensions) do
        with true <- all_must_be(:integer, array_dimensions) do
          c_args = {to_c(node_id), length(array_dimensions), List.to_tuple(array_dimensions)}
          call_port(state, :write_node_array_dimensions, caller_info, c_args)
          {:noreply, state}
        else
          _ ->
            {:reply, {:error, :einval}, state}
        end
      end

      def handle_call({:write, {:access_level, node_id, access_level}}, caller_info, state)
          when is_integer(access_level) do
        c_args = {to_c(node_id), access_level}
        call_port(state, :write_node_access_level, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call(
            {:write, {:minimum_sampling_interval, node_id, minimum_sampling_interval}},
            caller_info,
            state
          )
          when is_float(minimum_sampling_interval) do
        c_args = {to_c(node_id), minimum_sampling_interval}
        call_port(state, :write_node_minimum_sampling_interval, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:write, {:historizing, node_id, historizing?}}, caller_info, state)
          when is_boolean(historizing?) do
        c_args = {to_c(node_id), historizing?}
        call_port(state, :write_node_historizing, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:write, {:executable, node_id, executable?}}, caller_info, state)
          when is_boolean(executable?) do
        c_args = {to_c(node_id), executable?}
        call_port(state, :write_node_executable, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:write, {:event_notifier, node_id, event_notifier}}, caller_info, state)
          when is_integer(event_notifier) do
        c_args = {to_c(node_id), event_notifier}
        call_port(state, :write_node_event_notifier, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:write, {:value, node_id, {data_type, raw_value}}}, caller_info, state) do
        c_args = {to_c(node_id), data_type, 0, value_to_c(data_type, raw_value)}
        call_port(state, :write_node_value, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:write, {:value, node_id, {data_type, raw_value, index}}}, caller_info, state) do
        c_args = {to_c(node_id), data_type, index, value_to_c(data_type, raw_value)}
        call_port(state, :write_node_value, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:write, {:array, node_id, {data_type, array_dimensions}}}, caller_info, state)
          when is_integer(data_type) and is_list(array_dimensions) do
        with  true <- all_must_be(:integer, array_dimensions),
              array_raw_size <- get_array_raw_size(array_dimensions) do
          #{node_id, data_type, }
          c_args = {to_c(node_id), data_type, length(array_dimensions), array_raw_size, List.to_tuple(array_dimensions)}
          call_port(state, :write_node_blank_array, caller_info, c_args)
          {:noreply, state}
        else
          _ ->
            {:reply, {:error, :einval}, state}
        end
      end

      # Read nodes Attributes handlers

      def handle_call({:read, {:node_id, node_id}}, caller_info, state) do
        c_args = to_c(node_id)
        call_port(state, :read_node_node_id, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:read, {:browse_name, node_id}}, caller_info, state) do
        c_args = to_c(node_id)
        call_port(state, :read_node_browse_name, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:read, {:node_class, node_id}}, caller_info, state) do
        c_args = to_c(node_id)
        call_port(state, :read_node_node_class, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:read, {:display_name, node_id}}, caller_info, state) do
        c_args = to_c(node_id)
        call_port(state, :read_node_display_name, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:read, {:description, node_id}}, caller_info, state) do
        c_args = to_c(node_id)
        call_port(state, :read_node_description, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:read, {:is_abstract, node_id}}, caller_info, state) do
        c_args = to_c(node_id)
        call_port(state, :read_node_is_abstract, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:read, {:symmetric, node_id}}, caller_info, state) do
        c_args = to_c(node_id)
        call_port(state, :read_node_symmetric, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:read, {:write_mask, node_id}}, caller_info, state) do
        c_args = to_c(node_id)
        call_port(state, :read_node_write_mask, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:read, {:data_type, node_id}}, caller_info, state) do
        c_args = to_c(node_id)
        call_port(state, :read_node_data_type, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:read, {:inverse_name, node_id}}, caller_info, state) do
        c_args = to_c(node_id)
        call_port(state, :read_node_inverse_name, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:read, {:contains_no_loops, node_id}}, caller_info, state) do
        c_args = to_c(node_id)
        call_port(state, :read_node_contains_no_loops, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:read, {:value_rank, node_id}}, caller_info, state) do
        c_args = to_c(node_id)
        call_port(state, :read_node_value_rank, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:read, {:array_dimensions, node_id}}, caller_info, state) do
        c_args = to_c(node_id)
        call_port(state, :read_node_array_dimensions, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:read, {:access_level, node_id}}, caller_info, state) do
        c_args = to_c(node_id)
        call_port(state, :read_node_access_level, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:read, {:minimum_sampling_interval, node_id}}, caller_info, state) do
        c_args = to_c(node_id)
        call_port(state, :read_node_minimum_sampling_interval, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:read, {:historizing, node_id}}, caller_info, state) do
        c_args = to_c(node_id)
        call_port(state, :read_node_historizing, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:read, {:executable, node_id}}, caller_info, state) do
        c_args = to_c(node_id)
        call_port(state, :read_node_executable, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:read, {:event_notifier, node_id}}, caller_info, state) do
        c_args = to_c(node_id)
        call_port(state, :read_node_event_notifier, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:read, {:value, {node_id, index}}}, caller_info, state) do
        c_args = {to_c(node_id), index}
        call_port(state, :read_node_value, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:read, {:value_by_index, {node_id, index}}}, caller_info, state) do
        c_args = {to_c(node_id), index}
        call_port(state, :read_node_value_by_index, caller_info, c_args)
        {:noreply, state}
      end

      def handle_call({:read, {:value_by_data_type, {node_id, data_type}}}, caller_info, state) do
        c_args = {to_c(node_id), data_type}
        call_port(state, :read_node_value_by_data_type, caller_info, c_args)
        {:noreply, state}
      end

      # Catch all handlers

      def handle_info({_port, {:data, <<?r, c_response::binary>>}}, state) do
        state =
          c_response
          |> :erlang.binary_to_term()
          |> handle_c_response(state)

        {:noreply, state}
      end

      # Write nodes Attributes C handlers

      defp handle_c_response({:write_node_browse_name, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:write_node_display_name, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:write_node_description, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:write_node_write_mask, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:write_node_is_abstract, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:write_node_inverse_name, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:write_node_data_type, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:write_node_value_rank, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:write_node_array_dimensions, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:write_node_access_level, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response(
             {:write_node_minimum_sampling_interval, caller_metadata, data},
             state
           ) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:write_node_historizing, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:write_node_executable, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:write_node_event_notifier, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:write_node_value, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:write_node_blank_array, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      # Read nodes Attributes C handlers

      defp handle_c_response({:read_node_node_id, caller_metadata, node_id_response}, state) do
        response = parse_node_id(node_id_response)
        GenServer.reply(caller_metadata, response)
        state
      end

      defp handle_c_response({:read_node_node_class, caller_metadata, data}, state) do
        response = charlist_to_string(data)
        GenServer.reply(caller_metadata, response)
        state
      end

      defp handle_c_response(
             {:read_node_browse_name, caller_metadata, browse_name_response},
             state
           ) do
        response = parse_browse_name(browse_name_response)
        GenServer.reply(caller_metadata, response)
        state
      end

      defp handle_c_response({:read_node_display_name, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:read_node_description, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:read_node_write_mask, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:read_node_is_abstract, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:read_node_symmetric, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:read_node_inverse_name, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:read_node_data_type, caller_metadata, data_type_response}, state) do
        response = parse_data_type(data_type_response)
        GenServer.reply(caller_metadata, response)
        state
      end

      defp handle_c_response({:read_node_value_rank, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:read_node_array_dimensions, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:read_node_access_level, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:read_node_minimum_sampling_interval, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:read_node_contains_no_loops, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:read_node_historizing, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:read_node_executable, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:read_node_event_notifier, caller_metadata, data}, state) do
        GenServer.reply(caller_metadata, data)
        state
      end

      defp handle_c_response({:read_node_value, caller_metadata, value_response}, state) do
        response = parse_value(value_response)
        GenServer.reply(caller_metadata, response)
        state
      end

      defp handle_c_response({:read_node_value_by_index, caller_metadata, value_response}, state) do
        response = parse_value(value_response)
        GenServer.reply(caller_metadata, response)
        state
      end

      defp handle_c_response(
             {:read_node_value_by_data_type, caller_metadata, value_response},
             state
           ) do
        response = parse_value(value_response)
        GenServer.reply(caller_metadata, response)
        state
      end

      defp use_valgrind?(), do: System.get_env("USE_VALGRIND", "false")

      defp open_port(executable, "false") do
        Port.open({:spawn_executable, to_charlist(executable)}, [
          {:args, []},
          {:packet, 2},
          :use_stdio,
          :binary,
          :exit_status
        ])
      end

      defp open_port(executable, valgrind_env) do
        Logger.warn("(#{__MODULE__}) Valgrind Activated: #{inspect valgrind_env}")
        Port.open({:spawn_executable, to_charlist("/usr/bin/valgrind.bin")}, [
          {:args,
           [
             "-q",
             "--undef-value-errors=no",
             "--leak-check=full",
             "--show-leak-kinds=all",
             #"--verbose",
             #"--track-origins=yes",
             executable
           ]},
          {:packet, 2},
          :use_stdio,
          :binary,
          :exit_status
        ])
      end

      defp call_port(state, command, caller, arguments) do
        msg = {command, caller, arguments}
        send(state.port, {self(), {:command, :erlang.term_to_binary(msg)}})
      end

      defp charlist_to_string({:ok, charlist}), do: {:ok, to_string(charlist)}
      defp charlist_to_string(error_response), do: error_response

      defp to_c(%NodeId{ns_index: ns_index, identifier_type: id_type, identifier: identifier}),
        do: {id_type, ns_index, identifier}

      defp to_c(%QualifiedName{ns_index: ns_index, name: name}),
        do: {ns_index, name}

      defp to_c(_invalid_struct), do: raise("Invalid Data type")

      # For NodeId, QualifiedName.
      defp value_to_c(data_type, value) when data_type in [16, 17, 19], do: to_c(value)
      # SEMANTICCHANGESTRUCTUREDATATYPE
      defp value_to_c(data_type, {arg1, arg2}) when data_type == 25, do: {to_c(arg1), to_c(arg2)}
      defp value_to_c(_data_type, value), do: value

      defp parse_browse_name({:ok, {ns_index, name}}),
        do: {:ok, QualifiedName.new(ns_index: ns_index, name: name)}

      defp parse_browse_name(response), do: response

      defp parse_node_id({:ok, {ns_index, type, name}}),
        do: {:ok, NodeId.new(ns_index: ns_index, identifier_type: type, identifier: name)}

      defp parse_node_id(response), do: response

      defp parse_data_type({:ok, {ns_index, type, name}}),
        do: {:ok, NodeId.new(ns_index: ns_index, identifier_type: type, identifier: name)}

      defp parse_data_type(response), do: response

      defp parse_value({:ok, {ns_index, type, name, name_space_uri, server_index}}),
        do:
          {:ok,
           ExpandedNodeId.new(
             node_id: NodeId.new(ns_index: ns_index, identifier_type: type, identifier: name),
             name_space_uri: name_space_uri,
             server_index: server_index
           )}

      defp parse_value({:ok, {ns_index, type, name}}),
        do: {:ok, NodeId.new(ns_index: ns_index, identifier_type: type, identifier: name)}

      defp parse_value({:ok, {{ns_index1, type1, name1}, {ns_index2, type2, name2}}}),
        do: {
          :ok,
          {
            NodeId.new(ns_index: ns_index1, identifier_type: type1, identifier: name1),
            NodeId.new(ns_index: ns_index2, identifier_type: type2, identifier: name2)
          }
        }

      defp parse_value({:ok, {ns_index, name}}) when is_integer(ns_index),
        do: {:ok, QualifiedName.new(ns_index: ns_index, name: name)}

      defp parse_value({:ok, array}) when is_list(array),
        do: {:ok, Enum.map(array, fn(data) -> parse_c_value(data) end)}

      defp parse_value(response), do: response

      defp parse_c_value({ns_index, type, name, name_space_uri, server_index}),
        do:
          ExpandedNodeId.new(
            node_id: NodeId.new(ns_index: ns_index, identifier_type: type, identifier: name),
            name_space_uri: name_space_uri,
            server_index: server_index
          )

      defp parse_c_value({ns_index, type, name}),
        do: NodeId.new(ns_index: ns_index, identifier_type: type, identifier: name)

      defp parse_c_value({{ns_index1, type1, name1}, {ns_index2, type2, name2}}),
        do: {
          NodeId.new(ns_index: ns_index1, identifier_type: type1, identifier: name1),
          NodeId.new(ns_index: ns_index2, identifier_type: type2, identifier: name2)
        }

      defp parse_c_value({ns_index, name}) when is_integer(ns_index),
        do: QualifiedName.new(ns_index: ns_index, name: name)

      defp parse_c_value(array) when is_list(array),
        do: Enum.map(array, fn(data) -> parse_c_value(data) end)

      defp parse_c_value(response), do: response

      @doc false
      def set_ld_library_path(priv_dir) do
        System.get_env("LD_LIBRARY_PATH", "")
        |> String.contains?(priv_dir)
        |> write_ld_library_path(priv_dir)
      end

      defp write_ld_library_path(false, priv_dir) do
        ld_dirs =
          System.get_env("LD_LIBRARY_PATH", "")
          |> Path.join(":")
          |> Path.join(priv_dir)
          |> Path.join("/lib")

        System.put_env("LD_LIBRARY_PATH", ld_dirs)
        priv_dir
      end

      defp all_must_be(:integer, list),
        do: Enum.all?(list, fn x -> is_integer(x) end)

      defp get_array_raw_size(array_dimensions),
        do: Enum.reduce(array_dimensions, 1, fn(x, acc) -> x * acc end)

      defp write_ld_library_path(true, priv_dir), do: priv_dir

      defp get_binary_data(binary) when is_binary(binary), do: binary
      defp get_binary_data(function) when is_function(function), do: function.()
      defp get_binary_data(_non_binary_or_function), do: nil
    end
  end
end