-module(json@blueprint@schema).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([new_schema/1, type_constraint/1, string_constraint/4, number_constraint/5, to_json/1, to_json_string/1]).
-export_type([schema/0, schema_definition/0, schema_type/0, string_format/0]).

-type schema() :: {schema,
        schema_definition(),
        gleam@option:option(list(binary())),
        gleam@option:option(binary()),
        gleam@option:option(binary()),
        gleam@option:option(list({binary(), schema_definition()}))}.

-type schema_definition() :: {type, schema_type()} |
    {enum, list(gleam@json:json()), gleam@option:option(schema_type())} |
    {const, gleam@json:json()} |
    {nullable, schema_definition()} |
    {number,
        gleam@option:option(float()),
        gleam@option:option(float()),
        gleam@option:option(float()),
        gleam@option:option(float()),
        gleam@option:option(float())} |
    {string,
        gleam@option:option(integer()),
        gleam@option:option(integer()),
        gleam@option:option(binary()),
        gleam@option:option(string_format())} |
    {array, gleam@option:option(schema_definition())} |
    {detailed_array,
        gleam@option:option(schema_definition()),
        gleam@option:option(list(schema_definition())),
        gleam@option:option(integer()),
        gleam@option:option(integer()),
        gleam@option:option(boolean()),
        gleam@option:option(schema_definition()),
        gleam@option:option(integer()),
        gleam@option:option(integer())} |
    {object,
        list({binary(), schema_definition()}),
        gleam@option:option(boolean()),
        gleam@option:option(list(binary()))} |
    {detailed_object,
        gleam@option:option(list({binary(), schema_definition()})),
        gleam@option:option(list({binary(), schema_definition()})),
        gleam@option:option(schema_definition()),
        gleam@option:option(list(binary())),
        gleam@option:option(schema_definition()),
        gleam@option:option(integer()),
        gleam@option:option(integer())} |
    {all_of, list(schema_definition())} |
    {any_of, list(schema_definition())} |
    {one_of, list(schema_definition())} |
    {'not', schema_definition()} |
    {ref, binary()} |
    true_value |
    false_value.

-type schema_type() :: null |
    boolean_type |
    object_type |
    array_type |
    number_type |
    string_type |
    integer_type |
    {multiple, list(schema_type())}.

-type string_format() :: date_time |
    date |
    time |
    duration |
    email |
    idn_email |
    hostname |
    idn_hostname |
    ipv4 |
    ipv6 |
    uri |
    uri_reference |
    iri |
    iri_reference |
    uri_template |
    json_pointer |
    relative_json_pointer |
    regex.

-file("/code/edgar/gleamplay/src/json/blueprint/schema.gleam", 131).
-spec new_schema(schema_definition()) -> schema().
new_schema(Definition) ->
    {schema, Definition, none, none, none, none}.

-file("/code/edgar/gleamplay/src/json/blueprint/schema.gleam", 142).
-spec type_constraint(schema_type()) -> schema_definition().
type_constraint(Type_) ->
    {type, Type_}.

-file("/code/edgar/gleamplay/src/json/blueprint/schema.gleam", 147).
-spec string_constraint(
    gleam@option:option(integer()),
    gleam@option:option(integer()),
    gleam@option:option(binary()),
    gleam@option:option(string_format())
) -> schema_definition().
string_constraint(Min_length, Max_length, Pattern, Format) ->
    {string, Min_length, Max_length, Pattern, Format}.

-file("/code/edgar/gleamplay/src/json/blueprint/schema.gleam", 162).
-spec number_constraint(
    gleam@option:option(float()),
    gleam@option:option(float()),
    gleam@option:option(float()),
    gleam@option:option(float()),
    gleam@option:option(float())
) -> schema_definition().
number_constraint(
    Minimum,
    Maximum,
    Exclusive_minimum,
    Exclusive_maximum,
    Multiple_of
) ->
    {number,
        Minimum,
        Maximum,
        Exclusive_minimum,
        Exclusive_maximum,
        Multiple_of}.

-file("/code/edgar/gleamplay/src/json/blueprint/schema.gleam", 213).
-spec prepend_option(
    list({binary(), gleam@json:json()}),
    gleam@option:option(FZD),
    binary(),
    fun((FZD) -> gleam@json:json())
) -> list({binary(), gleam@json:json()}).
prepend_option(List, Maybe, Name, To_json) ->
    case Maybe of
        {some, Value} ->
            gleam@list:prepend(List, {Name, To_json(Value)});

        none ->
            List
    end.

-file("/code/edgar/gleamplay/src/json/blueprint/schema.gleam", 372).
-spec schema_type_to_json(schema_type()) -> gleam@json:json().
schema_type_to_json(Type_) ->
    case Type_ of
        null ->
            gleam@json:string(<<"null"/utf8>>);

        boolean_type ->
            gleam@json:string(<<"boolean"/utf8>>);

        object_type ->
            gleam@json:string(<<"object"/utf8>>);

        array_type ->
            gleam@json:string(<<"array"/utf8>>);

        number_type ->
            gleam@json:string(<<"number"/utf8>>);

        string_type ->
            gleam@json:string(<<"string"/utf8>>);

        integer_type ->
            gleam@json:string(<<"integer"/utf8>>);

        {multiple, Types} ->
            gleam@json:array(Types, fun(T) -> schema_type_to_json(T) end)
    end.

-file("/code/edgar/gleamplay/src/json/blueprint/schema.gleam", 386).
-spec string_format_to_string(string_format()) -> binary().
string_format_to_string(Format) ->
    case Format of
        date_time ->
            <<"date-time"/utf8>>;

        date ->
            <<"date"/utf8>>;

        time ->
            <<"time"/utf8>>;

        duration ->
            <<"duration"/utf8>>;

        email ->
            <<"email"/utf8>>;

        idn_email ->
            <<"idn-email"/utf8>>;

        hostname ->
            <<"hostname"/utf8>>;

        idn_hostname ->
            <<"idn-hostname"/utf8>>;

        ipv4 ->
            <<"ipv4"/utf8>>;

        ipv6 ->
            <<"ipv6"/utf8>>;

        uri ->
            <<"uri"/utf8>>;

        uri_reference ->
            <<"uri-reference"/utf8>>;

        iri ->
            <<"iri"/utf8>>;

        iri_reference ->
            <<"iri-reference"/utf8>>;

        uri_template ->
            <<"uri-template"/utf8>>;

        json_pointer ->
            <<"json-pointer"/utf8>>;

        relative_json_pointer ->
            <<"relative-json-pointer"/utf8>>;

        regex ->
            <<"regex"/utf8>>
    end.

-file("/code/edgar/gleamplay/src/json/blueprint/schema.gleam", 228).
-spec schema_definition_to_json_fields(schema_definition()) -> list({binary(),
    gleam@json:json()}).
schema_definition_to_json_fields(Def) ->
    case Def of
        {type, Type_} ->
            [{<<"type"/utf8>>, schema_type_to_json(Type_)}];

        {enum, Values, Schema} ->
            _pipe = [{<<"enum"/utf8>>, gleam@json:preprocessed_array(Values)}],
            prepend_option(
                _pipe,
                Schema,
                <<"type"/utf8>>,
                fun schema_type_to_json/1
            );

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

        {nullable, Schema@1} ->
            schema_definition_to_json_fields(Schema@1);

        {number,
            Minimum,
            Maximum,
            Exclusive_minimum,
            Exclusive_maximum,
            Multiple_of} ->
            _pipe@1 = [],
            _pipe@2 = prepend_option(
                _pipe@1,
                Minimum,
                <<"minimum"/utf8>>,
                fun gleam@json:float/1
            ),
            _pipe@3 = prepend_option(
                _pipe@2,
                Maximum,
                <<"maximum"/utf8>>,
                fun gleam@json:float/1
            ),
            _pipe@4 = prepend_option(
                _pipe@3,
                Exclusive_minimum,
                <<"exclusiveMinimum"/utf8>>,
                fun gleam@json:float/1
            ),
            _pipe@5 = prepend_option(
                _pipe@4,
                Exclusive_maximum,
                <<"exclusiveMaximum"/utf8>>,
                fun gleam@json:float/1
            ),
            prepend_option(
                _pipe@5,
                Multiple_of,
                <<"multipleOf"/utf8>>,
                fun gleam@json:float/1
            );

        {string, Min_length, Max_length, Pattern, Format} ->
            _pipe@6 = [],
            _pipe@7 = prepend_option(
                _pipe@6,
                Min_length,
                <<"minLength"/utf8>>,
                fun gleam@json:int/1
            ),
            _pipe@8 = prepend_option(
                _pipe@7,
                Max_length,
                <<"maxLength"/utf8>>,
                fun gleam@json:int/1
            ),
            _pipe@9 = prepend_option(
                _pipe@8,
                Pattern,
                <<"pattern"/utf8>>,
                fun gleam@json:string/1
            ),
            prepend_option(
                _pipe@9,
                Format,
                <<"format"/utf8>>,
                fun(F) -> gleam@json:string(string_format_to_string(F)) end
            );

        {array, Items} ->
            prepend_option(
                [],
                Items,
                <<"items"/utf8>>,
                fun(Schema@2) -> schema_definition_to_json(Schema@2) end
            );

        {object, Properties, Additional_properties, Required} ->
            _pipe@10 = [{<<"type"/utf8>>, gleam@json:string(<<"object"/utf8>>)},
                {<<"properties"/utf8>>,
                    gleam@json:object(
                        gleam@list:map(
                            Properties,
                            fun(Prop) ->
                                {erlang:element(1, Prop),
                                    schema_definition_to_json(
                                        erlang:element(2, Prop)
                                    )}
                            end
                        )
                    )}],
            _pipe@11 = prepend_option(
                _pipe@10,
                Additional_properties,
                <<"additionalProperties"/utf8>>,
                fun gleam@json:bool/1
            ),
            prepend_option(
                _pipe@11,
                Required,
                <<"required"/utf8>>,
                fun(_capture) ->
                    gleam@json:array(_capture, fun gleam@json:string/1)
                end
            );

        {detailed_array,
            Items@1,
            Prefix_items,
            Min_items,
            Max_items,
            Unique_items,
            Contains,
            Min_contains,
            Max_contains} ->
            _pipe@12 = [],
            _pipe@13 = prepend_option(
                _pipe@12,
                Items@1,
                <<"items"/utf8>>,
                fun(Schema@3) -> schema_definition_to_json(Schema@3) end
            ),
            _pipe@14 = prepend_option(
                _pipe@13,
                Prefix_items,
                <<"prefixItems"/utf8>>,
                fun(Schemas) ->
                    gleam@json:array(Schemas, fun schema_definition_to_json/1)
                end
            ),
            _pipe@15 = prepend_option(
                _pipe@14,
                Min_items,
                <<"minItems"/utf8>>,
                fun gleam@json:int/1
            ),
            _pipe@16 = prepend_option(
                _pipe@15,
                Max_items,
                <<"maxItems"/utf8>>,
                fun gleam@json:int/1
            ),
            _pipe@17 = prepend_option(
                _pipe@16,
                Unique_items,
                <<"uniqueItems"/utf8>>,
                fun gleam@json:bool/1
            ),
            _pipe@18 = prepend_option(
                _pipe@17,
                Contains,
                <<"contains"/utf8>>,
                fun(Schema@4) -> schema_definition_to_json(Schema@4) end
            ),
            _pipe@19 = prepend_option(
                _pipe@18,
                Min_contains,
                <<"minContains"/utf8>>,
                fun gleam@json:int/1
            ),
            prepend_option(
                _pipe@19,
                Max_contains,
                <<"maxContains"/utf8>>,
                fun gleam@json:int/1
            );

        {detailed_object,
            Properties@1,
            Pattern_properties,
            Additional_properties@1,
            Required@1,
            Property_names,
            Min_properties,
            Max_properties} ->
            _pipe@20 = [],
            _pipe@21 = prepend_option(
                _pipe@20,
                Properties@1,
                <<"properties"/utf8>>,
                fun(Props) ->
                    gleam@json:object(
                        gleam@list:map(
                            Props,
                            fun(Prop@1) ->
                                {erlang:element(1, Prop@1),
                                    schema_definition_to_json(
                                        erlang:element(2, Prop@1)
                                    )}
                            end
                        )
                    )
                end
            ),
            _pipe@22 = prepend_option(
                _pipe@21,
                Pattern_properties,
                <<"patternProperties"/utf8>>,
                fun(Patterns) ->
                    gleam@json:object(
                        gleam@list:map(
                            Patterns,
                            fun(Pattern@1) ->
                                {erlang:element(1, Pattern@1),
                                    schema_definition_to_json(
                                        erlang:element(2, Pattern@1)
                                    )}
                            end
                        )
                    )
                end
            ),
            _pipe@23 = prepend_option(
                _pipe@22,
                Additional_properties@1,
                <<"additionalProperties"/utf8>>,
                fun(Schema@5) -> schema_definition_to_json(Schema@5) end
            ),
            _pipe@24 = prepend_option(
                _pipe@23,
                Required@1,
                <<"required"/utf8>>,
                fun(Reqs) -> gleam@json:array(Reqs, fun gleam@json:string/1) end
            ),
            _pipe@25 = prepend_option(
                _pipe@24,
                Property_names,
                <<"propertyNames"/utf8>>,
                fun(Schema@6) -> schema_definition_to_json(Schema@6) end
            ),
            _pipe@26 = prepend_option(
                _pipe@25,
                Min_properties,
                <<"minProperties"/utf8>>,
                fun gleam@json:int/1
            ),
            prepend_option(
                _pipe@26,
                Max_properties,
                <<"maxProperties"/utf8>>,
                fun gleam@json:int/1
            );

        {all_of, Schemas@1} ->
            [{<<"allOf"/utf8>>,
                    gleam@json:array(Schemas@1, fun schema_definition_to_json/1)}];

        {any_of, Schemas@2} ->
            [{<<"anyOf"/utf8>>,
                    gleam@json:array(Schemas@2, fun schema_definition_to_json/1)}];

        {one_of, Schemas@3} ->
            [{<<"oneOf"/utf8>>,
                    gleam@json:array(Schemas@3, fun schema_definition_to_json/1)}];

        {'not', Schema@7} ->
            [{<<"not"/utf8>>, schema_definition_to_json(Schema@7)}];

        {ref, Ref} ->
            [{<<"$ref"/utf8>>, gleam@json:string(Ref)}];

        true_value ->
            [{<<"type"/utf8>>, gleam@json:bool(true)}];

        false_value ->
            [{<<"type"/utf8>>, gleam@json:bool(false)}]
    end.

-file("/code/edgar/gleamplay/src/json/blueprint/schema.gleam", 209).
-spec schema_definition_to_json(schema_definition()) -> gleam@json:json().
schema_definition_to_json(Def) ->
    gleam@json:object(schema_definition_to_json_fields(Def)).

-file("/code/edgar/gleamplay/src/json/blueprint/schema.gleam", 186).
-spec to_json(schema()) -> gleam@json:json().
to_json(Schema) ->
    Fields = begin
        _pipe = [{<<"$schema"/utf8>>,
                gleam@json:string(
                    <<"http://json-schema.org/draft-07/schema#"/utf8>>
                )}],
        _pipe@1 = prepend_option(
            _pipe,
            erlang:element(3, Schema),
            <<"$vocabulary"/utf8>>,
            fun(Vocab) -> gleam@json:array(Vocab, fun gleam@json:string/1) end
        ),
        _pipe@2 = prepend_option(
            _pipe@1,
            erlang:element(4, Schema),
            <<"$id"/utf8>>,
            fun gleam@json:string/1
        ),
        _pipe@3 = prepend_option(
            _pipe@2,
            erlang:element(5, Schema),
            <<"$comment"/utf8>>,
            fun gleam@json:string/1
        ),
        prepend_option(
            _pipe@3,
            erlang:element(6, Schema),
            <<"$defs"/utf8>>,
            fun(Defs) ->
                gleam@json:object(
                    gleam@list:map(
                        Defs,
                        fun(Def) ->
                            {erlang:element(1, Def),
                                schema_definition_to_json(
                                    erlang:element(2, Def)
                                )}
                        end
                    )
                )
            end
        )
    end,
    Schema_fields = schema_definition_to_json_fields(erlang:element(2, Schema)),
    Fields@1 = lists:append(Fields, Schema_fields),
    gleam@json:object(Fields@1).

-file("/code/edgar/gleamplay/src/json/blueprint/schema.gleam", 179).
-spec to_json_string(schema()) -> binary().
to_json_string(Schema) ->
    _pipe = Schema,
    _pipe@1 = to_json(_pipe),
    gleam@json:to_string(_pipe@1).