(ns ird.vps
  "EU cloud servers: tiers, SSH keys, instances, one-click apps, volumes,
  snapshots and activity. Hourly prepaid credit billing until destroy.
  Cross-account handover lives in ird.transfers. Every function returns a
  channel (see ird.async)."
  (:require [ird.async :refer [go-try <?]]
            [ird.gate :as gate]
            [ird.transport :as transport]))

(defn list-tiers
  "GET /vps/tiers — VPS tiers."
  [client]
  (transport/request client :get "/vps/tiers"))

(defn list-system-images
  "GET /vps/system-images — Bootable system images."
  [client]
  (transport/request client :get "/vps/system-images"))

(defn list-ssh-keys
  "GET /vps/ssh-keys — List SSH keys."
  [client]
  (transport/request client :get "/vps/ssh-keys"))

(defn add-ssh-key
  "POST /vps/ssh-keys — Add an SSH key.
  BODY is a plain map with :name and :public_key."
  [client body]
  (transport/request client :post "/vps/ssh-keys" {:body body}))

(defn delete-ssh-key
  "DELETE /vps/ssh-keys/{id} — Delete an SSH key."
  [client id]
  (transport/request client :delete ["vps" "ssh-keys" id]))

(defn availability
  "GET /vps/availability — Tier availability."
  [client]
  (transport/request client :get "/vps/availability"))

(defn list-instances
  "GET /vps/instances — List your servers."
  [client]
  (transport/request client :get "/vps/instances"))

(defn create-instance
  "POST /vps/instances — Create a server (202, hourly billing starts).
  BODY keys include :tier_id, :image_ref, :name, :ssh_key_ids, :zone,
  :subdomain, :volume_id, :queue_if_unavailable, :notify_on_outcome,
  :totp_code."
  [client body]
  (transport/request client :post "/vps/instances" {:body body}))

(defn app-catalog
  "GET /vps/apps — One-click app catalog."
  [client]
  (transport/request client :get "/vps/apps"))

(defn list-app-deployments
  "GET /vps/apps/deployments — List your app deployments."
  [client]
  (transport/request client :get "/vps/apps/deployments"))

(defn deploy-app
  "POST /vps/apps/deployments — Deploy an app (202, hourly billing starts).
  BODY keys include :app_id, :tier_id, :name, :ssh_key_ids, :zone,
  :subdomain, :queue_if_unavailable, :notify_on_outcome, :totp_code."
  [client body]
  (transport/request client :post "/vps/apps/deployments" {:body body}))

(defn get-app-deployment
  "GET /vps/apps/deployments/{id} — Get an app deployment."
  [client id]
  (transport/request client :get ["vps" "apps" "deployments" id]))

(defn reveal-app-password
  "POST /vps/apps/deployments/{id}/reveal-password — Reveal an app
  deployment's root password (once)."
  [client id]
  (transport/request client :post ["vps" "apps" "deployments" id "reveal-password"]))

(defn get-instance
  "GET /vps/instances/{id} — Get a server."
  [client id]
  (transport/request client :get ["vps" "instances" id]))

(defn destroy-instance
  "DELETE /vps/instances/{id} — Destroy a server (202; billing stops)."
  [client id]
  (transport/request client :delete ["vps" "instances" id]))

(defn get-metrics
  "GET /vps/instances/{id}/metrics — Server usage metrics.
  Optional QUERY keys include :type, :start, :end, :step."
  ([client id] (get-metrics client id nil))
  ([client id query]
   (transport/request client :get ["vps" "instances" id "metrics"] {:query query})))

(defn set-queue-notify
  "POST /vps/instances/{id}/queue-notify — Toggle the queued-create outcome
  email. BODY is a plain map with :enabled."
  [client id body]
  (transport/request client :post ["vps" "instances" id "queue-notify"] {:body body}))

(defn create-snapshot
  "POST /vps/instances/{id}/images — Snapshot a server (202).
  BODY is a plain map with optional :name."
  ([client id] (create-snapshot client id nil))
  ([client id body]
   (transport/request client :post ["vps" "instances" id "images"] (when body {:body body}))))

(defn restart
  "POST /vps/instances/{id}/restart — Restart a server (graceful, 202)."
  [client id]
  (transport/request client :post ["vps" "instances" id "restart"]))

(defn reset
  "POST /vps/instances/{id}/reset — Force reset a server (hard, 202)."
  [client id]
  (transport/request client :post ["vps" "instances" id "reset"]))

(defn shutdown
  "POST /vps/instances/{id}/shutdown — Shut down a server (graceful, 202)."
  [client id]
  (transport/request client :post ["vps" "instances" id "shutdown"]))

(defn power-off
  "POST /vps/instances/{id}/power-off — Force power off a server (hard, 202)."
  [client id]
  (transport/request client :post ["vps" "instances" id "power-off"]))

(defn power-on
  "POST /vps/instances/{id}/power-on — Power on a stopped server (202)."
  [client id]
  (transport/request client :post ["vps" "instances" id "power-on"]))

(defn set-rdns
  "PUT /vps/instances/{id}/rdns — Set a server's reverse DNS (PTR, 202).
  BODY is a plain map with :hostname and optional :ip."
  [client id body]
  (transport/request client :put ["vps" "instances" id "rdns"] {:body body}))

(defn list-instance-domains
  "GET /vps/instances/{id}/domains — List a server's connected domains."
  [client id]
  (transport/request client :get ["vps" "instances" id "domains"]))

(defn connect-domain
  "POST /vps/instances/{id}/domains — Connect a domain to a server (202).
  BODY requires :zone (the domain name) and :subdomain; optional keys are
  :set_rdns and :totp_code. Subject to the client's domain gate on :zone."
  [client id body]
  (gate/request client "POST /vps/instances/{id}/domains" {:domain (:zone body)}
                :post ["vps" "instances" id "domains"] {:body body}))

(defn- connection-target
  "Gate target for a domain connection: its zone, found in
  `list-instance-domains`. Called only when the client has a gate."
  [client id connection-id]
  (go-try
    {:domain (some #(when (= (str connection-id) (str (:id %))) (:zone_origin %))
                   (:connections (<? (list-instance-domains client id))))}))

(defn disconnect-domain
  "DELETE /vps/instances/{id}/domains/{connection-id} — Disconnect a domain
  from a server. Subject to the client's domain gate on the connection's
  zone (resolved via `list-instance-domains` when a gate is set)."
  [client id connection-id]
  (gate/request client "DELETE /vps/instances/{id}/domains/{connection-id}"
                #(connection-target client id connection-id)
                :delete ["vps" "instances" id "domains" connection-id]))

(defn list-volumes
  "GET /vps/volumes — List your volumes."
  [client]
  (transport/request client :get "/vps/volumes"))

(defn create-volume
  "POST /vps/volumes — Create a volume (202, hourly billing starts).
  BODY is a plain map with :name and :size_gb."
  [client body]
  (transport/request client :post "/vps/volumes" {:body body}))

(defn delete-volume
  "DELETE /vps/volumes/{id} — Delete a volume (202; billing stops)."
  [client id]
  (transport/request client :delete ["vps" "volumes" id]))

(defn list-images
  "GET /vps/images — List your snapshots."
  [client]
  (transport/request client :get "/vps/images"))

(defn delete-image
  "DELETE /vps/images/{id} — Delete a snapshot (202)."
  [client id]
  (transport/request client :delete ["vps" "images" id]))

(defn get-action
  "GET /vps/actions/{id} — Poll a VPS action."
  [client id]
  (transport/request client :get ["vps" "actions" id]))

(defn list-activity
  "GET /vps/activity — Infrastructure activity timeline.
  Optional QUERY keys include :instance_id."
  ([client] (list-activity client nil))
  ([client query]
   (transport/request client :get "/vps/activity" {:query query})))