#![deny(warnings, rust_2018_idioms)]

use crate::fbs::dns_enums_conv;
use crate::fbs::dns_enums_generated::ResourceType;
use crate::fbs::dns_message_generated::{Header, Message, Question, Resource, ResourceData, OPT};
use std::fmt;
use std::net::{Ipv4Addr, Ipv6Addr};

impl fmt::Display for Message<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Message:")?;
        if let Some(header) = self.header() {
            write!(f, "\n- header: {}", header)?;
        }
        if let Some(opt) = self.opt() {
            write!(f, "\n- opt: {}", opt)?;
        }
        if let Some(entries) = self.question() {
            for i in 0..entries.len() {
                write!(f, "\n- question: {}", entries.get(i))?;
            }
        }
        if let Some(entries) = self.answer() {
            for i in 0..entries.len() {
                write!(f, "\n- answer: {}", entries.get(i))?;
            }
        }
        if let Some(entries) = self.authority() {
            for i in 0..entries.len() {
                write!(f, "\n- authority: {}", entries.get(i))?;
            }
        }
        if let Some(entries) = self.additional() {
            for i in 0..entries.len() {
                write!(f, "\n- additional: {}", entries.get(i))?;
            }
        }
        Ok(())
    }
}

impl fmt::Display for Header<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "id={} is_response={} op_code=",
            self.id(),
            self.is_response()
        )?;
        match dns_enums_conv::opcode_int(self.op_code() as usize) {
            Some(op_code) => write!(f, "{:?}", op_code)?,
            None => write!(f, "{}", self.op_code())?,
        }
        write!(
            f,
            " authoritative={} truncated={} recursion_desired={} recursion_available={} authentic_data={} checking_disabled={} response_code=",
            self.authoritative(), self.truncated(), self.recursion_desired(), self.recursion_available(), self.authentic_data(), self.checking_disabled(),
        )?;
        match dns_enums_conv::responsecode_int(self.response_code() as usize) {
            Some(response_code) => write!(f, "{:?}", response_code)?,
            None => write!(f, "{}", self.response_code())?,
        }
        Ok(())
    }
}

impl fmt::Display for OPT<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "udp_size={} response_code={}",
            self.udp_size(),
            self.response_code()
        )?;
        write!(
            f,
            " version={} dnssec_ok={} option=[",
            self.version(),
            self.dnssec_ok()
        )?;
        if let Some(entries) = self.option() {
            for i in 0..entries.len() {
                let entry = entries.get(i);
                write!(f, " {}=(code=", i)?;
                match dns_enums_conv::optoptioncode_int(entry.code() as usize) {
                    Some(code) => write!(f, "{:?}", code)?,
                    None => write!(f, "{}", entry.code())?,
                }
                write!(f, " data={:02X?})", entry.data())?;
            }
        }
        write!(f, " ]")?;
        Ok(())
    }
}

impl fmt::Display for Question<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "name={} resource_type=", self.name().unwrap_or("UNSET"))?;
        match dns_enums_conv::resourcetype_int(self.resource_type() as usize) {
            Some(resource_type) => write!(f, "{:?}", resource_type)?,
            None => write!(f, "{}", self.resource_type())?,
        }
        write!(f, " resource_class=")?;
        match dns_enums_conv::resourceclass_int(self.resource_class() as usize) {
            Some(resource_class) => write!(f, "{:?}", resource_class)?,
            None => write!(f, "{}", self.resource_class())?,
        }
        Ok(())
    }
}

impl fmt::Display for Resource<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "name={} resource_type=", self.name().unwrap_or("UNSET"))?;
        match dns_enums_conv::resourcetype_int(self.resource_type() as usize) {
            Some(resource_type) => write!(f, "{:?}", resource_type)?,
            None => write!(f, "{}", self.resource_type())?,
        }
        // Ignore inapplicable resource_class/ttl for OPT records
        if self.resource_type() != ResourceType::TYPE_OPT as u16 {
            write!(f, " resource_class=")?;
            match dns_enums_conv::resourceclass_int(self.resource_class() as usize) {
                Some(resource_class) => write!(f, "{:?}", resource_class)?,
                None => write!(f, "{}", self.resource_class())?,
            }
            write!(f, " ttl={}", self.ttl())?;
        }
        if let Some(rdata) = self.rdata() {
            write!(f, " {}", rdata)?;
        }
        Ok(())
    }
}

impl fmt::Display for ResourceData<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if let Some(raw_data) = self.raw_data() {
            write!(f, "raw_data={:02X?}", raw_data)?;
        }
        if let Some(data) = self.a() {
            write!(
                f,
                "a[address={}]",
                Ipv4Addr::new(
                    data.address1(),
                    data.address2(),
                    data.address3(),
                    data.address4()
                )
            )?;
        }
        if let Some(data) = self.ns() {
            write!(f, "ns[nsdname={:?}]", data.nsdname())?;
        }
        if let Some(data) = self.cname() {
            write!(f, "cname[cname={:?}]", data.cname())?;
        }
        if let Some(data) = self.soa() {
            write!(
                f,
                "soa=[mname={:?} rname={:?} serial={} refresh={} retry={} expire={} minimum={}]",
                data.mname(),
                data.rname(),
                data.serial(),
                data.refresh(),
                data.retry(),
                data.expire(),
                data.minimum(),
            )?;
        }
        if let Some(data) = self.ptr() {
            write!(f, "ptr[ptrdname={:?}]", data.ptrdname())?;
        }
        if let Some(data) = self.hinfo() {
            write!(f, "hinfo[cpu={:02X?} os={:02X?}]", data.cpu(), data.os())?;
        }
        if let Some(data) = self.mx() {
            write!(
                f,
                "mx[preference={} exchange={:?}]",
                data.preference(),
                data.exchange()
            )?;
        }
        if let Some(data) = self.txt() {
            write!(f, "txt[")?;
            if let Some(entries) = data.entries() {
                for i in 0..entries.len() {
                    write!(f, " {}={:02X?}", i, entries.get(i).data())?;
                }
            }
            write!(f, " ]")?;
        }
        if let Some(data) = self.rp() {
            write!(
                f,
                "rp[mbox_dname={:?} txt_dname={:?}]",
                data.mbox_dname(),
                data.txt_dname()
            )?;
        }
        if let Some(data) = self.afsdb() {
            write!(
                f,
                "afsdb[subtype={} hostname={:?}]",
                data.subtype(),
                data.hostname()
            )?;
        }
        if let Some(data) = self.sig() {
            write!(
                f,
                "sig[type_covered={} algorithm={} labels={} original_ttl={} signature_expiration={} signature_inception={} key_tag={} signers_name={:?} signature={:02X?}]",
                data.type_covered(), data.algorithm(), data.labels(), data.original_ttl(), data.signature_expiration(), data.signature_inception(), data.key_tag(), data.signers_name(), data.signature(),
            )?;
        }
        if let Some(data) = self.key() {
            write!(
                f,
                "key[flags={} protocol={} algorithm={} public_key={:02X?}]",
                data.flags(),
                data.protocol(),
                data.algorithm(),
                data.public_key(),
            )?;
        }
        if let Some(data) = self.aaaa() {
            write!(
                f,
                "aaaa[address={}]",
                Ipv6Addr::new(
                    data.address1(),
                    data.address2(),
                    data.address3(),
                    data.address4(),
                    data.address5(),
                    data.address6(),
                    data.address7(),
                    data.address8()
                )
            )?;
        }
        if let Some(data) = self.loc() {
            write!(
                f,
                "loc[version={} size={} horiz_pre={} vert_pre={} latitude={} longitude={} altitude={}]",
                data.version(), data.size_(), data.horiz_pre(), data.vert_pre(), data.latitude(), data.longitude(), data.altitude(),
            )?;
        }
        if let Some(data) = self.srv() {
            write!(
                f,
                "srv[priority={} weight={} port={} target={:?}]",
                data.priority(),
                data.weight(),
                data.port(),
                data.target()
            )?;
        }
        if let Some(data) = self.naptr() {
            write!(
                f,
                "naptr[order={} preference={} flags={:02X?} services={:02X?} regexp={:02X?} replacement={:?}]",
                data.order(), data.preference(), data.flags(), data.services(), data.regexp(), data.replacement(),
            )?;
        }
        if let Some(data) = self.kx() {
            write!(
                f,
                "kx[preference={} exchanger={:?}]",
                data.preference(),
                data.exchanger()
            )?;
        }
        if let Some(data) = self.cert() {
            write!(
                f,
                "cert[type={} key_tag={} algorithm={} certificate={:02X?}]",
                data.type_(),
                data.key_tag(),
                data.algorithm(),
                data.certificate(),
            )?;
        }
        if let Some(data) = self.dname() {
            write!(f, "dname[dname={:?}]", data.dname())?;
        }
        if let Some(data) = self.apl() {
            write!(f, "apl[")?;
            if let Some(entries) = data.item() {
                for i in 0..entries.len() {
                    let entry = entries.get(i);
                    write!(
                        f,
                        " {}=[address_family={} prefix={} negation={} afd_part={:02X?}]",
                        i,
                        entry.address_family(),
                        entry.prefix(),
                        entry.negation(),
                        entry.afd_part(),
                    )?;
                }
            }
            write!(f, " ]")?;
        }
        if let Some(data) = self.ds() {
            write!(
                f,
                "ds[key_tag={} algorithm={} digest_type={} digest={:02X?}]",
                data.key_tag(),
                data.algorithm(),
                data.digest_type(),
                data.digest(),
            )?;
        }
        if let Some(data) = self.sshfp() {
            write!(
                f,
                "sshfp[algorithm={} fp_type={} fingerprint={:02X?}]",
                data.algorithm(),
                data.fp_type(),
                data.fingerprint()
            )?;
        }
        if let Some(data) = self.ipseckey() {
            write!(
                f,
                "ipseckey[precedence={} gateway_type={} algorithm={} gateway={:02X?} public_key={:02X?}]",
                data.precedence(), data.gateway_type(), data.algorithm(), data.gateway(), data.public_key(),
            )?;
        }
        if let Some(data) = self.rrsig() {
            write!(
                f,
                "rrsig[type_covered={} algorithm={} labels={} original_ttl={} signature_expiration={} signature_inception={} key_tag={} signers_name={:?} signature={:02X?}]",
                data.type_covered(), data.algorithm(), data.labels(), data.original_ttl(), data.signature_expiration(), data.signature_inception(), data.key_tag(), data.signers_name(), data.signature(),
            )?;
        }
        if let Some(data) = self.nsec() {
            write!(
                f,
                "nsec[next_domain_name={:?} type_bit_maps={:02X?}]",
                data.next_domain_name(),
                data.type_bit_maps()
            )?;
        }
        if let Some(data) = self.dnskey() {
            write!(
                f,
                "dnskey[flags={} protocol={} algorithm={} public_key={:02X?}]",
                data.flags(),
                data.protocol(),
                data.algorithm(),
                data.public_key()
            )?;
        }
        if let Some(data) = self.dhcid() {
            write!(f, "dhcid[dhcp_data={:02X?}]", data.dhcp_data())?;
        }
        if let Some(data) = self.nsec3() {
            write!(
                f,
                "nsec3[hash_algorithm={} flags={} iterations={} salt={:02X?} next_hashed_owner_name={:02X?} type_bit_maps={:02X?}]",
                data.hash_algorithm(), data.flags(), data.iterations(), data.salt(), data.next_hashed_owner_name(), data.type_bit_maps(),
            )?;
        }
        if let Some(data) = self.nsec3param() {
            write!(
                f,
                "nsec3param[hash_algorithm={} flags={} iterations={} salt={:02X?}]",
                data.hash_algorithm(),
                data.flags(),
                data.iterations(),
                data.salt()
            )?;
        }
        if let Some(data) = self.tlsa() {
            write!(
                f,
                "tlsa[certificate_usage={} selector={} matching_type={} certificate_association_data={:02X?}]",
                data.certificate_usage(), data.selector(), data.matching_type(), data.certificate_association_data(),
            )?;
        }
        if let Some(data) = self.smimea() {
            write!(
                f,
                "smimea[certificate_usage={} selector={} matching_type={} certificate_association_data={:02X?}]",
                data.certificate_usage(), data.selector(), data.matching_type(), data.certificate_association_data(),
            )?;
        }
        if let Some(data) = self.hip() {
            write!(
                f,
                "hip[public_key_algorithm={} hit={:02X?} public_key={:02X?} rendezvous_servers=[",
                data.public_key_algorithm(),
                data.hit(),
                data.public_key(),
            )?;
            if let Some(entries) = data.rendezvous_servers() {
                for i in 0..entries.len() {
                    write!(f, " {}={:?}", i, entries.get(i))?;
                }
            }
            write!(f, " ]")?;
        }
        if let Some(data) = self.openpgpkey() {
            write!(f, "openpgpkey[public_key={:?}]", data.public_key())?;
        }
        if let Some(data) = self.csync() {
            write!(
                f,
                "csync[soa_serial={} flags={} type_bit_map={:02X?}]",
                data.soa_serial(),
                data.flags(),
                data.type_bit_map()
            )?;
        }
        if let Some(data) = self.tkey() {
            write!(
                f,
                "tkey[algorithm={:?} inception={} expiration={} mode={} error={} key_data={:02X?} other_data={:02X?}]",
                data.algorithm(), data.inception(), data.expiration(), data.mode(), data.error(), data.key_data(), data.other_data(),
            )?;
        }
        if let Some(data) = self.tsig() {
            write!(
                f,
                "tsig[algorithm_name={:?} time_signed={} fudge={} mac={:02X?} other_data={:02X?}]",
                data.algorithm_name(),
                data.time_signed(),
                data.fudge(),
                data.mac(),
                data.other_data(),
            )?;
        }
        if let Some(data) = self.uri() {
            write!(
                f,
                "uri[priority={} weight={} target={:?}]",
                data.priority(),
                data.weight(),
                data.target()
            )?;
        }
        if let Some(data) = self.caa() {
            write!(
                f,
                "caa[flags={} tag={:?} value={:02X?}]",
                data.flags(),
                data.tag(),
                data.value()
            )?;
        }
        Ok(())
    }
}