// Local extensions to kube.upstream.libsonnet.

local kube = import "kube.upstream.libsonnet";

kube {
    ClusterIssuer(name): kube._Object("certmanager.k8s.io/v1alpha1", "ClusterIssuer", name) {
        spec: error "spec must be defined",
    },
    Issuer(name): kube._Object("certmanager.k8s.io/v1alpha1", "Issuer", name) {
        spec: error "spec must be defined",
    },
    Certificate(name): kube._Object("certmanager.k8s.io/v1alpha1", "Certificate", name) {
        spec: error "spec must be defined",
    },
    # For use in PodSpec.volumes_
    CertificateVolume(certificate): {
        secret: { secretName: certificate.spec.secretName },
    },

    # Add .Contain method to Namespaces, allowing for easy marking of particular
    # kube objects as contained in that namespace.
    Namespace(name): kube.Namespace(name) {
        Contain(o):: o {
            metadata+: {
                namespace: name,
            },
        },
    },

    CephObjectStoreUser(name): kube._Object("ceph.rook.io/v1", "CephObjectStoreUser", name) {
        local user = self,
        spec: error "spec must be defined",

        // Name of the secret that contains the login data for this user.
        // This secret is created in the same namespace as the ceph cluster, so
        // unfortunately you can't really refer to it directly.
        // We should write some automation to copy these secrets over in a
        // secure way.
        secret_name:: "rook-ceph-object-user-%s-%s" % [user.spec.store, user.spec.displayName],
    },

    // Make OpenAPI v3 schema specification less painful.
    OpenAPI:: {
        Validation(obj):: {
            openAPIV3Schema: obj.render,
        },

        Required(inner):: inner {
            required:: true,
        },

        Dict:: {
            local dict = self,
            required:: false,

            local requiredList = [
                k for k in std.filter(function(k) dict[k].required, std.objectFields(dict))
            ],

            render:: {
                properties: {
                    [k]: dict[k].render
                    for k in std.objectFields(dict)
                },
            } + (if std.length(requiredList) > 0 then {
                required: requiredList,
            } else {}),
        },

        Array(items):: {
            required:: false,
            render:: {
                type: "array",
                items: items.render,
            },
        },

        Integer:: {
            local integer = self,
            required:: false,
            render:: {
                type: "integer",
            } + (if integer.minimum != null then {
                minimum: integer.minimum,
            } else {}) + (if integer.maximum != null then {
                maximum: integer.maximum,
            } else {}),

            minimum:: null,
            maximum:: null,
        },

        String:: {
            local string = self,
            required:: false,
            render:: {
                type: "string",
            } + (if string.pattern != null then {
                pattern: string.pattern,
            } else {}),

            pattern:: null,
        },

        Boolean:: {
            required:: false,
            render:: {
                type: "boolean",
            },
        },

        Any:: {
            required:: false,
            render:: {},
        },
    },
}