-module(protocol@profiler).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([encode__position_tick_info/1, encode__profile_node/1, encode__profile/1, decode__position_tick_info/1, decode__profile_node/1, decode__profile/1, encode__coverage_range/1, decode__coverage_range/1, encode__function_coverage/1, decode__function_coverage/1, encode__script_coverage/1, decode__script_coverage/1, decode__get_best_effort_coverage_response/1, decode__start_precise_coverage_response/1, decode__stop_response/1, decode__take_precise_coverage_response/1, disable/1, enable/1, get_best_effort_coverage/1, set_sampling_interval/2, start/1, start_precise_coverage/4, stop/1, stop_precise_coverage/1, take_precise_coverage/1]).
-export_type([profile_node/0, profile/0, position_tick_info/0, coverage_range/0, function_coverage/0, script_coverage/0, get_best_effort_coverage_response/0, start_precise_coverage_response/0, stop_response/0, take_precise_coverage_response/0]).

-type profile_node() :: {profile_node,
        integer(),
        protocol@runtime:call_frame(),
        gleam@option:option(integer()),
        gleam@option:option(list(integer())),
        gleam@option:option(binary()),
        gleam@option:option(list(position_tick_info()))}.

-type profile() :: {profile,
        list(profile_node()),
        float(),
        float(),
        gleam@option:option(list(integer())),
        gleam@option:option(list(integer()))}.

-type position_tick_info() :: {position_tick_info, integer(), integer()}.

-type coverage_range() :: {coverage_range, integer(), integer(), integer()}.

-type function_coverage() :: {function_coverage,
        binary(),
        list(coverage_range()),
        boolean()}.

-type script_coverage() :: {script_coverage,
        protocol@runtime:script_id(),
        binary(),
        list(function_coverage())}.

-type get_best_effort_coverage_response() :: {get_best_effort_coverage_response,
        list(script_coverage())}.

-type start_precise_coverage_response() :: {start_precise_coverage_response,
        float()}.

-type stop_response() :: {stop_response, profile()}.

-type take_precise_coverage_response() :: {take_precise_coverage_response,
        list(script_coverage()),
        float()}.

-spec encode__position_tick_info(position_tick_info()) -> gleam@json:json().
encode__position_tick_info(Value__) ->
    gleam@json:object(
        [{<<"line"/utf8>>, gleam@json:int(erlang:element(2, Value__))},
            {<<"ticks"/utf8>>, gleam@json:int(erlang:element(3, Value__))}]
    ).

-spec encode__profile_node(profile_node()) -> gleam@json:json().
encode__profile_node(Value__) ->
    gleam@json:object(
        begin
            _pipe = [{<<"id"/utf8>>, gleam@json:int(erlang:element(2, Value__))},
                {<<"callFrame"/utf8>>,
                    protocol@runtime:encode__call_frame(
                        erlang:element(3, Value__)
                    )}],
            _pipe@1 = chrobot@internal@utils:add_optional(
                _pipe,
                erlang:element(4, Value__),
                fun(Inner_value__) ->
                    {<<"hitCount"/utf8>>, gleam@json:int(Inner_value__)}
                end
            ),
            _pipe@2 = chrobot@internal@utils:add_optional(
                _pipe@1,
                erlang:element(5, Value__),
                fun(Inner_value__@1) ->
                    {<<"children"/utf8>>,
                        gleam@json:array(Inner_value__@1, fun gleam@json:int/1)}
                end
            ),
            _pipe@3 = chrobot@internal@utils:add_optional(
                _pipe@2,
                erlang:element(6, Value__),
                fun(Inner_value__@2) ->
                    {<<"deoptReason"/utf8>>, gleam@json:string(Inner_value__@2)}
                end
            ),
            chrobot@internal@utils:add_optional(
                _pipe@3,
                erlang:element(7, Value__),
                fun(Inner_value__@3) ->
                    {<<"positionTicks"/utf8>>,
                        gleam@json:array(
                            Inner_value__@3,
                            fun encode__position_tick_info/1
                        )}
                end
            )
        end
    ).

-spec encode__profile(profile()) -> gleam@json:json().
encode__profile(Value__) ->
    gleam@json:object(
        begin
            _pipe = [{<<"nodes"/utf8>>,
                    gleam@json:array(
                        erlang:element(2, Value__),
                        fun encode__profile_node/1
                    )},
                {<<"startTime"/utf8>>,
                    gleam@json:float(erlang:element(3, Value__))},
                {<<"endTime"/utf8>>,
                    gleam@json:float(erlang:element(4, Value__))}],
            _pipe@1 = chrobot@internal@utils:add_optional(
                _pipe,
                erlang:element(5, Value__),
                fun(Inner_value__) ->
                    {<<"samples"/utf8>>,
                        gleam@json:array(Inner_value__, fun gleam@json:int/1)}
                end
            ),
            chrobot@internal@utils:add_optional(
                _pipe@1,
                erlang:element(6, Value__),
                fun(Inner_value__@1) ->
                    {<<"timeDeltas"/utf8>>,
                        gleam@json:array(Inner_value__@1, fun gleam@json:int/1)}
                end
            )
        end
    ).

-spec decode__position_tick_info(gleam@dynamic:dynamic_()) -> {ok,
        position_tick_info()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__position_tick_info(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:field(<<"line"/utf8>>, fun gleam@dynamic:int/1))(Value__),
        fun(Line) ->
            gleam@result:'try'(
                (gleam@dynamic:field(<<"ticks"/utf8>>, fun gleam@dynamic:int/1))(
                    Value__
                ),
                fun(Ticks) -> {ok, {position_tick_info, Line, Ticks}} end
            )
        end
    ).

-spec decode__profile_node(gleam@dynamic:dynamic_()) -> {ok, profile_node()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__profile_node(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:field(<<"id"/utf8>>, fun gleam@dynamic:int/1))(Value__),
        fun(Id) ->
            gleam@result:'try'(
                (gleam@dynamic:field(
                    <<"callFrame"/utf8>>,
                    fun protocol@runtime:decode__call_frame/1
                ))(Value__),
                fun(Call_frame) ->
                    gleam@result:'try'(
                        (gleam@dynamic:optional_field(
                            <<"hitCount"/utf8>>,
                            fun gleam@dynamic:int/1
                        ))(Value__),
                        fun(Hit_count) ->
                            gleam@result:'try'(
                                (gleam@dynamic:optional_field(
                                    <<"children"/utf8>>,
                                    gleam@dynamic:list(fun gleam@dynamic:int/1)
                                ))(Value__),
                                fun(Children) ->
                                    gleam@result:'try'(
                                        (gleam@dynamic:optional_field(
                                            <<"deoptReason"/utf8>>,
                                            fun gleam@dynamic:string/1
                                        ))(Value__),
                                        fun(Deopt_reason) ->
                                            gleam@result:'try'(
                                                (gleam@dynamic:optional_field(
                                                    <<"positionTicks"/utf8>>,
                                                    gleam@dynamic:list(
                                                        fun decode__position_tick_info/1
                                                    )
                                                ))(Value__),
                                                fun(Position_ticks) ->
                                                    {ok,
                                                        {profile_node,
                                                            Id,
                                                            Call_frame,
                                                            Hit_count,
                                                            Children,
                                                            Deopt_reason,
                                                            Position_ticks}}
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-spec decode__profile(gleam@dynamic:dynamic_()) -> {ok, profile()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__profile(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:field(
            <<"nodes"/utf8>>,
            gleam@dynamic:list(fun decode__profile_node/1)
        ))(Value__),
        fun(Nodes) ->
            gleam@result:'try'(
                (gleam@dynamic:field(
                    <<"startTime"/utf8>>,
                    fun gleam@dynamic:float/1
                ))(Value__),
                fun(Start_time) ->
                    gleam@result:'try'(
                        (gleam@dynamic:field(
                            <<"endTime"/utf8>>,
                            fun gleam@dynamic:float/1
                        ))(Value__),
                        fun(End_time) ->
                            gleam@result:'try'(
                                (gleam@dynamic:optional_field(
                                    <<"samples"/utf8>>,
                                    gleam@dynamic:list(fun gleam@dynamic:int/1)
                                ))(Value__),
                                fun(Samples) ->
                                    gleam@result:'try'(
                                        (gleam@dynamic:optional_field(
                                            <<"timeDeltas"/utf8>>,
                                            gleam@dynamic:list(
                                                fun gleam@dynamic:int/1
                                            )
                                        ))(Value__),
                                        fun(Time_deltas) ->
                                            {ok,
                                                {profile,
                                                    Nodes,
                                                    Start_time,
                                                    End_time,
                                                    Samples,
                                                    Time_deltas}}
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-spec encode__coverage_range(coverage_range()) -> gleam@json:json().
encode__coverage_range(Value__) ->
    gleam@json:object(
        [{<<"startOffset"/utf8>>, gleam@json:int(erlang:element(2, Value__))},
            {<<"endOffset"/utf8>>, gleam@json:int(erlang:element(3, Value__))},
            {<<"count"/utf8>>, gleam@json:int(erlang:element(4, Value__))}]
    ).

-spec decode__coverage_range(gleam@dynamic:dynamic_()) -> {ok, coverage_range()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__coverage_range(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:field(<<"startOffset"/utf8>>, fun gleam@dynamic:int/1))(
            Value__
        ),
        fun(Start_offset) ->
            gleam@result:'try'(
                (gleam@dynamic:field(
                    <<"endOffset"/utf8>>,
                    fun gleam@dynamic:int/1
                ))(Value__),
                fun(End_offset) ->
                    gleam@result:'try'(
                        (gleam@dynamic:field(
                            <<"count"/utf8>>,
                            fun gleam@dynamic:int/1
                        ))(Value__),
                        fun(Count) ->
                            {ok,
                                {coverage_range,
                                    Start_offset,
                                    End_offset,
                                    Count}}
                        end
                    )
                end
            )
        end
    ).

-spec encode__function_coverage(function_coverage()) -> gleam@json:json().
encode__function_coverage(Value__) ->
    gleam@json:object(
        [{<<"functionName"/utf8>>,
                gleam@json:string(erlang:element(2, Value__))},
            {<<"ranges"/utf8>>,
                gleam@json:array(
                    erlang:element(3, Value__),
                    fun encode__coverage_range/1
                )},
            {<<"isBlockCoverage"/utf8>>,
                gleam@json:bool(erlang:element(4, Value__))}]
    ).

-spec decode__function_coverage(gleam@dynamic:dynamic_()) -> {ok,
        function_coverage()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__function_coverage(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:field(
            <<"functionName"/utf8>>,
            fun gleam@dynamic:string/1
        ))(Value__),
        fun(Function_name) ->
            gleam@result:'try'(
                (gleam@dynamic:field(
                    <<"ranges"/utf8>>,
                    gleam@dynamic:list(fun decode__coverage_range/1)
                ))(Value__),
                fun(Ranges) ->
                    gleam@result:'try'(
                        (gleam@dynamic:field(
                            <<"isBlockCoverage"/utf8>>,
                            fun gleam@dynamic:bool/1
                        ))(Value__),
                        fun(Is_block_coverage) ->
                            {ok,
                                {function_coverage,
                                    Function_name,
                                    Ranges,
                                    Is_block_coverage}}
                        end
                    )
                end
            )
        end
    ).

-spec encode__script_coverage(script_coverage()) -> gleam@json:json().
encode__script_coverage(Value__) ->
    gleam@json:object(
        [{<<"scriptId"/utf8>>,
                protocol@runtime:encode__script_id(erlang:element(2, Value__))},
            {<<"url"/utf8>>, gleam@json:string(erlang:element(3, Value__))},
            {<<"functions"/utf8>>,
                gleam@json:array(
                    erlang:element(4, Value__),
                    fun encode__function_coverage/1
                )}]
    ).

-spec decode__script_coverage(gleam@dynamic:dynamic_()) -> {ok,
        script_coverage()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__script_coverage(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:field(
            <<"scriptId"/utf8>>,
            fun protocol@runtime:decode__script_id/1
        ))(Value__),
        fun(Script_id) ->
            gleam@result:'try'(
                (gleam@dynamic:field(<<"url"/utf8>>, fun gleam@dynamic:string/1))(
                    Value__
                ),
                fun(Url) ->
                    gleam@result:'try'(
                        (gleam@dynamic:field(
                            <<"functions"/utf8>>,
                            gleam@dynamic:list(fun decode__function_coverage/1)
                        ))(Value__),
                        fun(Functions) ->
                            {ok, {script_coverage, Script_id, Url, Functions}}
                        end
                    )
                end
            )
        end
    ).

-spec decode__get_best_effort_coverage_response(gleam@dynamic:dynamic_()) -> {ok,
        get_best_effort_coverage_response()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__get_best_effort_coverage_response(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:field(
            <<"result"/utf8>>,
            gleam@dynamic:list(fun decode__script_coverage/1)
        ))(Value__),
        fun(Result) -> {ok, {get_best_effort_coverage_response, Result}} end
    ).

-spec decode__start_precise_coverage_response(gleam@dynamic:dynamic_()) -> {ok,
        start_precise_coverage_response()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__start_precise_coverage_response(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:field(<<"timestamp"/utf8>>, fun gleam@dynamic:float/1))(
            Value__
        ),
        fun(Timestamp) -> {ok, {start_precise_coverage_response, Timestamp}} end
    ).

-spec decode__stop_response(gleam@dynamic:dynamic_()) -> {ok, stop_response()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__stop_response(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:field(<<"profile"/utf8>>, fun decode__profile/1))(
            Value__
        ),
        fun(Profile) -> {ok, {stop_response, Profile}} end
    ).

-spec decode__take_precise_coverage_response(gleam@dynamic:dynamic_()) -> {ok,
        take_precise_coverage_response()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__take_precise_coverage_response(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:field(
            <<"result"/utf8>>,
            gleam@dynamic:list(fun decode__script_coverage/1)
        ))(Value__),
        fun(Result) ->
            gleam@result:'try'(
                (gleam@dynamic:field(
                    <<"timestamp"/utf8>>,
                    fun gleam@dynamic:float/1
                ))(Value__),
                fun(Timestamp) ->
                    {ok, {take_precise_coverage_response, Result, Timestamp}}
                end
            )
        end
    ).

-spec disable(fun((binary(), gleam@option:option(any())) -> AGEK)) -> AGEK.
disable(Callback__) ->
    Callback__(<<"Profiler.disable"/utf8>>, none).

-spec enable(fun((binary(), gleam@option:option(any())) -> AGEO)) -> AGEO.
enable(Callback__) ->
    Callback__(<<"Profiler.enable"/utf8>>, none).

-spec get_best_effort_coverage(
    fun((binary(), gleam@option:option(any())) -> {ok, gleam@dynamic:dynamic_()} |
        {error, chrome:request_error()})
) -> {ok, get_best_effort_coverage_response()} | {error, chrome:request_error()}.
get_best_effort_coverage(Callback__) ->
    gleam@result:'try'(
        Callback__(<<"Profiler.getBestEffortCoverage"/utf8>>, none),
        fun(Result__) ->
            _pipe = decode__get_best_effort_coverage_response(Result__),
            gleam@result:replace_error(_pipe, protocol_error)
        end
    ).

-spec set_sampling_interval(
    fun((binary(), gleam@option:option(gleam@json:json())) -> AGFD),
    integer()
) -> AGFD.
set_sampling_interval(Callback__, Interval) ->
    Callback__(
        <<"Profiler.setSamplingInterval"/utf8>>,
        {some,
            gleam@json:object([{<<"interval"/utf8>>, gleam@json:int(Interval)}])}
    ).

-spec start(fun((binary(), gleam@option:option(any())) -> AGFI)) -> AGFI.
start(Callback__) ->
    Callback__(<<"Profiler.start"/utf8>>, none).

-spec start_precise_coverage(
    fun((binary(), gleam@option:option(gleam@json:json())) -> {ok,
            gleam@dynamic:dynamic_()} |
        {error, chrome:request_error()}),
    gleam@option:option(boolean()),
    gleam@option:option(boolean()),
    gleam@option:option(boolean())
) -> {ok, start_precise_coverage_response()} | {error, chrome:request_error()}.
start_precise_coverage(
    Callback__,
    Call_count,
    Detailed,
    Allow_triggered_updates
) ->
    gleam@result:'try'(
        Callback__(
            <<"Profiler.startPreciseCoverage"/utf8>>,
            {some,
                gleam@json:object(
                    begin
                        _pipe = [],
                        _pipe@1 = chrobot@internal@utils:add_optional(
                            _pipe,
                            Call_count,
                            fun(Inner_value__) ->
                                {<<"callCount"/utf8>>,
                                    gleam@json:bool(Inner_value__)}
                            end
                        ),
                        _pipe@2 = chrobot@internal@utils:add_optional(
                            _pipe@1,
                            Detailed,
                            fun(Inner_value__@1) ->
                                {<<"detailed"/utf8>>,
                                    gleam@json:bool(Inner_value__@1)}
                            end
                        ),
                        chrobot@internal@utils:add_optional(
                            _pipe@2,
                            Allow_triggered_updates,
                            fun(Inner_value__@2) ->
                                {<<"allowTriggeredUpdates"/utf8>>,
                                    gleam@json:bool(Inner_value__@2)}
                            end
                        )
                    end
                )}
        ),
        fun(Result__) ->
            _pipe@3 = decode__start_precise_coverage_response(Result__),
            gleam@result:replace_error(_pipe@3, protocol_error)
        end
    ).

-spec stop(
    fun((binary(), gleam@option:option(any())) -> {ok, gleam@dynamic:dynamic_()} |
        {error, chrome:request_error()})
) -> {ok, stop_response()} | {error, chrome:request_error()}.
stop(Callback__) ->
    gleam@result:'try'(
        Callback__(<<"Profiler.stop"/utf8>>, none),
        fun(Result__) -> _pipe = decode__stop_response(Result__),
            gleam@result:replace_error(_pipe, protocol_error) end
    ).

-spec stop_precise_coverage(fun((binary(), gleam@option:option(any())) -> AGGP)) -> AGGP.
stop_precise_coverage(Callback__) ->
    Callback__(<<"Profiler.stopPreciseCoverage"/utf8>>, none).

-spec take_precise_coverage(
    fun((binary(), gleam@option:option(any())) -> {ok, gleam@dynamic:dynamic_()} |
        {error, chrome:request_error()})
) -> {ok, take_precise_coverage_response()} | {error, chrome:request_error()}.
take_precise_coverage(Callback__) ->
    gleam@result:'try'(
        Callback__(<<"Profiler.takePreciseCoverage"/utf8>>, none),
        fun(Result__) ->
            _pipe = decode__take_precise_coverage_response(Result__),
            gleam@result:replace_error(_pipe, protocol_error)
        end
    ).