batata-consul-client 0.0.2

use std::collections::HashMap;
use std::sync::Arc;

use serde::{Deserialize, Serialize};

use crate::client::HttpClient;
use crate::error::Result;
use crate::types::{AgentService, HealthCheck, WriteMeta};

/// Agent member information
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct AgentMember {
    /// Member name
    pub name: String,
    /// Member address
    pub addr: String,
    /// Member port
    pub port: u16,
    /// Member tags
    #[serde(default)]
    pub tags: HashMap<String, String>,
    /// Member status (alive, leaving, left, failed)
    pub status: i32,
    /// Protocol version (min)
    pub protocol_min: u8,
    /// Protocol version (max)
    pub protocol_max: u8,
    /// Protocol version (current)
    pub protocol_cur: u8,
    /// Delegate version (min)
    pub delegate_min: u8,
    /// Delegate version (max)
    pub delegate_max: u8,
    /// Delegate version (current)
    pub delegate_cur: u8,
}

/// Agent self information
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct AgentSelf {
    /// Configuration
    pub config: HashMap<String, serde_json::Value>,
    /// Coordinator
    #[serde(default)]
    pub coord: Option<serde_json::Value>,
    /// Member information
    pub member: AgentMember,
    /// Statistics
    #[serde(default)]
    pub stats: HashMap<String, HashMap<String, String>>,
    /// Metadata
    #[serde(default)]
    pub meta: HashMap<String, String>,
}

/// Service registration request
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct AgentServiceRegistration {
    /// Service ID (defaults to Name if not provided)
    #[serde(rename = "ID")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    /// Service name
    pub name: String,
    /// Service tags
    #[serde(default)]
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub tags: Vec<String>,
    /// Service port
    #[serde(skip_serializing_if = "Option::is_none")]
    pub port: Option<u16>,
    /// Service address
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address: Option<String>,
    /// Enable tag override
    #[serde(default)]
    pub enable_tag_override: bool,
    /// Service metadata
    #[serde(default)]
    #[serde(skip_serializing_if = "HashMap::is_empty")]
    pub meta: HashMap<String, String>,
    /// Health check
    #[serde(skip_serializing_if = "Option::is_none")]
    pub check: Option<AgentServiceCheck>,
    /// Multiple health checks
    #[serde(default)]
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub checks: Vec<AgentServiceCheck>,
}

impl AgentServiceRegistration {
    pub fn new(name: &str) -> Self {
        Self {
            id: None,
            name: name.to_string(),
            tags: Vec::new(),
            port: None,
            address: None,
            enable_tag_override: false,
            meta: HashMap::new(),
            check: None,
            checks: Vec::new(),
        }
    }

    pub fn with_id(mut self, id: &str) -> Self {
        self.id = Some(id.to_string());
        self
    }

    pub fn with_address(mut self, address: &str) -> Self {
        self.address = Some(address.to_string());
        self
    }

    pub fn with_port(mut self, port: u16) -> Self {
        self.port = Some(port);
        self
    }

    pub fn with_tags(mut self, tags: Vec<String>) -> Self {
        self.tags = tags;
        self
    }

    pub fn with_meta(mut self, key: &str, value: &str) -> Self {
        self.meta.insert(key.to_string(), value.to_string());
        self
    }

    pub fn with_check(mut self, check: AgentServiceCheck) -> Self {
        self.check = Some(check);
        self
    }

    pub fn add_check(mut self, check: AgentServiceCheck) -> Self {
        self.checks.push(check);
        self
    }
}

/// Service health check definition
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct AgentServiceCheck {
    /// Check ID
    #[serde(rename = "CheckID")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub check_id: Option<String>,
    /// Check name
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Script to run (deprecated)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub script: Option<String>,
    /// Args for script
    #[serde(skip_serializing_if = "Option::is_none")]
    pub args: Option<Vec<String>>,
    /// Docker container ID
    #[serde(rename = "DockerContainerID")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub docker_container_id: Option<String>,
    /// Shell for docker exec
    #[serde(skip_serializing_if = "Option::is_none")]
    pub shell: Option<String>,
    /// Interval between checks
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interval: Option<String>,
    /// Timeout for check
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timeout: Option<String>,
    /// TTL for passive checks
    #[serde(rename = "TTL")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ttl: Option<String>,
    /// HTTP endpoint to check
    #[serde(rename = "HTTP")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub http: Option<String>,
    /// HTTP method
    #[serde(skip_serializing_if = "Option::is_none")]
    pub method: Option<String>,
    /// HTTP headers
    #[serde(skip_serializing_if = "Option::is_none")]
    pub header: Option<HashMap<String, Vec<String>>>,
    /// TCP endpoint to check
    #[serde(rename = "TCP")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tcp: Option<String>,
    /// gRPC endpoint to check
    #[serde(rename = "GRPC")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub grpc: Option<String>,
    /// Use TLS for gRPC
    #[serde(rename = "GRPCUseTLS")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub grpc_use_tls: Option<bool>,
    /// Initial status
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    /// Notes about the check
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notes: Option<String>,
    /// Skip TLS verification
    #[serde(rename = "TLSSkipVerify")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tls_skip_verify: Option<bool>,
    /// Deregister after critical for duration
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deregister_critical_service_after: Option<String>,
}

impl AgentServiceCheck {
    /// Create a new HTTP check
    pub fn http(url: &str, interval: &str) -> Self {
        Self {
            check_id: None,
            name: None,
            script: None,
            args: None,
            docker_container_id: None,
            shell: None,
            interval: Some(interval.to_string()),
            timeout: None,
            ttl: None,
            http: Some(url.to_string()),
            method: None,
            header: None,
            tcp: None,
            grpc: None,
            grpc_use_tls: None,
            status: None,
            notes: None,
            tls_skip_verify: None,
            deregister_critical_service_after: None,
        }
    }

    /// Create a new TCP check
    pub fn tcp(address: &str, interval: &str) -> Self {
        Self {
            check_id: None,
            name: None,
            script: None,
            args: None,
            docker_container_id: None,
            shell: None,
            interval: Some(interval.to_string()),
            timeout: None,
            ttl: None,
            http: None,
            method: None,
            header: None,
            tcp: Some(address.to_string()),
            grpc: None,
            grpc_use_tls: None,
            status: None,
            notes: None,
            tls_skip_verify: None,
            deregister_critical_service_after: None,
        }
    }

    /// Create a new TTL check
    pub fn ttl(ttl: &str) -> Self {
        Self {
            check_id: None,
            name: None,
            script: None,
            args: None,
            docker_container_id: None,
            shell: None,
            interval: None,
            timeout: None,
            ttl: Some(ttl.to_string()),
            http: None,
            method: None,
            header: None,
            tcp: None,
            grpc: None,
            grpc_use_tls: None,
            status: None,
            notes: None,
            tls_skip_verify: None,
            deregister_critical_service_after: None,
        }
    }

    /// Create a new gRPC check
    pub fn grpc(address: &str, interval: &str) -> Self {
        Self {
            check_id: None,
            name: None,
            script: None,
            args: None,
            docker_container_id: None,
            shell: None,
            interval: Some(interval.to_string()),
            timeout: None,
            ttl: None,
            http: None,
            method: None,
            header: None,
            tcp: None,
            grpc: Some(address.to_string()),
            grpc_use_tls: None,
            status: None,
            notes: None,
            tls_skip_verify: None,
            deregister_critical_service_after: None,
        }
    }

    pub fn with_name(mut self, name: &str) -> Self {
        self.name = Some(name.to_string());
        self
    }

    pub fn with_timeout(mut self, timeout: &str) -> Self {
        self.timeout = Some(timeout.to_string());
        self
    }

    pub fn with_deregister_after(mut self, duration: &str) -> Self {
        self.deregister_critical_service_after = Some(duration.to_string());
        self
    }
}

/// Check registration request
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct AgentCheckRegistration {
    /// Check ID
    #[serde(rename = "ID")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    /// Check name
    pub name: String,
    /// Notes about the check
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notes: Option<String>,
    /// Service ID this check is for
    #[serde(rename = "ServiceID")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub service_id: Option<String>,
    /// Check definition
    #[serde(flatten)]
    pub check: AgentServiceCheck,
}

/// Agent API client
pub struct Agent {
    client: Arc<HttpClient>,
}

impl Agent {
    /// Create a new Agent client
    pub fn new(client: Arc<HttpClient>) -> Self {
        Self { client }
    }

    /// Get information about the agent
    pub async fn self_info(&self) -> Result<AgentSelf> {
        let builder = self.client.get("/v1/agent/self");
        self.client.execute_json(builder).await
    }

    /// Get the agent's node name
    pub async fn node_name(&self) -> Result<String> {
        let info = self.self_info().await?;
        Ok(info.member.name)
    }

    /// List all services registered with the agent
    pub async fn services(&self) -> Result<HashMap<String, AgentService>> {
        let builder = self.client.get("/v1/agent/services");
        self.client.execute_json(builder).await
    }

    /// Get a single service by ID
    pub async fn service(&self, service_id: &str) -> Result<AgentService> {
        let path = format!("/v1/agent/service/{}", service_id);
        let builder = self.client.get(&path);
        self.client.execute_json(builder).await
    }

    /// List all checks registered with the agent
    pub async fn checks(&self) -> Result<HashMap<String, HealthCheck>> {
        let builder = self.client.get("/v1/agent/checks");
        self.client.execute_json(builder).await
    }

    /// List cluster members
    pub async fn members(&self, wan: bool) -> Result<Vec<AgentMember>> {
        let path = if wan {
            "/v1/agent/members?wan=1"
        } else {
            "/v1/agent/members"
        };
        let builder = self.client.get(path);
        self.client.execute_json(builder).await
    }

    /// Register a service
    pub async fn service_register(&self, registration: &AgentServiceRegistration) -> Result<WriteMeta> {
        let builder = self.client.put("/v1/agent/service/register").json(registration);
        self.client.write_empty(builder).await
    }

    /// Deregister a service
    pub async fn service_deregister(&self, service_id: &str) -> Result<WriteMeta> {
        let path = format!("/v1/agent/service/deregister/{}", service_id);
        let builder = self.client.put(&path);
        self.client.write_empty(builder).await
    }

    /// Register a check
    pub async fn check_register(&self, registration: &AgentCheckRegistration) -> Result<WriteMeta> {
        let builder = self.client.put("/v1/agent/check/register").json(registration);
        self.client.write_empty(builder).await
    }

    /// Deregister a check
    pub async fn check_deregister(&self, check_id: &str) -> Result<WriteMeta> {
        let path = format!("/v1/agent/check/deregister/{}", check_id);
        let builder = self.client.put(&path);
        self.client.write_empty(builder).await
    }

    /// Mark a TTL check as passing
    pub async fn pass_ttl(&self, check_id: &str, note: Option<&str>) -> Result<WriteMeta> {
        let mut path = format!("/v1/agent/check/pass/{}", check_id);
        if let Some(n) = note {
            path.push_str(&format!("?note={}", urlencoding::encode(n)));
        }
        let builder = self.client.put(&path);
        self.client.write_empty(builder).await
    }

    /// Mark a TTL check as warning
    pub async fn warn_ttl(&self, check_id: &str, note: Option<&str>) -> Result<WriteMeta> {
        let mut path = format!("/v1/agent/check/warn/{}", check_id);
        if let Some(n) = note {
            path.push_str(&format!("?note={}", urlencoding::encode(n)));
        }
        let builder = self.client.put(&path);
        self.client.write_empty(builder).await
    }

    /// Mark a TTL check as failing
    pub async fn fail_ttl(&self, check_id: &str, note: Option<&str>) -> Result<WriteMeta> {
        let mut path = format!("/v1/agent/check/fail/{}", check_id);
        if let Some(n) = note {
            path.push_str(&format!("?note={}", urlencoding::encode(n)));
        }
        let builder = self.client.put(&path);
        self.client.write_empty(builder).await
    }

    /// Update a TTL check with custom status
    pub async fn update_ttl(&self, check_id: &str, output: &str, status: &str) -> Result<WriteMeta> {
        let path = format!("/v1/agent/check/update/{}", check_id);
        let body = serde_json::json!({
            "Output": output,
            "Status": status
        });
        let builder = self.client.put(&path).json(&body);
        self.client.write_empty(builder).await
    }

    /// Enable service maintenance mode
    pub async fn enable_service_maintenance(&self, service_id: &str, reason: Option<&str>) -> Result<WriteMeta> {
        let mut path = format!("/v1/agent/service/maintenance/{}?enable=true", service_id);
        if let Some(r) = reason {
            path.push_str(&format!("&reason={}", urlencoding::encode(r)));
        }
        let builder = self.client.put(&path);
        self.client.write_empty(builder).await
    }

    /// Disable service maintenance mode
    pub async fn disable_service_maintenance(&self, service_id: &str) -> Result<WriteMeta> {
        let path = format!("/v1/agent/service/maintenance/{}?enable=false", service_id);
        let builder = self.client.put(&path);
        self.client.write_empty(builder).await
    }

    /// Enable node maintenance mode
    pub async fn enable_node_maintenance(&self, reason: Option<&str>) -> Result<WriteMeta> {
        let mut path = "/v1/agent/maintenance?enable=true".to_string();
        if let Some(r) = reason {
            path.push_str(&format!("&reason={}", urlencoding::encode(r)));
        }
        let builder = self.client.put(&path);
        self.client.write_empty(builder).await
    }

    /// Disable node maintenance mode
    pub async fn disable_node_maintenance(&self) -> Result<WriteMeta> {
        let builder = self.client.put("/v1/agent/maintenance?enable=false");
        self.client.write_empty(builder).await
    }

    /// Force leave a node
    pub async fn force_leave(&self, node: &str) -> Result<WriteMeta> {
        let path = format!("/v1/agent/force-leave/{}", node);
        let builder = self.client.put(&path);
        self.client.write_empty(builder).await
    }

    /// Join a cluster
    pub async fn join(&self, address: &str, wan: bool) -> Result<WriteMeta> {
        let mut path = format!("/v1/agent/join/{}", address);
        if wan {
            path.push_str("?wan=1");
        }
        let builder = self.client.put(&path);
        self.client.write_empty(builder).await
    }

    /// Leave the cluster gracefully
    pub async fn leave(&self) -> Result<WriteMeta> {
        let builder = self.client.put("/v1/agent/leave");
        self.client.write_empty(builder).await
    }
}