observatory

-module(observatory).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([init/0, collect/1, counter_init/2, counter_inc_by/3, counter_inc/2]).
-export_type([observatory/0, collector/0]).

-type observatory() :: {observatory, gleam@dict:dict(binary(), collector())}.

-type collector() :: {a_counter, float()}.

-spec init() -> observatory().
init() ->
    {observatory, gleam@dict:new()}.

-spec collect(observatory()) -> list({binary(), float()}).
collect(Observatory) ->
    _pipe = maps:to_list(erlang:element(2, Observatory)),
    gleam@list:map(_pipe, fun(Entry) -> case gleam@pair:second(Entry) of
                {a_counter, Counter} ->
                    {gleam@pair:first(Entry), Counter}
            end end).

-spec counter_init(observatory(), binary()) -> observatory().
counter_init(Observatory, Name) ->
    {observatory,
        gleam@dict:insert(
            erlang:element(2, Observatory),
            Name,
            {a_counter, +0.0}
        )}.

-spec inc_collector_by(float()) -> fun((gleam@option:option(collector())) -> collector()).
inc_collector_by(Increment) ->
    fun(Opt_collector) -> case Opt_collector of
            {some, Collector} ->
                case Collector of
                    {a_counter, Collector@1} ->
                        {a_counter, Collector@1 + Increment}
                end;

            none ->
                {a_counter, Increment}
        end end.

-spec counter_inc_by(observatory(), binary(), float()) -> observatory().
counter_inc_by(Observatory, Name, Increment) ->
    {observatory,
        gleam@dict:update(
            erlang:element(2, Observatory),
            Name,
            inc_collector_by(Increment)
        )}.

-spec counter_inc(observatory(), binary()) -> observatory().
counter_inc(Observatory, Name) ->
    counter_inc_by(Observatory, Name, 1.0).