vultr 0.4.3

use std::fmt::Display;

use serde::Deserialize;
use uuid::Uuid;

use crate::data::meta::VultrMeta;

#[derive(Deserialize, Debug)]
pub struct VultrFirewallGroupRoot {
    pub firewall_group: VultrFirewallGroup,
}

#[derive(Deserialize, Debug)]
pub struct VultrFirewallGroupsRoot {
    pub firewall_groups: Vec<VultrFirewallGroup>,
    pub meta: VultrMeta,
}

/// A Vultr firewall group that contains inbound and outbound traffic rules.
#[derive(Deserialize, Debug)]
pub struct VultrFirewallGroup {
    id: Uuid,
    description: String,
    date_created: String,
    date_modified: String,
    instance_count: Option<u32>,
    rule_count: Option<u32>,
    max_rule_count: Option<u32>,
}

impl VultrFirewallGroup {
    /// Returns the unique UUID of this firewall group.
    pub fn id(&self) -> Uuid {
        self.id
    }

    /// Returns the human-readable description of this firewall group.
    pub fn description(&self) -> &String {
        &self.description
    }

    /// Returns the ISO 8601 creation date of this firewall group.
    pub fn date_created(&self) -> &String {
        &self.date_created
    }

    /// Returns the ISO 8601 date when this firewall group was last modified.
    pub fn date_modified(&self) -> &String {
        &self.date_modified
    }
}

#[derive(Deserialize, Debug)]
pub struct VultrFirewallGroupRulesRoot {
    pub firewall_rules: Vec<VultrFirewallGroupRule>,
    pub meta: VultrMeta,
}

#[derive(Deserialize, Debug)]
pub struct VultrFirewallGroupRuleRoot {
    pub firewall_rule: VultrFirewallGroupRule,
}

/// A single traffic rule within a Vultr firewall group.
#[derive(Deserialize, Debug)]
pub struct VultrFirewallGroupRule {
    id: u32,
    ip_type: VultrFirewallGroupRuleIpType,
    action: String,
    protocol: VultrFirewallGroupRuleProtocol,
    port: String,
    subnet: String,
    subnet_size: u32,
    source: String,
    notes: String,
}

impl VultrFirewallGroupRule {
    /// Returns the numeric rule ID.
    pub fn id(&self) -> u32 {
        self.id
    }

    /// Returns the IP version this rule applies to.
    pub fn ip_type(&self) -> &VultrFirewallGroupRuleIpType {
        &self.ip_type
    }

    /// Returns the network protocol matched by this rule.
    pub fn protocol(&self) -> &VultrFirewallGroupRuleProtocol {
        &self.protocol
    }

    /// Returns the port or port range (e.g. `"80"` or `"8000:8080"`).
    pub fn port(&self) -> &String {
        &self.port
    }

    /// Returns the source subnet in CIDR notation.
    pub fn subnet(&self) -> &String {
        &self.subnet
    }

    /// Returns the subnet prefix length.
    pub fn subnet_size(&self) -> u32 {
        self.subnet_size
    }

    /// Returns the traffic source identifier, or an empty string for any source.
    pub fn source(&self) -> &String {
        &self.source
    }

    /// Returns the user-supplied notes for this rule.
    pub fn notes(&self) -> &String {
        &self.notes
    }
}

/// IP version for a firewall rule.
#[derive(Deserialize, Debug)]
pub enum VultrFirewallGroupRuleIpType {
    /// IPv4.
    #[serde(rename = "v4")]
    V4,
    /// IPv6.
    #[serde(rename = "v6")]
    V6,
}

impl Display for VultrFirewallGroupRuleIpType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            VultrFirewallGroupRuleIpType::V4 => write!(f, "v4"),
            VultrFirewallGroupRuleIpType::V6 => write!(f, "v6"),
        }
    }
}

/// Network protocol matched by a firewall rule.
#[derive(Deserialize, Debug)]
pub enum VultrFirewallGroupRuleProtocol {
    /// Internet Control Message Protocol.
    #[serde(rename = "icmp")]
    ICMP,
    /// Transmission Control Protocol.
    #[serde(rename = "tcp")]
    TCP,
    /// User Datagram Protocol.
    #[serde(rename = "udp")]
    UDP,
    /// Generic Routing Encapsulation.
    #[serde(rename = "gre")]
    GRE,
    /// Encapsulating Security Payload.
    #[serde(rename = "esp")]
    ESP,
    /// IPv6 Encapsulating Header extension.
    #[serde(rename = "eh")]
    EH,
}

impl Display for VultrFirewallGroupRuleProtocol {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            VultrFirewallGroupRuleProtocol::ICMP => write!(f, "icmp"),
            VultrFirewallGroupRuleProtocol::TCP => write!(f, "tcp"),
            VultrFirewallGroupRuleProtocol::UDP => write!(f, "udp"),
            VultrFirewallGroupRuleProtocol::GRE => write!(f, "gre"),
            VultrFirewallGroupRuleProtocol::ESP => write!(f, "esp"),
            VultrFirewallGroupRuleProtocol::EH => write!(f, "eh"),
        }
    }
}