-module(galchemy@orm@codec).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src\\galchemy\\orm\\codec.gleam").
-export([custom/2, define/2, codec/1, sql_type_name/1, encode/2, decode/2, nullable/1, value/2, int/0, text/0, float/0, bytea/0, uuid/0, numeric/0, json/0, jsonb/0, bool/0, timestamp/0, date/0, time_of_day/0, array/1, enum_/1, map/3]).
-export_type([codec/1, custom_codec/1, codec_error/0]).

-type codec(LJR) :: {codec,
        fun((LJR) -> galchemy@ast@expression:sql_value()),
        fun((galchemy@ast@expression:sql_value()) -> {ok, LJR} |
            {error, codec_error()})}.

-type custom_codec(LJS) :: {custom_codec, binary(), codec(LJS)}.

-type codec_error() :: {unexpected_type, binary(), binary()} |
    {custom, binary()}.

-file("src\\galchemy\\orm\\codec.gleam", 23).
-spec custom(
    fun((LJT) -> galchemy@ast@expression:sql_value()),
    fun((galchemy@ast@expression:sql_value()) -> {ok, LJT} |
        {error, codec_error()})
) -> codec(LJT).
custom(Encoder, Decoder) ->
    {codec, Encoder, Decoder}.

-file("src\\galchemy\\orm\\codec.gleam", 44).
-spec define(binary(), codec(LKD)) -> custom_codec(LKD).
define(Sql_type_name, Next_codec) ->
    {custom_codec, Sql_type_name, Next_codec}.

-file("src\\galchemy\\orm\\codec.gleam", 48).
-spec codec(custom_codec(LKG)) -> codec(LKG).
codec(Next_custom_codec) ->
    {custom_codec, _, Inner_codec} = Next_custom_codec,
    Inner_codec.

-file("src\\galchemy\\orm\\codec.gleam", 53).
-spec sql_type_name(custom_codec(any())) -> binary().
sql_type_name(Next_custom_codec) ->
    {custom_codec, Inner_name, _} = Next_custom_codec,
    Inner_name.

-file("src\\galchemy\\orm\\codec.gleam", 231).
-spec encode(codec(LLG), LLG) -> galchemy@ast@expression:sql_value().
encode(Next_codec, Value) ->
    {codec, Encoder, _} = Next_codec,
    Encoder(Value).

-file("src\\galchemy\\orm\\codec.gleam", 236).
-spec decode(codec(LLI), galchemy@ast@expression:sql_value()) -> {ok, LLI} |
    {error, codec_error()}.
decode(Next_codec, Value) ->
    {codec, _, Decoder} = Next_codec,
    Decoder(Value).

-file("src\\galchemy\\orm\\codec.gleam", 210).
-spec nullable(codec(LLC)) -> codec(gleam@option:option(LLC)).
nullable(Inner) ->
    {codec, fun(Value) -> case Value of
                {some, Inner_value} ->
                    encode(Inner, Inner_value);

                none ->
                    null
            end end, fun(Value@1) -> case Value@1 of
                null ->
                    {ok, none};

                _ ->
                    case decode(Inner, Value@1) of
                        {ok, Inner_value@1} ->
                            {ok, {some, Inner_value@1}};

                        {error, Error} ->
                            {error, Error}
                    end
            end end}.

-file("src\\galchemy\\orm\\codec.gleam", 244).
-spec value(codec(LLM), LLM) -> galchemy@ast@expression:expression().
value(Next_codec, Inner) ->
    {value_expr, encode(Next_codec, Inner)}.

-file("src\\galchemy\\orm\\codec.gleam", 248).
-spec type_name(galchemy@ast@expression:sql_value()) -> binary().
type_name(Value) ->
    case Value of
        {text, _} ->
            <<"Text"/utf8>>;

        {int, _} ->
            <<"Int"/utf8>>;

        {float, _} ->
            <<"Float"/utf8>>;

        {bool, _} ->
            <<"Bool"/utf8>>;

        {bytea, _} ->
            <<"Bytea"/utf8>>;

        {uuid, _} ->
            <<"Uuid"/utf8>>;

        {numeric, _} ->
            <<"Numeric"/utf8>>;

        {json, _} ->
            <<"Json"/utf8>>;

        {jsonb, _} ->
            <<"Jsonb"/utf8>>;

        {enum, _, _} ->
            <<"Enum"/utf8>>;

        {array, _} ->
            <<"Array"/utf8>>;

        {timestamp, _} ->
            <<"Timestamp"/utf8>>;

        {date, _} ->
            <<"Date"/utf8>>;

        {time_of_day, _} ->
            <<"TimeOfDay"/utf8>>;

        null ->
            <<"Null"/utf8>>
    end.

-file("src\\galchemy\\orm\\codec.gleam", 58).
-spec int() -> codec(integer()).
int() ->
    {codec, fun(Field@0) -> {int, Field@0} end, fun(Value) -> case Value of
                {int, Inner} ->
                    {ok, Inner};

                _ ->
                    {error, {unexpected_type, <<"Int"/utf8>>, type_name(Value)}}
            end end}.

-file("src\\galchemy\\orm\\codec.gleam", 67).
-spec text() -> codec(binary()).
text() ->
    {codec, fun(Field@0) -> {text, Field@0} end, fun(Value) -> case Value of
                {text, Inner} ->
                    {ok, Inner};

                _ ->
                    {error,
                        {unexpected_type, <<"Text"/utf8>>, type_name(Value)}}
            end end}.

-file("src\\galchemy\\orm\\codec.gleam", 76).
-spec float() -> codec(float()).
float() ->
    {codec, fun(Field@0) -> {float, Field@0} end, fun(Value) -> case Value of
                {float, Inner} ->
                    {ok, Inner};

                _ ->
                    {error,
                        {unexpected_type, <<"Float"/utf8>>, type_name(Value)}}
            end end}.

-file("src\\galchemy\\orm\\codec.gleam", 85).
-spec bytea() -> codec(bitstring()).
bytea() ->
    {codec, fun(Field@0) -> {bytea, Field@0} end, fun(Value) -> case Value of
                {bytea, Inner} ->
                    {ok, Inner};

                _ ->
                    {error,
                        {unexpected_type, <<"Bytea"/utf8>>, type_name(Value)}}
            end end}.

-file("src\\galchemy\\orm\\codec.gleam", 94).
-spec uuid() -> codec(binary()).
uuid() ->
    {codec, fun(Field@0) -> {uuid, Field@0} end, fun(Value) -> case Value of
                {uuid, Inner} ->
                    {ok, Inner};

                _ ->
                    {error,
                        {unexpected_type, <<"Uuid"/utf8>>, type_name(Value)}}
            end end}.

-file("src\\galchemy\\orm\\codec.gleam", 103).
-spec numeric() -> codec(binary()).
numeric() ->
    {codec, fun(Field@0) -> {numeric, Field@0} end, fun(Value) -> case Value of
                {numeric, Inner} ->
                    {ok, Inner};

                _ ->
                    {error,
                        {unexpected_type, <<"Numeric"/utf8>>, type_name(Value)}}
            end end}.

-file("src\\galchemy\\orm\\codec.gleam", 112).
-spec json() -> codec(binary()).
json() ->
    {codec, fun(Field@0) -> {json, Field@0} end, fun(Value) -> case Value of
                {json, Inner} ->
                    {ok, Inner};

                _ ->
                    {error,
                        {unexpected_type, <<"Json"/utf8>>, type_name(Value)}}
            end end}.

-file("src\\galchemy\\orm\\codec.gleam", 121).
-spec jsonb() -> codec(binary()).
jsonb() ->
    {codec, fun(Field@0) -> {jsonb, Field@0} end, fun(Value) -> case Value of
                {jsonb, Inner} ->
                    {ok, Inner};

                _ ->
                    {error,
                        {unexpected_type, <<"Jsonb"/utf8>>, type_name(Value)}}
            end end}.

-file("src\\galchemy\\orm\\codec.gleam", 130).
-spec bool() -> codec(boolean()).
bool() ->
    {codec, fun(Field@0) -> {bool, Field@0} end, fun(Value) -> case Value of
                {bool, Inner} ->
                    {ok, Inner};

                _ ->
                    {error,
                        {unexpected_type, <<"Bool"/utf8>>, type_name(Value)}}
            end end}.

-file("src\\galchemy\\orm\\codec.gleam", 139).
-spec timestamp() -> codec(gleam@time@timestamp:timestamp()).
timestamp() ->
    {codec,
        fun(Field@0) -> {timestamp, Field@0} end,
        fun(Value) -> case Value of
                {timestamp, Inner} ->
                    {ok, Inner};

                _ ->
                    {error,
                        {unexpected_type,
                            <<"Timestamp"/utf8>>,
                            type_name(Value)}}
            end end}.

-file("src\\galchemy\\orm\\codec.gleam", 149).
-spec date() -> codec(gleam@time@calendar:date()).
date() ->
    {codec, fun(Field@0) -> {date, Field@0} end, fun(Value) -> case Value of
                {date, Inner} ->
                    {ok, Inner};

                _ ->
                    {error,
                        {unexpected_type, <<"Date"/utf8>>, type_name(Value)}}
            end end}.

-file("src\\galchemy\\orm\\codec.gleam", 158).
-spec time_of_day() -> codec(gleam@time@calendar:time_of_day()).
time_of_day() ->
    {codec,
        fun(Field@0) -> {time_of_day, Field@0} end,
        fun(Value) -> case Value of
                {time_of_day, Inner} ->
                    {ok, Inner};

                _ ->
                    {error,
                        {unexpected_type,
                            <<"TimeOfDay"/utf8>>,
                            type_name(Value)}}
            end end}.

-file("src\\galchemy\\orm\\codec.gleam", 168).
-spec array(codec(LKX)) -> codec(list(LKX)).
array(Inner) ->
    {codec,
        fun(Values) ->
            {array,
                gleam@list:map(Values, fun(Value) -> encode(Inner, Value) end)}
        end,
        fun(Value@1) -> case Value@1 of
                {array, Values@1} ->
                    gleam@list:try_map(
                        Values@1,
                        fun(Item) -> decode(Inner, Item) end
                    );

                _ ->
                    {error,
                        {unexpected_type, <<"Array"/utf8>>, type_name(Value@1)}}
            end end}.

-file("src\\galchemy\\orm\\codec.gleam", 183).
-spec enum_(binary()) -> custom_codec(binary()).
enum_(Enum_type_name) ->
    define(
        Enum_type_name,
        {codec,
            fun(Value) -> {enum, Enum_type_name, Value} end,
            fun(Value@1) -> case Value@1 of
                    {enum, Inner_type, Inner_value} ->
                        case Inner_type =:= Enum_type_name of
                            true ->
                                {ok, Inner_value};

                            false ->
                                {error,
                                    {custom,
                                        <<<<<<"Expected enum type "/utf8,
                                                    Enum_type_name/binary>>/binary,
                                                ", got "/utf8>>/binary,
                                            Inner_type/binary>>}}
                        end;

                    _ ->
                        {error,
                            {unexpected_type,
                                <<"Enum"/utf8>>,
                                type_name(Value@1)}}
                end end}
    ).

-file("src\\galchemy\\orm\\codec.gleam", 268).
-spec result_try(
    {ok, LLO} | {error, LLP},
    fun((LLO) -> {ok, LLS} | {error, LLP})
) -> {ok, LLS} | {error, LLP}.
result_try(Value, Next) ->
    case Value of
        {ok, Inner} ->
            Next(Inner);

        {error, Error} ->
            {error, Error}
    end.

-file("src\\galchemy\\orm\\codec.gleam", 30).
-spec map(
    codec(LJX),
    fun((LJX) -> {ok, LJZ} | {error, codec_error()}),
    fun((LJZ) -> LJX)
) -> codec(LJZ).
map(Base, Decoder_map, Encoder_map) ->
    {codec,
        fun(Value) -> encode(Base, Encoder_map(Value)) end,
        fun(Value@1) ->
            result_try(
                decode(Base, Value@1),
                fun(Decoded) -> Decoder_map(Decoded) end
            )
        end}.