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

-export([encode__request_id/1, decode__request_id/1, encode__request_stage/1, decode__request_stage/1, encode__request_pattern/1, decode__request_pattern/1, encode__header_entry/1, decode__header_entry/1, encode__auth_challenge_source/1, decode__auth_challenge_source/1, encode__auth_challenge/1, decode__auth_challenge/1, encode__auth_challenge_response_response/1, decode__auth_challenge_response_response/1, encode__auth_challenge_response/1, decode__auth_challenge_response/1, decode__get_response_body_response/1, decode__take_response_body_as_stream_response/1, disable/1, enable/3, fail_request/3, fulfill_request/7, continue_request/6, continue_with_auth/3, get_response_body/2, take_response_body_as_stream/2]).
-export_type([request_id/0, request_stage/0, request_pattern/0, header_entry/0, auth_challenge/0, auth_challenge_source/0, auth_challenge_response/0, auth_challenge_response_response/0, get_response_body_response/0, take_response_body_as_stream_response/0]).

-type request_id() :: {request_id, binary()}.

-type request_stage() :: request_stage_request | request_stage_response.

-type request_pattern() :: {request_pattern,
        gleam@option:option(binary()),
        gleam@option:option(protocol@network:resource_type()),
        gleam@option:option(request_stage())}.

-type header_entry() :: {header_entry, binary(), binary()}.

-type auth_challenge() :: {auth_challenge,
        gleam@option:option(auth_challenge_source()),
        binary(),
        binary(),
        binary()}.

-type auth_challenge_source() :: auth_challenge_source_server |
    auth_challenge_source_proxy.

-type auth_challenge_response() :: {auth_challenge_response,
        auth_challenge_response_response(),
        gleam@option:option(binary()),
        gleam@option:option(binary())}.

-type auth_challenge_response_response() :: auth_challenge_response_response_default |
    auth_challenge_response_response_cancel_auth |
    auth_challenge_response_response_provide_credentials.

-type get_response_body_response() :: {get_response_body_response,
        binary(),
        boolean()}.

-type take_response_body_as_stream_response() :: {take_response_body_as_stream_response,
        protocol@io:stream_handle()}.

-spec encode__request_id(request_id()) -> gleam@json:json().
encode__request_id(Value__) ->
    case Value__ of
        {request_id, Inner_value__} ->
            gleam@json:string(Inner_value__)
    end.

-spec decode__request_id(gleam@dynamic:dynamic_()) -> {ok, request_id()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__request_id(Value__) ->
    _pipe = Value__,
    (gleam@dynamic:decode1(
        fun(Field@0) -> {request_id, Field@0} end,
        fun gleam@dynamic:string/1
    ))(_pipe).

-spec encode__request_stage(request_stage()) -> gleam@json:json().
encode__request_stage(Value__) ->
    _pipe = case Value__ of
        request_stage_request ->
            <<"Request"/utf8>>;

        request_stage_response ->
            <<"Response"/utf8>>
    end,
    gleam@json:string(_pipe).

-spec decode__request_stage(gleam@dynamic:dynamic_()) -> {ok, request_stage()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__request_stage(Value__) ->
    case gleam@dynamic:string(Value__) of
        {ok, <<"Request"/utf8>>} ->
            {ok, request_stage_request};

        {ok, <<"Response"/utf8>>} ->
            {ok, request_stage_response};

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

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

-spec encode__request_pattern(request_pattern()) -> gleam@json:json().
encode__request_pattern(Value__) ->
    gleam@json:object(
        begin
            _pipe = [],
            _pipe@1 = chrobot@internal@utils:add_optional(
                _pipe,
                erlang:element(2, Value__),
                fun(Inner_value__) ->
                    {<<"urlPattern"/utf8>>, gleam@json:string(Inner_value__)}
                end
            ),
            _pipe@2 = chrobot@internal@utils:add_optional(
                _pipe@1,
                erlang:element(3, Value__),
                fun(Inner_value__@1) ->
                    {<<"resourceType"/utf8>>,
                        protocol@network:encode__resource_type(Inner_value__@1)}
                end
            ),
            chrobot@internal@utils:add_optional(
                _pipe@2,
                erlang:element(4, Value__),
                fun(Inner_value__@2) ->
                    {<<"requestStage"/utf8>>,
                        encode__request_stage(Inner_value__@2)}
                end
            )
        end
    ).

-spec decode__request_pattern(gleam@dynamic:dynamic_()) -> {ok,
        request_pattern()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__request_pattern(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:optional_field(
            <<"urlPattern"/utf8>>,
            fun gleam@dynamic:string/1
        ))(Value__),
        fun(Url_pattern) ->
            gleam@result:'try'(
                (gleam@dynamic:optional_field(
                    <<"resourceType"/utf8>>,
                    fun protocol@network:decode__resource_type/1
                ))(Value__),
                fun(Resource_type) ->
                    gleam@result:'try'(
                        (gleam@dynamic:optional_field(
                            <<"requestStage"/utf8>>,
                            fun decode__request_stage/1
                        ))(Value__),
                        fun(Request_stage) ->
                            {ok,
                                {request_pattern,
                                    Url_pattern,
                                    Resource_type,
                                    Request_stage}}
                        end
                    )
                end
            )
        end
    ).

-spec encode__header_entry(header_entry()) -> gleam@json:json().
encode__header_entry(Value__) ->
    gleam@json:object(
        [{<<"name"/utf8>>, gleam@json:string(erlang:element(2, Value__))},
            {<<"value"/utf8>>, gleam@json:string(erlang:element(3, Value__))}]
    ).

-spec decode__header_entry(gleam@dynamic:dynamic_()) -> {ok, header_entry()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__header_entry(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:field(<<"name"/utf8>>, fun gleam@dynamic:string/1))(
            Value__
        ),
        fun(Name) ->
            gleam@result:'try'(
                (gleam@dynamic:field(
                    <<"value"/utf8>>,
                    fun gleam@dynamic:string/1
                ))(Value__),
                fun(Value) -> {ok, {header_entry, Name, Value}} end
            )
        end
    ).

-spec encode__auth_challenge_source(auth_challenge_source()) -> gleam@json:json().
encode__auth_challenge_source(Value__) ->
    _pipe = case Value__ of
        auth_challenge_source_server ->
            <<"Server"/utf8>>;

        auth_challenge_source_proxy ->
            <<"Proxy"/utf8>>
    end,
    gleam@json:string(_pipe).

-spec decode__auth_challenge_source(gleam@dynamic:dynamic_()) -> {ok,
        auth_challenge_source()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__auth_challenge_source(Value__) ->
    case gleam@dynamic:string(Value__) of
        {ok, <<"Server"/utf8>>} ->
            {ok, auth_challenge_source_server};

        {ok, <<"Proxy"/utf8>>} ->
            {ok, auth_challenge_source_proxy};

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

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

-spec encode__auth_challenge(auth_challenge()) -> gleam@json:json().
encode__auth_challenge(Value__) ->
    gleam@json:object(
        begin
            _pipe = [{<<"origin"/utf8>>,
                    gleam@json:string(erlang:element(3, Value__))},
                {<<"scheme"/utf8>>,
                    gleam@json:string(erlang:element(4, Value__))},
                {<<"realm"/utf8>>,
                    gleam@json:string(erlang:element(5, Value__))}],
            chrobot@internal@utils:add_optional(
                _pipe,
                erlang:element(2, Value__),
                fun(Inner_value__) ->
                    {<<"source"/utf8>>,
                        encode__auth_challenge_source(Inner_value__)}
                end
            )
        end
    ).

-spec decode__auth_challenge(gleam@dynamic:dynamic_()) -> {ok, auth_challenge()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__auth_challenge(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:optional_field(
            <<"source"/utf8>>,
            fun decode__auth_challenge_source/1
        ))(Value__),
        fun(Source) ->
            gleam@result:'try'(
                (gleam@dynamic:field(
                    <<"origin"/utf8>>,
                    fun gleam@dynamic:string/1
                ))(Value__),
                fun(Origin) ->
                    gleam@result:'try'(
                        (gleam@dynamic:field(
                            <<"scheme"/utf8>>,
                            fun gleam@dynamic:string/1
                        ))(Value__),
                        fun(Scheme) ->
                            gleam@result:'try'(
                                (gleam@dynamic:field(
                                    <<"realm"/utf8>>,
                                    fun gleam@dynamic:string/1
                                ))(Value__),
                                fun(Realm) ->
                                    {ok,
                                        {auth_challenge,
                                            Source,
                                            Origin,
                                            Scheme,
                                            Realm}}
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-spec encode__auth_challenge_response_response(
    auth_challenge_response_response()
) -> gleam@json:json().
encode__auth_challenge_response_response(Value__) ->
    _pipe = case Value__ of
        auth_challenge_response_response_default ->
            <<"Default"/utf8>>;

        auth_challenge_response_response_cancel_auth ->
            <<"CancelAuth"/utf8>>;

        auth_challenge_response_response_provide_credentials ->
            <<"ProvideCredentials"/utf8>>
    end,
    gleam@json:string(_pipe).

-spec decode__auth_challenge_response_response(gleam@dynamic:dynamic_()) -> {ok,
        auth_challenge_response_response()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__auth_challenge_response_response(Value__) ->
    case gleam@dynamic:string(Value__) of
        {ok, <<"Default"/utf8>>} ->
            {ok, auth_challenge_response_response_default};

        {ok, <<"CancelAuth"/utf8>>} ->
            {ok, auth_challenge_response_response_cancel_auth};

        {ok, <<"ProvideCredentials"/utf8>>} ->
            {ok, auth_challenge_response_response_provide_credentials};

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

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

-spec encode__auth_challenge_response(auth_challenge_response()) -> gleam@json:json().
encode__auth_challenge_response(Value__) ->
    gleam@json:object(
        begin
            _pipe = [{<<"response"/utf8>>,
                    encode__auth_challenge_response_response(
                        erlang:element(2, Value__)
                    )}],
            _pipe@1 = chrobot@internal@utils:add_optional(
                _pipe,
                erlang:element(3, Value__),
                fun(Inner_value__) ->
                    {<<"username"/utf8>>, gleam@json:string(Inner_value__)}
                end
            ),
            chrobot@internal@utils:add_optional(
                _pipe@1,
                erlang:element(4, Value__),
                fun(Inner_value__@1) ->
                    {<<"password"/utf8>>, gleam@json:string(Inner_value__@1)}
                end
            )
        end
    ).

-spec decode__auth_challenge_response(gleam@dynamic:dynamic_()) -> {ok,
        auth_challenge_response()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__auth_challenge_response(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:field(
            <<"response"/utf8>>,
            fun decode__auth_challenge_response_response/1
        ))(Value__),
        fun(Response) ->
            gleam@result:'try'(
                (gleam@dynamic:optional_field(
                    <<"username"/utf8>>,
                    fun gleam@dynamic:string/1
                ))(Value__),
                fun(Username) ->
                    gleam@result:'try'(
                        (gleam@dynamic:optional_field(
                            <<"password"/utf8>>,
                            fun gleam@dynamic:string/1
                        ))(Value__),
                        fun(Password) ->
                            {ok,
                                {auth_challenge_response,
                                    Response,
                                    Username,
                                    Password}}
                        end
                    )
                end
            )
        end
    ).

-spec decode__get_response_body_response(gleam@dynamic:dynamic_()) -> {ok,
        get_response_body_response()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__get_response_body_response(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:field(<<"body"/utf8>>, fun gleam@dynamic:string/1))(
            Value__
        ),
        fun(Body) ->
            gleam@result:'try'(
                (gleam@dynamic:field(
                    <<"base64Encoded"/utf8>>,
                    fun gleam@dynamic:bool/1
                ))(Value__),
                fun(Base64_encoded) ->
                    {ok, {get_response_body_response, Body, Base64_encoded}}
                end
            )
        end
    ).

-spec decode__take_response_body_as_stream_response(gleam@dynamic:dynamic_()) -> {ok,
        take_response_body_as_stream_response()} |
    {error, list(gleam@dynamic:decode_error())}.
decode__take_response_body_as_stream_response(Value__) ->
    gleam@result:'try'(
        (gleam@dynamic:field(
            <<"stream"/utf8>>,
            fun protocol@io:decode__stream_handle/1
        ))(Value__),
        fun(Stream) -> {ok, {take_response_body_as_stream_response, Stream}} end
    ).

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

-spec enable(
    fun((binary(), gleam@option:option(gleam@json:json())) -> ABRR),
    gleam@option:option(list(request_pattern())),
    gleam@option:option(boolean())
) -> ABRR.
enable(Callback__, Patterns, Handle_auth_requests) ->
    Callback__(
        <<"Fetch.enable"/utf8>>,
        {some,
            gleam@json:object(
                begin
                    _pipe = [],
                    _pipe@1 = chrobot@internal@utils:add_optional(
                        _pipe,
                        Patterns,
                        fun(Inner_value__) ->
                            {<<"patterns"/utf8>>,
                                gleam@json:array(
                                    Inner_value__,
                                    fun encode__request_pattern/1
                                )}
                        end
                    ),
                    chrobot@internal@utils:add_optional(
                        _pipe@1,
                        Handle_auth_requests,
                        fun(Inner_value__@1) ->
                            {<<"handleAuthRequests"/utf8>>,
                                gleam@json:bool(Inner_value__@1)}
                        end
                    )
                end
            )}
    ).

-spec fail_request(
    fun((binary(), gleam@option:option(gleam@json:json())) -> ABSB),
    request_id(),
    protocol@network:error_reason()
) -> ABSB.
fail_request(Callback__, Request_id, Error_reason) ->
    Callback__(
        <<"Fetch.failRequest"/utf8>>,
        {some,
            gleam@json:object(
                [{<<"requestId"/utf8>>, encode__request_id(Request_id)},
                    {<<"errorReason"/utf8>>,
                        protocol@network:encode__error_reason(Error_reason)}]
            )}
    ).

-spec fulfill_request(
    fun((binary(), gleam@option:option(gleam@json:json())) -> ABSG),
    request_id(),
    integer(),
    gleam@option:option(list(header_entry())),
    gleam@option:option(binary()),
    gleam@option:option(binary()),
    gleam@option:option(binary())
) -> ABSG.
fulfill_request(
    Callback__,
    Request_id,
    Response_code,
    Response_headers,
    Binary_response_headers,
    Body,
    Response_phrase
) ->
    Callback__(
        <<"Fetch.fulfillRequest"/utf8>>,
        {some,
            gleam@json:object(
                begin
                    _pipe = [{<<"requestId"/utf8>>,
                            encode__request_id(Request_id)},
                        {<<"responseCode"/utf8>>, gleam@json:int(Response_code)}],
                    _pipe@1 = chrobot@internal@utils:add_optional(
                        _pipe,
                        Response_headers,
                        fun(Inner_value__) ->
                            {<<"responseHeaders"/utf8>>,
                                gleam@json:array(
                                    Inner_value__,
                                    fun encode__header_entry/1
                                )}
                        end
                    ),
                    _pipe@2 = chrobot@internal@utils:add_optional(
                        _pipe@1,
                        Binary_response_headers,
                        fun(Inner_value__@1) ->
                            {<<"binaryResponseHeaders"/utf8>>,
                                gleam@json:string(Inner_value__@1)}
                        end
                    ),
                    _pipe@3 = chrobot@internal@utils:add_optional(
                        _pipe@2,
                        Body,
                        fun(Inner_value__@2) ->
                            {<<"body"/utf8>>,
                                gleam@json:string(Inner_value__@2)}
                        end
                    ),
                    chrobot@internal@utils:add_optional(
                        _pipe@3,
                        Response_phrase,
                        fun(Inner_value__@3) ->
                            {<<"responsePhrase"/utf8>>,
                                gleam@json:string(Inner_value__@3)}
                        end
                    )
                end
            )}
    ).

-spec continue_request(
    fun((binary(), gleam@option:option(gleam@json:json())) -> ABSU),
    request_id(),
    gleam@option:option(binary()),
    gleam@option:option(binary()),
    gleam@option:option(binary()),
    gleam@option:option(list(header_entry()))
) -> ABSU.
continue_request(Callback__, Request_id, Url, Method, Post_data, Headers) ->
    Callback__(
        <<"Fetch.continueRequest"/utf8>>,
        {some,
            gleam@json:object(
                begin
                    _pipe = [{<<"requestId"/utf8>>,
                            encode__request_id(Request_id)}],
                    _pipe@1 = chrobot@internal@utils:add_optional(
                        _pipe,
                        Url,
                        fun(Inner_value__) ->
                            {<<"url"/utf8>>, gleam@json:string(Inner_value__)}
                        end
                    ),
                    _pipe@2 = chrobot@internal@utils:add_optional(
                        _pipe@1,
                        Method,
                        fun(Inner_value__@1) ->
                            {<<"method"/utf8>>,
                                gleam@json:string(Inner_value__@1)}
                        end
                    ),
                    _pipe@3 = chrobot@internal@utils:add_optional(
                        _pipe@2,
                        Post_data,
                        fun(Inner_value__@2) ->
                            {<<"postData"/utf8>>,
                                gleam@json:string(Inner_value__@2)}
                        end
                    ),
                    chrobot@internal@utils:add_optional(
                        _pipe@3,
                        Headers,
                        fun(Inner_value__@3) ->
                            {<<"headers"/utf8>>,
                                gleam@json:array(
                                    Inner_value__@3,
                                    fun encode__header_entry/1
                                )}
                        end
                    )
                end
            )}
    ).

-spec continue_with_auth(
    fun((binary(), gleam@option:option(gleam@json:json())) -> ABTI),
    request_id(),
    auth_challenge_response()
) -> ABTI.
continue_with_auth(Callback__, Request_id, Auth_challenge_response) ->
    Callback__(
        <<"Fetch.continueWithAuth"/utf8>>,
        {some,
            gleam@json:object(
                [{<<"requestId"/utf8>>, encode__request_id(Request_id)},
                    {<<"authChallengeResponse"/utf8>>,
                        encode__auth_challenge_response(Auth_challenge_response)}]
            )}
    ).

-spec get_response_body(
    fun((binary(), gleam@option:option(gleam@json:json())) -> {ok,
            gleam@dynamic:dynamic_()} |
        {error, chrome:request_error()}),
    request_id()
) -> {ok, get_response_body_response()} | {error, chrome:request_error()}.
get_response_body(Callback__, Request_id) ->
    gleam@result:'try'(
        Callback__(
            <<"Fetch.getResponseBody"/utf8>>,
            {some,
                gleam@json:object(
                    [{<<"requestId"/utf8>>, encode__request_id(Request_id)}]
                )}
        ),
        fun(Result__) -> _pipe = decode__get_response_body_response(Result__),
            gleam@result:replace_error(_pipe, protocol_error) end
    ).

-spec take_response_body_as_stream(
    fun((binary(), gleam@option:option(gleam@json:json())) -> {ok,
            gleam@dynamic:dynamic_()} |
        {error, chrome:request_error()}),
    request_id()
) -> {ok, take_response_body_as_stream_response()} |
    {error, chrome:request_error()}.
take_response_body_as_stream(Callback__, Request_id) ->
    gleam@result:'try'(
        Callback__(
            <<"Fetch.takeResponseBodyAsStream"/utf8>>,
            {some,
                gleam@json:object(
                    [{<<"requestId"/utf8>>, encode__request_id(Request_id)}]
                )}
        ),
        fun(Result__) ->
            _pipe = decode__take_response_body_as_stream_response(Result__),
            gleam@result:replace_error(_pipe, protocol_error)
        end
    ).