gleamgen

-module(gleamgen@expression@case_).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([new/1, with_matcher/3, build_expression/1]).
-export_type([case_expression/2]).

-type case_expression(MOQ, MOR) :: {case_expression,
        gleamgen@expression:expression(MOQ),
        list({gleamgen@matcher:matcher(gleamgen@types:unchecked(), gleamgen@types:unchecked()),
            gleamgen@expression:expression(MOR)})}.

-file("/home/weasel/gleam/testing_gleamgen/gleamgen/src/gleamgen/expression/case_.gleam", 16).
-spec new(gleamgen@expression:expression(MOS)) -> case_expression(MOS, any()).
new(Input_expression) ->
    {case_expression, Input_expression, []}.

-file("/home/weasel/gleam/testing_gleamgen/gleamgen/src/gleamgen/expression/case_.gleam", 20).
-spec with_matcher(
    case_expression(MOX, MOY),
    gleamgen@matcher:matcher(MOX, MPB),
    fun((MPB) -> gleamgen@expression:expression(MOY))
) -> case_expression(MOX, MOY).
with_matcher(Old, Matcher, Handler) ->
    {case_expression,
        erlang:element(2, Old),
        [{begin
                    _pipe = Matcher,
                    gleamgen_ffi:identity(_pipe)
                end,
                Handler(gleamgen@matcher:get_output(Matcher))} |
            erlang:element(3, Old)]}.

-file("/home/weasel/gleam/testing_gleamgen/gleamgen/src/gleamgen/expression/case_.gleam", 31).
-spec build_expression(case_expression(any(), MPH)) -> gleamgen@expression:expression(MPH).
build_expression(Case_) ->
    gleamgen@expression:new_case(
        begin
            _pipe = erlang:element(2, Case_),
            gleamgen_ffi:identity(_pipe)
        end,
        begin
            _pipe@1 = erlang:element(3, Case_),
            _pipe@2 = lists:reverse(_pipe@1),
            gleam@list:map(
                _pipe@2,
                fun(C) ->
                    fun(Context) ->
                        Rendered_match = gleamgen@matcher:render(
                            erlang:element(1, C)
                        ),
                        Rendered_response = gleamgen@expression:render(
                            erlang:element(2, C),
                            Context
                        ),
                        _pipe@3 = erlang:element(2, Rendered_match),
                        _pipe@4 = glam@doc:append(
                            _pipe@3,
                            glam@doc:concat(
                                [{break, <<" "/utf8>>, <<""/utf8>>},
                                    glam@doc:from_string(<<"->"/utf8>>),
                                    {break, <<" "/utf8>>, <<""/utf8>>}]
                            )
                        ),
                        _pipe@5 = glam@doc:group(_pipe@4),
                        _pipe@6 = glam@doc:append(
                            _pipe@5,
                            erlang:element(2, Rendered_response)
                        ),
                        {render,
                            _pipe@6,
                            gleamgen@render:merge_details(
                                erlang:element(3, Rendered_match),
                                erlang:element(3, Rendered_response)
                            )}
                    end
                end
            )
        end,
        begin
            _pipe@7 = erlang:element(3, Case_),
            _pipe@8 = gleam@list:first(_pipe@7),
            _pipe@9 = gleam@result:map(
                _pipe@8,
                fun(C@1) ->
                    gleamgen@expression:type_(erlang:element(2, C@1))
                end
            ),
            gleam@result:lazy_unwrap(
                _pipe@9,
                fun() -> gleamgen@types:unchecked() end
            )
        end
    ).