use std::net::SocketAddr;

use serde::ser::SerializeStruct;
use serde::{Deserialize, Serialize, Serializer};

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(tag = "transport", rename_all = "lowercase")]
pub enum Address {
    Tcp { hostname: String, port: u16 },
    Unix { path: Option<String> },
}

#[derive(Clone, Debug)]
pub enum Endpoint {
    Tcp(SocketAddr),
    Unix { path: Option<String> },
}

impl Serialize for Endpoint {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::Tcp(address) => {
                let mut fields = serializer.serialize_struct("Address", 3)?;
                fields.serialize_field("transport", "tcp")?;
                fields.serialize_field("hostname", &address.ip())?;
                fields.serialize_field("port", &address.port())?;
                fields.end()
            }
            Self::Unix { path } => {
                let mut fields = serializer.serialize_struct("Address", 2)?;
                fields.serialize_field("transport", "unix")?;
                fields.serialize_field("path", path)?;
                fields.end()
            }
        }
    }
}

impl From<Endpoint> for Address {
    fn from(endpoint: Endpoint) -> Self {
        match endpoint {
            Endpoint::Tcp(address) => Self::Tcp {
                hostname: address.ip().to_string(),
                port: address.port(),
            },
            Endpoint::Unix { path } => Self::Unix { path },
        }
    }
}