(ns clj-k8s.utils
  (:require [clojure.string :as str]))

(defn find-named [x xs]
  (some #(when (= (:name %) x) %) xs))

(defmacro not-found->nil
  [& body]
  `(try
     ~@body
     (catch Throwable t#
       (if (= 404 (-> t# ex-data :status))
         nil
         (throw t#)))))

(defn ->label-selector
  [labels]
  (if (string? labels)
    labels
    (->> labels
         (map (fn [[k v]] (format "%s=%s" (name k) v)))
         (str/join ","))))

(defn- current-condition
  [{:keys [conditions]}]
  (->> conditions
       (filter #(= (:status %) "True"))
       first))

(defn running?
  [{:keys [status]}]
  (boolean (and status (nil? (current-condition status)))))

(defn succeeded?
  [{:keys [status]}]
  (= (:type (current-condition status)) "Complete"))

(defn failed?
  [{:keys [status]}]
  (or (nil? status) (= (:type (current-condition status)) "Failed")))

(ns clj-k8s.models
  (:require [schema.core :as s]))

(s/defschema KubeClientSpec
  {:token s/Str
   :base-url s/Str
   (s/optional-key :namespace) s/Str})

(s/defschema KubeClient
  {:base-url s/Str
   :auths {s/Str s/Str}
   :namespace s/Str})

(ns clj-k8s.gke
  (:import (com.google.auth.oauth2 GoogleCredentials)
           (java.util List)))

(defonce gke-scopes
  ["https://www.googleapis.com/auth/cloud-platform"])

(def ^GoogleCredentials creds
  (delay
    (let [app-creds (GoogleCredentials/getApplicationDefault)]
      (if (.createScopedRequired app-creds)
        (.createScoped app-creds ^List gke-scopes)
        app-creds))))

(defn refresh-goog-token!
  [^GoogleCredentials creds]
  (.refreshIfExpired creds)
  creds)

(def get-google-access-token
  (fn []
    (some-> @creds
            refresh-goog-token!
            .getAccessToken
            .getTokenValue)))

(ns clj-k8s.api
  (:require [yaml.core :as yaml]
            [schema.core :as s]
            [clj-k8s.gke :as gke]
            [clj-k8s.utils :refer [find-named not-found->nil
                                   ->label-selector]]
            [clj-k8s.models :refer :all]
            [clojure.java.io :as io]
            [clojure.string :as str]
            [kubernetes.core :as k]
            [kubernetes.api.version :as kv]
            [kubernetes.api.core-v- :as kc]
            [kubernetes.api.batch-v- :as kb]))

(defonce ^:private default-ns "default")

(defonce ^:private default-k8s-svc-host (System/getenv "KUBERNETES_SERVICE_HOST"))
(defonce ^:private default-k8s-svc-port (System/getenv "KUBERNETES_SERVICE_PORT"))

(defonce ^:private default-cluster-service-account-dir
  (or (System/getenv "GOOGLE_APPLICATION_CREDENTIALS")
      "/var/run/secrets/kubernetes.io/serviceaccount"))

(defonce ^:private token-from-env (str (System/getenv "KUBERNETES_TOKEN")))

(defonce ^:private default-kube-config-path
  (or (System/getenv "KUBECONFIG")
      (str (System/getenv "HOME") "/.kube/config")))

(def running-from-kube?
  (and (.exists (io/file default-cluster-service-account-dir))
       (every? some? [default-k8s-svc-host default-k8s-svc-port])))

(defn- is-current-gke?
  [current-context]
  (str/starts-with? current-context "gke_"))

(defn mk-client
  {:added "1.25.8.2"}
  ([]
   (if (and default-k8s-svc-host default-k8s-svc-port (not-empty token-from-env))
     (s/validate KubeClient
                 {:base-url default-k8s-svc-host
                  :auths     {"BearerToken" (str "Bearer " token-from-env)}
                  :namespace default-ns})
     (mk-client default-kube-config-path)))
  ([kube-config]
   (if (map? kube-config)
     (let [{:keys [base-url token namespace]} (s/validate KubeClientSpec kube-config)]
       (s/validate KubeClient {:base-url base-url
                               :auths     {"BearerToken" (str "Bearer " token)}
                               :namespace (or namespace default-ns)}))
     (mk-client kube-config token-from-env)))
  ([kube-config token]
   (let [{:keys [clusters contexts current-context]}
         (yaml/from-file kube-config)
         context (find-named current-context contexts)
         cluster (find-named (get-in context [:context :cluster]) clusters)
         token (if (is-current-gke? current-context)
                 (gke/get-google-access-token)
                 token)]
     {:base-url  (get-in cluster [:cluster :server])
      :auths     {"BearerToken" (str "Bearer " token)}
      :namespace (get-in context [:context :namespace] default-ns)})))

(defmacro with-api-context
  [api-context & body]
  `(let [api-context# ~api-context
         api-context# (-> k/*api-context*
                          (merge api-context#)
                          (assoc :auths (merge (:auths k/*api-context*) (:auths api-context#))))]
     (binding [k/*api-context* api-context#]
       ~@body)))

(defn active-ns [spec]
  (with-api-context spec
    (:namespace k/*api-context*)))

(defn cluster-version
  {:added "1.25.8.2"}
  ([spec]
   (with-api-context spec
     (kv/get-code-version))))

(defn create-namespace
  {:added "1.25.8.2"}
  ([spec ns-spec] (create-namespace spec ns-spec {}))
  ([spec ns-spec opts]
   (let [ns-spec (if (string? ns-spec)
                   {:metadata {:name ns-spec}} ns-spec)]
     (with-api-context spec
       (kc/create-core-v1-namespace ns-spec opts)))))

(defn get-namespace
  {:added "1.25.8.2"}
  ([spec n] (get-namespace spec n {}))
  ([spec n opts]
   (with-api-context spec
     (not-found->nil
      (kc/read-core-v1-namespace n opts)))))

(defn delete-namespace
  {:added "1.25.8.2"}
  ([spec ns] (delete-namespace spec ns {}))
  ([spec ns opts]
   (with-api-context spec
     (not-found->nil
      (kc/delete-core-v1-namespace ns opts)))))

(defn get-endpoints
  {:added "1.25.8.2"}
  ([spec ns] (get-endpoints spec ns {}))
  ([spec ep-name {:keys [namespace] :or {namespace default-ns} :as opts}]
   (with-api-context spec
     (not-found->nil
      (kc/read-core-v1-namespaced-endpoints ep-name namespace opts)))))

(defn create-endpoint
  {:added "1.25.8.2"}
  ([spec ep-spec] (create-endpoint spec ep-spec {}))
  ([spec ep-spec {:keys [namespace] :or {namespace default-ns} :as opts}]
   (with-api-context spec
     (not-found->nil
      (kc/create-core-v1-namespaced-endpoints ep-spec namespace opts)))))

(defn list-pods
  {:added "1.25.8.2"}
  ([spec] (list-pods spec {}))
  ([spec {:keys [namespace all-namespaces]
          :or {namespace default-ns} :as opts}]
   (with-api-context spec
     (let [opts (update opts :label-selector ->label-selector)]
       (:items
        (if all-namespaces
          (kc/list-core-v1-pod-for-all-namespaces opts)
          (kc/list-core-v1-namespaced-pod namespace opts)))))))

(defn get-pod
  {:added "1.25.8.2"}
  ([spec pod-name] (get-pod spec pod-name {}))
  ([spec pod-name {:keys [namespace] :or {namespace default-ns} :as opts}]
   (with-api-context spec
     (not-found->nil
      (kc/read-core-v1-namespaced-pod pod-name namespace opts)))))

(defn delete-pod
  {:added "1.25.8.2"}
  ([spec pod-name] (get-pod spec pod-name {}))
  ([spec pod-name {:keys [namespace] :or {namespace default-ns} :as opts}]
   (with-api-context spec
     (not-found->nil
      (kc/delete-core-v1-namespaced-pod pod-name namespace opts)))))

(defn pod-logs
  {:added "1.25.8.2"}
  ([spec n] (pod-logs spec n {}))
  ([spec n {:keys [namespace] :or {namespace default-ns} :as opts}]
   (with-api-context spec
     (not-found->nil
      (kc/read-core-v1-namespaced-pod-log n namespace opts)))))

(defn get-job
  {:added "1.25.8.2"}
  ([spec n] (get-job spec n {}))
  ([spec n {:keys [namespace] :or {namespace default-ns} :as opts}]
   (with-api-context spec
     (not-found->nil
      (kb/read-batch-v1-namespaced-job n namespace opts)))))

(defn list-jobs
  {:added "1.25.8.2"}
  ([spec] (list-jobs spec {}))
  ([spec {:keys [namespace all-namespaces] :or {namespace default-ns} :as opts}]
   (with-api-context spec
     (let [opts (update opts :label-selector ->label-selector)]
       (:items
        (if all-namespaces
          (kb/list-batch-v1-job-for-all-namespaces opts)
          (kb/list-batch-v1-namespaced-job namespace opts)))))))

(defn submit-job
  {:added "1.25.8.2"}
  ([spec job-spec] (submit-job spec job-spec {}))
  ([spec job-spec opts]
   (with-api-context spec
     (let [job-ns (get-in job-spec [:metadata :namespace] default-ns)]
       (kb/create-batch-v1-namespaced-job job-ns job-spec opts)))))

(defn delete-job
  {:added "1.25.8.2"}
  ([spec n] (delete-job spec n {}))
  ([spec n {:keys [namespace] :or {namespace default-ns} :as opts}]
   (with-api-context spec
     (let [opts (merge {:propagation-policy "Foreground"} opts)]
       (kb/delete-batch-v1-namespaced-job n namespace opts)))))

(defn job-pods
  {:added "1.25.8.2"}
  ([spec n] (job-pods spec n {}))
  ([spec n opts]
   (with-api-context spec
     (if-let [job (get-job spec n opts)]
       (->> (get-in job [:spec :selector :matchLabels :controller-uid])
            (str "controller-uid=")
            (assoc opts :label-selector)
            (kc/list-core-v1-namespaced-pod (get-in job [:metadata :namespace]))
            :items)
       []))))