pify

-module(pify).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/pify.gleam").
-export([client/3, append_path/2, fetch/4, fetch_products/1, fetch_product/2, remove_edges_and_nodes/1, reshape_cart/1, last_split/2, reshape_images/2, reshape_product/2, reshape_products/1]).
-export_type([shopify_result/1]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

-type shopify_result(GLU) :: {shopify_result, integer(), GLU}.

-file("src/pify.gleam", 19).
-spec client(binary(), binary(), gleam@option:option(binary())) -> {ok,
        types:shopify_client()} |
    {error, any()}.
client(Key, Domain, Api_version) ->
    {ok, {shopify_client, Key, Domain, Api_version}}.

-file("src/pify.gleam", 106).
-spec append_path(gleam@http@request:request(GMY), binary()) -> gleam@http@request:request(GMY).
append_path(Request, Path) ->
    gleam@http@request:set_path(
        Request,
        <<(erlang:element(8, Request))/binary, Path/binary>>
    ).

-file("src/pify.gleam", 23).
-spec base(types:shopify_client()) -> gleam@http@request:request(binary()).
base(Client) ->
    Request = begin
        _pipe = gleam@http@request:new(),
        _pipe@1 = gleam@http@request:set_host(_pipe, erlang:element(3, Client)),
        _pipe@2 = append_path(
            _pipe@1,
            <<<<"/api/"/utf8,
                    (gleam@option:unwrap(
                        erlang:element(4, Client),
                        <<"2023-10"/utf8>>
                    ))/binary>>/binary,
                "/graphql.json"/utf8>>
        ),
        _pipe@3 = gleam@http@request:set_method(_pipe@2, post),
        _pipe@4 = gleam@http@request:set_header(
            _pipe@3,
            <<"content-type"/utf8>>,
            <<"application/json"/utf8>>
        ),
        gleam@http@request:set_header(
            _pipe@4,
            <<"X-Shopify-Storefront-Access-Token"/utf8>>,
            erlang:element(2, Client)
        )
    end,
    Request.

-file("src/pify.gleam", 41).
-spec fetch(
    types:shopify_client(),
    binary(),
    gleam@option:option(binary()),
    gleam@dynamic@decode:decoder(GLZ)
) -> {ok, shopify_result(GLZ)} | {error, types:shopify_error()}.
fetch(Client, Query, Variables, Decoder) ->
    Request = begin
        _pipe = base(Client),
        gleam@http@request:set_body(
            _pipe,
            gleam@json:to_string(
                gleam@json:object(
                    [{<<"query"/utf8>>, gleam@json:string(Query)},
                        {<<"variables"/utf8>>, case Variables of
                                none ->
                                    gleam@json:null();

                                {some, Value} ->
                                    gleam@json:string(Value)
                            end}]
                )
            )
        )
    end,
    gleam@result:'try'(
        begin
            _pipe@1 = gleam@httpc:send(Request),
            gleam@result:map_error(
                _pipe@1,
                fun(_) ->
                    {shopify_error,
                        500,
                        begin
                            _pipe@2 = snag:new(<<"HTTP request failed"/utf8>>),
                            snag:line_print(_pipe@2)
                        end}
                end
            )
        end,
        fun(Resp) ->
            gleam@result:'try'(
                begin
                    _pipe@3 = erlang:element(4, Resp),
                    _pipe@4 = gleam@json:parse(_pipe@3, Decoder),
                    gleam@result:map_error(
                        _pipe@4,
                        fun(_) ->
                            {shopify_error,
                                500,
                                <<"JSON decoding failed."/utf8>>}
                        end
                    )
                end,
                fun(Decoded_body) ->
                    {ok,
                        {shopify_result, erlang:element(2, Resp), Decoded_body}}
                end
            )
        end
    ).

-file("src/pify.gleam", 81).
-spec fetch_products(types:shopify_client()) -> {ok,
        shopify_result(types:products())} |
    {error, types:shopify_error()}.
fetch_products(Client) ->
    Query = fragments:product_fragment(),
    fetch(Client, Query, none, types:products_decoder()).

-file("src/pify.gleam", 93).
-spec fetch_product(types:shopify_client(), binary()) -> {ok,
        shopify_result(types:product())} |
    {error, types:shopify_error()}.
fetch_product(Client, Handle) ->
    Query = fragments:product_fragment(),
    fetch(Client, Query, {some, Handle}, types:product_decoder()).

-file("src/pify.gleam", 116).
?DOC(
    " Remove the edges from the array and return the proper type of the connection.\n"
    "\n"
    " Essential to work with GraphQL.\n"
).
-spec remove_edges_and_nodes(types:connection(GMN)) -> list(GMN).
remove_edges_and_nodes(Array) ->
    _pipe = erlang:element(2, Array),
    gleam@list:map(_pipe, fun(Nodes) -> erlang:element(2, Nodes) end).

-file("src/pify.gleam", 139).
-spec reshape_cart(types:shopify_cart()) -> types:cart().
reshape_cart(Cart) ->
    Result = (case erlang:element(4, Cart) of
        none ->
            none;

        {some, Cost} ->
            Lines = remove_edges_and_nodes(erlang:element(5, Cart)),
            {some,
                {cart,
                    erlang:element(2, Cart),
                    erlang:element(3, Cart),
                    {some,
                        {shopify_cart_cost,
                            erlang:element(4, Cost),
                            erlang:element(3, Cost),
                            erlang:element(4, Cost)}},
                    erlang:element(6, Cart),
                    Lines}}
    end),
    Lines@1 = remove_edges_and_nodes(erlang:element(5, Cart)),
    gleam@option:unwrap(
        Result,
        {cart,
            erlang:element(2, Cart),
            erlang:element(3, Cart),
            erlang:element(4, Cart),
            erlang:element(6, Cart),
            Lines@1}
    ).

-file("src/pify.gleam", 250).
?DOC(" AI constructed. Need to verify logic.\n").
-spec last_split(binary(), binary()) -> {ok, {binary(), binary()}} |
    {error, nil}.
last_split(Str, Separator) ->
    Reversed_str = gleam@string:reverse(Str),
    Reversed_separator = gleam@string:reverse(Separator),
    case gleam@string:split_once(Reversed_str, Reversed_separator) of
        {ok, {After_reversed, Before_reversed}} ->
            Before = gleam@string:reverse(Before_reversed),
            After = gleam@string:reverse(After_reversed),
            {ok, {Before, After}};

        {error, _} ->
            {error, nil}
    end.

-file("src/pify.gleam", 236).
?DOC(" AI constructed. Need to verify logic.\n").
-spec get_filename(binary()) -> binary().
get_filename(Url) ->
    Path_segment = case last_split(Url, <<"/"/utf8>>) of
        {ok, {_, After}} ->
            After;

        {error, _} ->
            Url
    end,
    case last_split(Path_segment, <<"."/utf8>>) of
        {ok, {Before, _}} ->
            Before;

        {error, _} ->
            Path_segment
    end.

-file("src/pify.gleam", 121).
-spec reshape_images(types:connection(types:image()), binary()) -> list(types:image()).
reshape_images(Images, Product_title) ->
    Flattened = remove_edges_and_nodes(Images),
    _pipe = Flattened,
    gleam@list:map(
        _pipe,
        fun(Image) ->
            New_alt_text = case erlang:element(3, Image) of
                <<""/utf8>> ->
                    Filename = get_filename(erlang:element(2, Image)),
                    <<<<Product_title/binary, "-"/utf8>>/binary,
                        Filename/binary>>;

                Text ->
                    Text
            end,
            {image,
                erlang:element(2, Image),
                New_alt_text,
                erlang:element(4, Image),
                erlang:element(5, Image)}
        end
    ).

-file("src/pify.gleam", 174).
-spec reshape_product(types:shopify_product(), boolean()) -> types:product().
reshape_product(Product, Filter_hidden_products) ->
    Result = begin
        Is_hidden = gleam@list:contains(
            erlang:element(13, Product),
            <<"gleam-frontend-hidden"/utf8>>
        ),
        case Filter_hidden_products andalso Is_hidden of
            true ->
                none;

            false ->
                Reshaped_image = reshape_images(
                    erlang:element(11, Product),
                    erlang:element(5, Product)
                ),
                Reshaped_variants = remove_edges_and_nodes(
                    erlang:element(9, Product)
                ),
                {some,
                    {product,
                        erlang:element(2, Product),
                        erlang:element(3, Product),
                        erlang:element(4, Product),
                        erlang:element(5, Product),
                        erlang:element(6, Product),
                        erlang:element(7, Product),
                        erlang:element(8, Product),
                        erlang:element(10, Product),
                        erlang:element(12, Product),
                        erlang:element(13, Product),
                        erlang:element(14, Product),
                        Reshaped_variants,
                        Reshaped_image}}
        end
    end,
    Reshaped_image@1 = reshape_images(
        erlang:element(11, Product),
        erlang:element(5, Product)
    ),
    Reshaped_variants@1 = remove_edges_and_nodes(erlang:element(9, Product)),
    gleam@option:unwrap(
        Result,
        {product,
            erlang:element(2, Product),
            erlang:element(3, Product),
            erlang:element(4, Product),
            erlang:element(5, Product),
            erlang:element(6, Product),
            erlang:element(7, Product),
            erlang:element(8, Product),
            erlang:element(10, Product),
            erlang:element(12, Product),
            erlang:element(13, Product),
            erlang:element(14, Product),
            Reshaped_variants@1,
            Reshaped_image@1}
    ).

-file("src/pify.gleam", 225).
-spec reshape_products(list(types:shopify_product())) -> list(types:product()).
reshape_products(Products) ->
    gleam@list:map(Products, fun(Product) -> reshape_product(Product, true) end).