use std::ops::Deref;


use rocket::request::FromParam;
use serde::{Deserialize, Serialize, Deserializer, Serializer};
use trust_dns_proto::error::ProtoError;

use crate::dns::Name;


#[derive(Debug, Clone)]
pub struct SerdeName(pub(crate)Name);

impl Deref for SerdeName {
    type Target = Name;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<'de> Deserialize<'de> for SerdeName {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>
    {
        use serde::de::Error;

        String::deserialize(deserializer)
            .and_then(|string|
                Name::from_utf8(&string)
                    .map_err(|e| Error::custom(e.to_string()))
            ).map( SerdeName)
    }
}

impl Serialize for SerdeName {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer
    {
        self.0.to_utf8().serialize(serializer)
    }
}

impl SerdeName {
    pub fn into_inner(self) -> Name {
        self.0
    }
}


#[derive(Debug, Deserialize)]
pub struct AbsoluteName(SerdeName);

impl<'r> FromParam<'r> for AbsoluteName {
    type Error = ProtoError;

    fn from_param(param: &'r str) -> Result<Self, Self::Error> {
        let mut name = Name::from_utf8(&param)?;
        if !name.is_fqdn() {
            name.set_fqdn(true);
        }
        Ok(AbsoluteName(SerdeName(name)))
    }
}

impl Deref for AbsoluteName {
    type Target = Name;
    fn deref(&self) -> &Self::Target {
        &self.0.0
    }
}