%%%-------------------------------------------------------------------
%%% @private
%%% @doc
%%% Utilities for options and configuration
%%% @end
%%%-------------------------------------------------------------------
-module(denrei_utils).

%% Includes
-include("denrei.hrl").

%% API
-export([
    get_opt/4,
    to_integer/1,
    to_ip/1,
    tokenize_subject/1,
    timestamp/0,
    timestamp/1,
    interleave_field_size/1,
    get_next_field/1,
    send/3,
    send/4,
    send/5,
    integer_to_binary/1,
    integer_to_binary/2,
    binary_to_integer/1,
    binary_to_integer/2
]).

-spec get_opt(string(), atom(), proplists:proplist(), term()) -> term().
get_opt(VarName, Key, Args, Default) ->
    case proplists:get_value(Key, Args) of
        undefined ->
            case os:getenv(VarName) of
                false ->
                    case application:get_env(?APPLICATION, Key) of
                        undefined ->
                            Default;
                        {ok, Value} ->
                            Value
                    end;
                "true" ->
                    true;
                Value ->
                    Value
            end;
        Value ->
            Value
    end.

-spec to_integer(string() | integer()) -> integer().
to_integer(Value) when is_list(Value) ->
    erlang:list_to_integer(Value);

to_integer(Value) ->
    Value.

-spec to_ip(binary() | string() | inet:ip_address() | inet:hostname()) -> inet:ip_address().
to_ip(Value) when is_binary(Value) ->
    to_ip(binary_to_list(Value));

to_ip(Value) ->
    case inet:getaddr(Value, inet) of
        {ok, Address} ->
            Address;
        {error, _} ->
            case inet:ifget(Value, [addr]) of
                {ok, [{addr, Address}]} ->
                    Address;
                _ -> undefined
            end
    end.

-spec tokenize_subject(iolist() | binary() | all) -> [atom()] | all.
tokenize_subject(all) ->
    all;

tokenize_subject(Subject) when is_list(Subject) ->
    tokenize_subject(iolist_to_binary(Subject));

tokenize_subject(Subject) ->
    [Fields | _] = binary:split(Subject, <<" ">>),
    [binary_to_atom(Field, utf8) || Field <- binary:split(Fields, <<".">>, [global])].

-spec timestamp() -> non_neg_integer().
timestamp() ->
    timestamp(os:timestamp()).

-spec timestamp(erlang:timestamp()) -> non_neg_integer().
timestamp({Mega, Sec, Micro}) ->
    Mega * 1000000 * 1000000 + Sec * 1000000 + Micro.

-spec interleave_field_size([binary()]) -> [binary()].
interleave_field_size(Fields) ->
    lists:foldr(fun(Field, AccIn) ->
        Size = size(Field),
        [<<Size:24>> | [Field | AccIn]]
    end, [], Fields).

-spec get_next_field(binary()) -> {binary(), binary()}.
get_next_field(<<Size:24, Packet/binary>>) ->
    <<Field:Size/binary, Rest/binary>> = Packet,
    {Field, Rest}.

-spec send(module(), any(), iodata()) -> ok | {error, atom()}.
send(Transport, Socket, Packet) ->
    lager:debug([{transport, Transport}, {socket, Socket}], "~p send: ~p", [Transport, Packet]),
    Transport:send(Socket, Packet).

-spec send(module(), any(), iodata(), [binary()]) -> ok | {error, atom()}.
send(Transport, Socket, Prefix, Fields) ->
    send(Transport, Socket, [Prefix, denrei_utils:interleave_field_size(Fields)]).

-spec send(module(), any(), iodata(), [binary()], iodata()) -> ok | {error, atom()}.
send(Transport, Socket, Prefix, Fields, Suffix) ->
    send(Transport, Socket, [Prefix, denrei_utils:interleave_field_size(Fields), Suffix]).

-spec integer_to_binary(Integer :: integer()) -> binary().
integer_to_binary(Integer) ->
    ?MODULE:integer_to_binary(Integer, 10).

-spec integer_to_binary(Integer :: integer(), Base :: 2..36) -> binary().
integer_to_binary(Integer, Base) ->
    list_to_binary(integer_to_list(Integer, Base)).

-spec binary_to_integer(Binary :: binary()) -> integer().
binary_to_integer(Binary) ->
    ?MODULE:binary_to_integer(Binary, 10).

-spec binary_to_integer(Binary :: binary(), Base :: 2..36) -> integer().
binary_to_integer(Binary, Base) ->
    list_to_integer(binary_to_list(Binary), Base).