metabase.util.malli.schema

(ns metabase.util.malli.schema
  (:require
   [clojure.string :as str]
   [malli.core :as mc]
   [metabase.legacy-mbql.normalize :as mbql.normalize]
   [metabase.legacy-mbql.schema :as mbql.s]
   [metabase.lib.schema.common :as lib.schema.common]
   [metabase.lib.schema.temporal-bucketing :as lib.schema.temporal-bucketing]
   [metabase.util :as u]
   [metabase.util.date-2 :as u.date]
   [metabase.util.i18n :as i18n :refer [deferred-tru]]
   [metabase.util.json :as json]
   [metabase.util.malli :as mu]
   [metabase.util.malli.registry :as mr]
   [metabase.util.password :as u.password]
   [toucan2.core :as t2]))

(set! *warn-on-reflection* true)

(def ^{:arglists '([model])} InstanceOf
  (memoize
   (fn [model]
     (mu/with-api-error-message
      [:fn
       {:error/message (format "value must be an instance of %s" (name model))}
       #(t2/instance-of? model %)]
      (deferred-tru "value must be an instance of {0}" (name model))))))

(def ^{:arglists '([^Class klass])} InstanceOfClass
  (memoize
   (fn [^Class klass]
     [:fn
      {:error/message (format "Instance of a %s" (.getCanonicalName klass))}
      (partial instance? klass)])))

(def ^{:arglists '([maps-schema k])} maps-with-unique-key
  (memoize
   (fn [maps-schema k]
     (mu/with-api-error-message
      [:and
       [:fn (fn [maps]
              (= (count maps)
                 (-> (map #(get % k) maps)
                     distinct
                     count)))]
       maps-schema]
      (deferred-tru "value must be seq of maps in which {0}s are unique" (name k))))))

(defn enum-keywords-and-strings
  [& keywords]
  (assert (every? keyword? keywords))
  (vec (concat [:enum] keywords (map u/qualified-name keywords))))

(defn enum-decode-keyword
  [keywords]
  (into [:enum {:decode/json keyword}] keywords))

(def NonBlankString
  (mu/with-api-error-message ::lib.schema.common/non-blank-string (deferred-tru "value must be a non-blank string.")))

(def IntGreaterThanOrEqualToZero
  (let [message (deferred-tru "value must be an integer greater or equal to than zero.")]
    [:int
     {:min         0
      :description (str message)
      :error/fn    (fn [_ _]
                     (str message))
      :api/regex   #"\d+"}]))

(def Int
  (let [message (deferred-tru "value must be an integer.")]
    [:int
     {:description (str message)
      :error/fn    (fn [_ _]
                     (str message))
      :api/regex   #"-?\d+"}]))

(def PositiveInt
  (let [message (deferred-tru "value must be an integer greater than zero.")]
    [:int
     {:min         1
      :description (str message)
      :error/fn    (fn [_ _]
                     (str message))
      :api/regex   #"[1-9]\d*"}]))

(def NegativeInt
  (let [message (deferred-tru "value must be a negative integer")]
    [:int
     {:max         -1
      :description (str message)
      :error/fn    (fn [_ _]
                     (str message))
      :api/regex   #"-[1-9]\d*"}]))

(def PositiveNum
  (mu/with-api-error-message
   [:and number? pos?]
   (deferred-tru "value must be a number greater than zero.")))

(def KeywordOrString
  (mu/with-api-error-message
   [:or :string :keyword]
   (deferred-tru "value must be a keyword or string.")))

(def FieldType
  (mu/with-api-error-message
   [:fn #(isa? % :type/*)]
   (deferred-tru "value must be a valid field type.")))

(def FieldSemanticType
  (mu/with-api-error-message
   [:fn #(isa? % :Semantic/*)]
   (deferred-tru "value must be a valid field semantic type.")))

(def FieldRelationType
  (mu/with-api-error-message
   [:fn #(isa? % :Relation/*)]
   (deferred-tru "value must be a valid field relation type.")))

(def FieldSemanticOrRelationType
  (mu/with-api-error-message
   [:fn (fn [k] (or (isa? k :Semantic/*) (isa? k :Relation/*)))]
   (deferred-tru "value must be a valid field semantic or relation type.")))

(def CoercionStrategy
  (mu/with-api-error-message
   [:fn #(isa? % :Coercion/*)]
   (deferred-tru "value must be a valid coercion strategy.")))

(def FieldTypeKeywordOrString
  (mu/with-api-error-message
   [:fn #(isa? (keyword %) :type/*)]
   (deferred-tru "value must be a valid field data type (keyword or string).")))

(def FieldSemanticTypeKeywordOrString
  (mu/with-api-error-message
   [:fn #(isa? (keyword %) :Semantic/*)]
   (deferred-tru "value must be a valid field semantic type (keyword or string).")))

(def FieldRelationTypeKeywordOrString
  (mu/with-api-error-message
   [:fn #(isa? (keyword %) :Relation/*)]
   (deferred-tru "value must be a valid field relation type (keyword or string).")))

(def FieldSemanticOrRelationTypeKeywordOrString
  (mu/with-api-error-message
   [:fn (fn [k]
          (let [k (keyword k)]
            (or (isa? k :Semantic/*)
                (isa? k :Relation/*))))]
   (deferred-tru "value must be a valid field semantic or relation type (keyword or string).")))

(def LegacyFieldOrExpressionReference
  (mu/with-api-error-message
   [:fn (fn [k]
          ((comp (mr/validator mbql.s/Field)
                 mbql.normalize/normalize-tokens) k))]
   (deferred-tru "value must an array with :field id-or-name and an options map")))

(def CoercionStrategyKeywordOrString
  (mu/with-api-error-message
   [:fn #(isa? (keyword %) :Coercion/*)]
   (deferred-tru "value must be a valid coercion strategy (keyword or string).")))

(def EntityTypeKeywordOrString
  (mu/with-api-error-message
   [:fn #(isa? (keyword %) :entity/*)]
   (deferred-tru "value must be a valid entity type (keyword or string).")))

(def Map
  (mu/with-api-error-message
   :map
   (deferred-tru "Value must be a map.")))

(def Email
  (mu/with-api-error-message
   [:and
    :string
    [:fn {:error/message "valid email address"} u/email?]]
   (deferred-tru "value must be a valid email address.")))

(def Url
  (mu/with-api-error-message
   [:fn u/url?]
   (deferred-tru "value must be a valid URL.")))

(def ValidPassword
  (mu/with-api-error-message
   [:and
    :string
    [:fn {:error/message "valid password that is not too common"} (every-pred string? #'u.password/is-valid?)]]
   (deferred-tru "password is too common.")))

(def IntString
  (mu/with-api-error-message
   [:and
    :string
    [:fn #(u/ignore-exceptions (Integer/parseInt %))]]
   (deferred-tru "value must be a valid integer.")))

(def IntStringGreaterThanZero
  (mu/with-api-error-message
   [:and
    :string
    [:fn #(u/ignore-exceptions (< 0 (Integer/parseInt %)))]]
   (deferred-tru "value must be a valid integer greater than zero.")))

(def IntStringGreaterThanOrEqualToZero
  (mu/with-api-error-message
   [:and
    :string
    [:fn #(u/ignore-exceptions (<= 0 (Integer/parseInt %)))]]
   (deferred-tru "value must be a valid integer greater than or equal to zero.")))

(def TemporalString
  (mu/with-api-error-message
   [:and
    :string
    [:fn #(u/ignore-exceptions (boolean (u.date/parse %)))]]
   (deferred-tru "value must be a valid date string")))

(def JSONString
  (mu/with-api-error-message
   [:and
    :string
    [:fn #(try
            (json/decode %)
            true
            (catch Throwable _
              false))]]
   (deferred-tru "value must be a valid JSON string.")))

(def ^:private keyword-or-non-blank-str-malli
  (mc/schema
   [:or {:json-schema {:type "string" :minLength 1}} :keyword NonBlankString]))

(def BooleanValue
  (-> [:enum {:decode/json (fn [b] (contains? #{"true" true} b))
              :json-schema {:type "boolean"}}
       "true" "false" true false]
      (mu/with-api-error-message
       (deferred-tru "value must be a valid boolean string (''true'' or ''false'')."))))

(def MaybeBooleanValue
  (-> [:enum {:decode/json (fn [b] (some->> b (contains? #{"true" true})))
              :json-schema {:type "boolean" :optional true}}
       "true" "false" true false nil]
      (mu/with-api-error-message
       (deferred-tru "value must be a valid boolean string (''true'' or ''false'')."))))

(def ValuesSourceConfig
  ;; TODO: This should be tighter
  (mc/schema
   [:map
    [:values {:optional true} [:* :any]]
    [:card_id {:optional true} PositiveInt]
    [:value_field {:optional true} LegacyFieldOrExpressionReference]
    [:label_field {:optional true} LegacyFieldOrExpressionReference]]))

(def RemappedFieldValue
  [:tuple :any :string])

(def NonRemappedFieldValue
  [:tuple :any])

(def FieldValuesList
  [:sequential [:or RemappedFieldValue NonRemappedFieldValue]])

(def FieldValuesResult
  [:map
   [:has_more_values :boolean]
   [:values FieldValuesList]])

#_(def ParameterSource
    (mc/schema
     [:multi {:dispatch :values_source_type}
      ["card"        [:map
                      [:values_source_type :string]
                      [:values_source_config
                       [:map {:closed true}
                        [:card_id {:optional true} IntGreaterThanZero]
                        [:value_field {:optional true} Field]
                        [:label_field {:optional true} Field]]]]]
      ["static-list" [:map
                      [:values_source_type :string]
                      [:values_source_config
                       [:map {:closed true}
                        [:values {:optional true} [:* :any]]]]]]]))
(def Parameter
  ;; TODO we could use :multi to dispatch values_source_type to the correct values_source_config
  (mu/with-api-error-message
   [:map
    [:id   NonBlankString]
    [:type keyword-or-non-blank-str-malli]
     ;; TODO how to merge this with ParameterSource above?
    [:values_source_type   {:optional true} [:enum "static-list" "card" nil]]
    [:values_source_config {:optional true} ValuesSourceConfig]
    [:slug                 {:optional true} :string]
    [:name                 {:optional true} :string]
    [:default              {:optional true} :any]
    [:sectionId            {:optional true} NonBlankString]
    [:temporal_units       {:optional true} [:sequential ::lib.schema.temporal-bucketing/unit]]]
   (deferred-tru "parameter must be a map with :id and :type keys")))

(def ParameterMapping
  (mu/with-api-error-message
   [:map [:parameter_id NonBlankString]
    [:target :any]
    [:card_id {:optional true} PositiveInt]]
   (deferred-tru "parameter_mapping must be a map with :parameter_id and :target keys")))

(def EmbeddingParams
  (mu/with-api-error-message
   [:maybe [:map-of
            :keyword
            [:enum "disabled" "enabled" "locked"]]]
   (deferred-tru "value must be a valid embedding params map.")))

(def ValidLocale
  (mu/with-api-error-message
   [:and
    NonBlankString
    [:fn
     {:error/message "valid locale"}
     i18n/available-locale?]]
   (deferred-tru "String must be a valid two-letter ISO language or language-country code e.g. ''en'' or ''en_US''.")))

(def NanoIdString
  (mu/with-api-error-message
   [:re #"^[A-Za-z0-9_\-]{21}$"]
   (deferred-tru "String must be a valid 21-character NanoID string.")))

(def UUIDString
  (mu/with-api-error-message
   [:re u/uuid-regex]
   (deferred-tru "value must be a valid UUID.")))

(defn CollectionOf
  [item-schema]
  [:fn
   {:error/message (format "Collection of %s" item-schema)}
   #(and (coll? %) (every? (partial mr/validate item-schema) %))])

(defn QueryVectorOf
  [schema]
  [:vector {:decode/string (fn [x] (cond (vector? x) x x [x]))} schema])

(defn MapWithNoKebabKeys
  []
  [:fn
   {:error/message "Map should not contain any kebab-case keys"}
   (fn [m]
     ;; reduce-kv is more efficient that iterating over (keys m). But we have to extract the underlying map from
     ;; Toucan2 Instance because it doesn't implement IKVReduce (yet).
     (let [m (if (instance? toucan2.instance.Instance m)
               (.m ^toucan2.instance.Instance m)
               m)]
       (reduce-kv (fn [_ k _]
                    (if (str/includes? k "-")
                      (reduced false)
                      true))
                  true m)))])

(def File
  [:map {:closed true}
   [:content-type string?]
   [:filename string?]
   [:size int?]
   [:tempfile (InstanceOfClass java.io.File)]])