(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."
  (:require
   [ird.gate :as gate]
   [ird.transport :as transport]))

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

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

(defn list-ssh-keys
  "GET /vps/ssh-keys — List SSH keys.
  Returns the parsed response map."
  [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.
  Returns the parsed response map."
  [client body]
  (transport/request client :post "/vps/ssh-keys" {:body body}))

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

(defn availability
  "GET /vps/availability — Tier availability.
  Returns the parsed response map."
  [client]
  (transport/request client :get "/vps/availability"))

(defn list-instances
  "GET /vps/instances — List your servers.
  Returns the parsed response map."
  [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.
  Returns the parsed response map."
  [client body]
  (transport/request client :post "/vps/instances" {:body body}))

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

(defn list-app-deployments
  "GET /vps/apps/deployments — List your app deployments.
  Returns the parsed response map."
  [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.
  Returns the parsed response map."
  [client body]
  (transport/request client :post "/vps/apps/deployments" {:body body}))

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

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

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

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

(defn get-metrics
  "GET /vps/instances/{id}/metrics — Server usage metrics.
  Optional QUERY keys include :type, :start, :end, :step.
  Returns the parsed response map."
  ([client id] (get-metrics client id nil))
  ([client id query]
   (transport/request client :get (str "/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.
  Returns the parsed response map."
  [client id body]
  (transport/request client :post (str "/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.
  Returns the parsed response map."
  ([client id] (create-snapshot client id nil))
  ([client id body]
   (transport/request client :post (str "/vps/instances/" id "/images")
                      (when body {:body body}))))

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

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

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

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

(defn power-on
  "POST /vps/instances/{id}/power-on — Power on a stopped server (202).
  Returns the parsed response map."
  [client id]
  (transport/request client :post (str "/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.
  Returns the parsed response map."
  [client id body]
  (transport/request client :put (str "/vps/instances/" id "/rdns")
                     {:body body}))

(defn list-instance-domains
  "GET /vps/instances/{id}/domains — List a server's connected domains.
  Returns the parsed response map."
  [client id]
  (transport/request client :get (str "/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.
  Returns the parsed response map."
  [client id body]
  (gate/check! client "POST /vps/instances/{id}/domains" {:domain (:zone body)})
  (transport/request client :post (str "/vps/instances/" id "/domains")
                     {:body body}))

(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).
  Returns the parsed response map."
  [client id connection-id]
  (when (:gate client)
    (let [zone (some #(when (= (str connection-id) (str (:id %)))
                        (:zone_origin %))
                     (:connections (list-instance-domains client id)))]
      (gate/check! client "DELETE /vps/instances/{id}/domains/{connection-id}"
                   {:domain zone})))
  (transport/request client :delete
                     (str "/vps/instances/" id "/domains/" connection-id)))

(defn list-volumes
  "GET /vps/volumes — List your volumes.
  Returns the parsed response map."
  [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.
  Returns the parsed response map."
  [client body]
  (transport/request client :post "/vps/volumes" {:body body}))

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

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

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

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

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