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

-export([encode__dom_breakpoint_type/1, decode__dom_breakpoint_type/1, encode__event_listener/1, decode__event_listener/1, decode__get_event_listeners_response/1, get_event_listeners/4, remove_dom_breakpoint/3, remove_event_listener_breakpoint/2, remove_xhr_breakpoint/2, set_dom_breakpoint/3, set_event_listener_breakpoint/2, set_xhr_breakpoint/2]).
-export_type([dom_breakpoint_type/0, event_listener/0, get_event_listeners_response/0]).

-type dom_breakpoint_type() :: dom_breakpoint_type_subtree_modified |
    dom_breakpoint_type_attribute_modified |
    dom_breakpoint_type_node_removed.

-type event_listener() :: {event_listener,
        binary(),
        boolean(),
        boolean(),
        boolean(),
        protocol@runtime:script_id(),
        integer(),
        integer(),
        gleam@option:option(protocol@runtime:remote_object()),
        gleam@option:option(protocol@runtime:remote_object()),
        gleam@option:option(protocol@dom:backend_node_id())}.

-type get_event_listeners_response() :: {get_event_listeners_response,
        list(event_listener())}.

-spec encode__dom_breakpoint_type(dom_breakpoint_type()) -> gleam@json:json().
encode__dom_breakpoint_type(Value__) ->
    _pipe = case Value__ of
        dom_breakpoint_type_subtree_modified ->
            <<"subtree-modified"/utf8>>;

        dom_breakpoint_type_attribute_modified ->
            <<"attribute-modified"/utf8>>;

        dom_breakpoint_type_node_removed ->
            <<"node-removed"/utf8>>
    end,
    gleam@json:string(_pipe).

-spec decode__dom_breakpoint_type(gleam@dynamic:dynamic_()) -> {ok,
        dom_breakpoint_type()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__dom_breakpoint_type(Value__) ->
    case gleam@dynamic:string(Value__) of
        {ok, <<"subtree-modified"/utf8>>} ->
            {ok, dom_breakpoint_type_subtree_modified};

        {ok, <<"attribute-modified"/utf8>>} ->
            {ok, dom_breakpoint_type_attribute_modified};

        {ok, <<"node-removed"/utf8>>} ->
            {ok, dom_breakpoint_type_node_removed};

        {error, Error} ->
            {error, Error};

        {ok, Other} ->
            {error,
                [{decode_error,
                        <<"valid enum property"/utf8>>,
                        Other,
                        [<<"enum decoder"/utf8>>]}]}
    end.

-spec encode__event_listener(event_listener()) -> gleam@json:json().
encode__event_listener(Value__) ->
    gleam@json:object(
        begin
            _pipe = [{<<"type"/utf8>>,
                    gleam@json:string(erlang:element(2, Value__))},
                {<<"useCapture"/utf8>>,
                    gleam@json:bool(erlang:element(3, Value__))},
                {<<"passive"/utf8>>,
                    gleam@json:bool(erlang:element(4, Value__))},
                {<<"once"/utf8>>, gleam@json:bool(erlang:element(5, Value__))},
                {<<"scriptId"/utf8>>,
                    protocol@runtime:encode__script_id(
                        erlang:element(6, Value__)
                    )},
                {<<"lineNumber"/utf8>>,
                    gleam@json:int(erlang:element(7, Value__))},
                {<<"columnNumber"/utf8>>,
                    gleam@json:int(erlang:element(8, Value__))}],
            _pipe@1 = chrobot@internal@utils:add_optional(
                _pipe,
                erlang:element(9, Value__),
                fun(Inner_value__) ->
                    {<<"handler"/utf8>>,
                        protocol@runtime:encode__remote_object(Inner_value__)}
                end
            ),
            _pipe@2 = chrobot@internal@utils:add_optional(
                _pipe@1,
                erlang:element(10, Value__),
                fun(Inner_value__@1) ->
                    {<<"originalHandler"/utf8>>,
                        protocol@runtime:encode__remote_object(Inner_value__@1)}
                end
            ),
            chrobot@internal@utils:add_optional(
                _pipe@2,
                erlang:element(11, Value__),
                fun(Inner_value__@2) ->
                    {<<"backendNodeId"/utf8>>,
                        protocol@dom:encode__backend_node_id(Inner_value__@2)}
                end
            )
        end
    ).

-spec decode__event_listener(gleam@dynamic:dynamic_()) -> {ok, event_listener()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__event_listener(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:field(<<"type"/utf8>>, fun gleam@dynamic:string/1))(
            Value__
        ),
        fun(Type_) ->
            gleam@result:'try'(
                (gleam@dynamic:field(
                    <<"useCapture"/utf8>>,
                    fun gleam@dynamic:bool/1
                ))(Value__),
                fun(Use_capture) ->
                    gleam@result:'try'(
                        (gleam@dynamic:field(
                            <<"passive"/utf8>>,
                            fun gleam@dynamic:bool/1
                        ))(Value__),
                        fun(Passive) ->
                            gleam@result:'try'(
                                (gleam@dynamic:field(
                                    <<"once"/utf8>>,
                                    fun gleam@dynamic:bool/1
                                ))(Value__),
                                fun(Once) ->
                                    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(
                                                    <<"lineNumber"/utf8>>,
                                                    fun gleam@dynamic:int/1
                                                ))(Value__),
                                                fun(Line_number) ->
                                                    gleam@result:'try'(
                                                        (gleam@dynamic:field(
                                                            <<"columnNumber"/utf8>>,
                                                            fun gleam@dynamic:int/1
                                                        ))(Value__),
                                                        fun(Column_number) ->
                                                            gleam@result:'try'(
                                                                (gleam@dynamic:optional_field(
                                                                    <<"handler"/utf8>>,
                                                                    fun protocol@runtime:decode__remote_object/1
                                                                ))(Value__),
                                                                fun(Handler) ->
                                                                    gleam@result:'try'(
                                                                        (gleam@dynamic:optional_field(
                                                                            <<"originalHandler"/utf8>>,
                                                                            fun protocol@runtime:decode__remote_object/1
                                                                        ))(
                                                                            Value__
                                                                        ),
                                                                        fun(
                                                                            Original_handler
                                                                        ) ->
                                                                            gleam@result:'try'(
                                                                                (gleam@dynamic:optional_field(
                                                                                    <<"backendNodeId"/utf8>>,
                                                                                    fun protocol@dom:decode__backend_node_id/1
                                                                                ))(
                                                                                    Value__
                                                                                ),
                                                                                fun(
                                                                                    Backend_node_id
                                                                                ) ->
                                                                                    {ok,
                                                                                        {event_listener,
                                                                                            Type_,
                                                                                            Use_capture,
                                                                                            Passive,
                                                                                            Once,
                                                                                            Script_id,
                                                                                            Line_number,
                                                                                            Column_number,
                                                                                            Handler,
                                                                                            Original_handler,
                                                                                            Backend_node_id}}
                                                                                end
                                                                            )
                                                                        end
                                                                    )
                                                                end
                                                            )
                                                        end
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-spec decode__get_event_listeners_response(gleam@dynamic:dynamic_()) -> {ok,
        get_event_listeners_response()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__get_event_listeners_response(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:field(
            <<"listeners"/utf8>>,
            gleam@dynamic:list(fun decode__event_listener/1)
        ))(Value__),
        fun(Listeners) -> {ok, {get_event_listeners_response, Listeners}} end
    ).

-spec get_event_listeners(
    fun((binary(), gleam@option:option(gleam@json:json())) -> {ok,
            gleam@dynamic:dynamic_()} |
        {error, chrome:request_error()}),
    protocol@runtime:remote_object_id(),
    gleam@option:option(integer()),
    gleam@option:option(boolean())
) -> {ok, get_event_listeners_response()} | {error, chrome:request_error()}.
get_event_listeners(Callback__, Object_id, Depth, Pierce) ->
    gleam@result:'try'(
        Callback__(
            <<"DOMDebugger.getEventListeners"/utf8>>,
            {some,
                gleam@json:object(
                    begin
                        _pipe = [{<<"objectId"/utf8>>,
                                protocol@runtime:encode__remote_object_id(
                                    Object_id
                                )}],
                        _pipe@1 = chrobot@internal@utils:add_optional(
                            _pipe,
                            Depth,
                            fun(Inner_value__) ->
                                {<<"depth"/utf8>>,
                                    gleam@json:int(Inner_value__)}
                            end
                        ),
                        chrobot@internal@utils:add_optional(
                            _pipe@1,
                            Pierce,
                            fun(Inner_value__@1) ->
                                {<<"pierce"/utf8>>,
                                    gleam@json:bool(Inner_value__@1)}
                            end
                        )
                    end
                )}
        ),
        fun(Result__) ->
            _pipe@2 = decode__get_event_listeners_response(Result__),
            gleam@result:replace_error(_pipe@2, protocol_error)
        end
    ).

-spec remove_dom_breakpoint(
    fun((binary(), gleam@option:option(gleam@json:json())) -> AARW),
    protocol@dom:node_id(),
    dom_breakpoint_type()
) -> AARW.
remove_dom_breakpoint(Callback__, Node_id, Type_) ->
    Callback__(
        <<"DOMDebugger.removeDOMBreakpoint"/utf8>>,
        {some,
            gleam@json:object(
                [{<<"nodeId"/utf8>>, protocol@dom:encode__node_id(Node_id)},
                    {<<"type"/utf8>>, encode__dom_breakpoint_type(Type_)}]
            )}
    ).

-spec remove_event_listener_breakpoint(
    fun((binary(), gleam@option:option(gleam@json:json())) -> AASB),
    binary()
) -> AASB.
remove_event_listener_breakpoint(Callback__, Event_name) ->
    Callback__(
        <<"DOMDebugger.removeEventListenerBreakpoint"/utf8>>,
        {some,
            gleam@json:object(
                [{<<"eventName"/utf8>>, gleam@json:string(Event_name)}]
            )}
    ).

-spec remove_xhr_breakpoint(
    fun((binary(), gleam@option:option(gleam@json:json())) -> AASG),
    binary()
) -> AASG.
remove_xhr_breakpoint(Callback__, Url) ->
    Callback__(
        <<"DOMDebugger.removeXHRBreakpoint"/utf8>>,
        {some, gleam@json:object([{<<"url"/utf8>>, gleam@json:string(Url)}])}
    ).

-spec set_dom_breakpoint(
    fun((binary(), gleam@option:option(gleam@json:json())) -> AASL),
    protocol@dom:node_id(),
    dom_breakpoint_type()
) -> AASL.
set_dom_breakpoint(Callback__, Node_id, Type_) ->
    Callback__(
        <<"DOMDebugger.setDOMBreakpoint"/utf8>>,
        {some,
            gleam@json:object(
                [{<<"nodeId"/utf8>>, protocol@dom:encode__node_id(Node_id)},
                    {<<"type"/utf8>>, encode__dom_breakpoint_type(Type_)}]
            )}
    ).

-spec set_event_listener_breakpoint(
    fun((binary(), gleam@option:option(gleam@json:json())) -> AASQ),
    binary()
) -> AASQ.
set_event_listener_breakpoint(Callback__, Event_name) ->
    Callback__(
        <<"DOMDebugger.setEventListenerBreakpoint"/utf8>>,
        {some,
            gleam@json:object(
                [{<<"eventName"/utf8>>, gleam@json:string(Event_name)}]
            )}
    ).

-spec set_xhr_breakpoint(
    fun((binary(), gleam@option:option(gleam@json:json())) -> AASV),
    binary()
) -> AASV.
set_xhr_breakpoint(Callback__, Url) ->
    Callback__(
        <<"DOMDebugger.setXHRBreakpoint"/utf8>>,
        {some, gleam@json:object([{<<"url"/utf8>>, gleam@json:string(Url)}])}
    ).