-module(gleam@uri).
-compile(no_auto_import).

-export([erl_parse/1, parse/1, parse_query/1, query_to_string/1, path_segments/1, to_string/1]).

erl_parse(A) ->
    uri_string:parse(A).

parse(String) ->
    case gleam@result:nil_error(gleam@dynamic:map(uri_string:parse(String))) of
        {error, GleamTryError} -> {error, GleamTryError};
        {ok, UriMap} ->
            Get = fun(K, DecodeType) ->
                gleam@option:from_result(
                    gleam@result:then(
                        gleam@map:get(UriMap, gleam@dynamic:from(K)),
                        gleam@function:compose(
                            DecodeType,
                            fun gleam@result:nil_error/1
                        )
                    )
                )
            end,
            Uri = {uri,
                   Get(scheme, fun gleam@dynamic:string/1),
                   Get(userinfo, fun gleam@dynamic:string/1),
                   Get(host, fun gleam@dynamic:string/1),
                   Get(port, fun gleam@dynamic:int/1),
                   gleam@option:unwrap(
                       Get(path, fun gleam@dynamic:string/1),
                       <<""/utf8>>
                   ),
                   Get(query, fun gleam@dynamic:string/1),
                   Get(fragment, fun gleam@dynamic:string/1)},
            {ok, Uri}
    end.

parse_query(Query) ->
    gleam@result:map_error(
        gleam@dynamic:list(
            uri_string:dissect_query(Query),
            fun(GleamCaptureVariable) ->
                gleam@dynamic:tuple2_of(
                    GleamCaptureVariable,
                    fun gleam@dynamic:string/1,
                    fun gleam@dynamic:string/1
                )
            end
        ),
        fun(_) -> nil end
    ).

query_to_string(Query) ->
    gleam@result:unwrap(
        gleam@dynamic:string(
            uri_string:compose_query(Query, [{encoding, utf8}])
        ),
        <<""/utf8>>
    ).

do_path_segments(Input, Accumulator) ->
    case Input of
        [] ->
            gleam@list:reverse(Accumulator);

        [Segment | Rest] ->
            Accumulator5 = case {Segment, Accumulator} of
                {<<""/utf8>>, Accumulator1} ->
                    Accumulator1;

                {<<"."/utf8>>, Accumulator2} ->
                    Accumulator2;

                {<<".."/utf8>>, []} ->
                    [];

                {<<".."/utf8>>, [_ | Accumulator3]} ->
                    Accumulator3;

                {Segment1, Accumulator4} ->
                    [Segment1 | Accumulator4]
            end,
            do_path_segments(Rest, Accumulator5)
    end.

path_segments(Path) ->
    do_path_segments(gleam@string:split(Path, <<"/"/utf8>>), []).

to_string(Uri) ->
    Field = fun(Key, Value) ->
        gleam@result:map(
            gleam@option:to_result(Value, nil),
            fun(Value1) -> {Key, gleam@dynamic:from(Value1)} end
        )
    end,
    gleam@result:unwrap(
        gleam@dynamic:string(
            uri_string:recompose(
                gleam@map:from_list(
                    gleam@list:filter_map(
                        [Field(scheme, erlang:element(2, Uri)),
                         Field(userinfo, erlang:element(3, Uri)),
                         Field(host, erlang:element(4, Uri)),
                         Field(port, erlang:element(5, Uri)),
                         Field(path, {some, erlang:element(6, Uri)}),
                         Field(query, erlang:element(7, Uri)),
                         Field(fragment, erlang:element(8, Uri))],
                        fun(X) -> X end
                    )
                )
            )
        ),
        <<""/utf8>>
    ).