#![forbid(unsafe_code)]
#![cfg_attr(feature = "strict", deny(warnings))]

mod cli;
mod platform;

use std::any::Any;
use std::io::{stderr, stdin, stdout, Read, Stderr, Stdout, Write};
use std::iter::once;
use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, ToSocketAddrs};
use std::time::Duration;

use failure::{Error, Fail};
use rand::prelude::*;
use tokio::{net::UdpSocket, time};

use nonymous::emit::message::MessageBuilder;
use nonymous::emit::{NewBuilder, Sink};
use nonymous::view::{Message, View};

pub async fn main(name: &'static str) {
    if let Err(error) = bore(name).await {
        eprint!("fatal error ");
        eprint(error.as_fail());

        for error in error.iter_causes() {
            eprint!("caused by ");
            eprint(error);
        }

        std::process::exit(1);
    }
}

fn eprint(error: &dyn Fail) {
    if let Some(name) = error.name() {
        eprintln!("{}: ", name);
    }

    eprintln!("    {}", error);
}

fn pretty_print(source: &[u8]) -> Result<(), Error> {
    let (message, rest) = Message::view(source, 0..source.len())?;
    println!("{}", message);

    if rest.len() > 0 {
        println!(";; {} octets after message\n", rest.len());
    }

    Ok(())
}

async fn bore(name: &'static str) -> Result<(), Error> {
    let about = self::cli::about(name);
    let usage = self::cli::usage(name);
    let arguments = self::cli::app(name, &about, &usage).get_matches();
    let qname = arguments.value_of("name");
    let qtype = arguments.value_of("type");
    let qclass = arguments.value_of("class").expect("has Arg::default_value");

    let (qname, qtype) = match (qname, qtype) {
        (None, None) => (".", "NS"),
        (None, Some(_)) => unreachable!(),
        (Some(qname), None) => (qname, "A"),
        (Some(qname), Some(qtype)) => (qname, qtype),
    };

    let mut query = vec![];

    if arguments.is_present("decode") {
        let mut source = vec![];
        stdin().lock().read_to_end(&mut source)?;
        pretty_print(&source)?;
        return Ok(());
    }

    if arguments.is_present("load") {
        stdin().lock().read_to_end(&mut query)?;
    } else {
        // unbound(8) requires RD (no cache snooping) by default
        query = MessageBuilder::new(Sink::new(query, None))
            .id(random())
            .rd(true)
            .question()?
            .qname()
            .labels(qname)?
            .finish()
            .finish(qtype.parse()?, qclass.parse()?)
            .into_ar()
            .extension()?
            .finish()?
            .finish()
            .finish()
            .finish();
    }

    if arguments.is_present("encode") {
        stdout().lock().write_all(&query)?;
        return Ok(());
    }

    let timeout = arguments
        .value_of("timeout")
        .expect("should never fail (has Arg::default_value)")
        .parse()
        .map(Duration::from_secs)?;

    let port = arguments
        .value_of("port")
        .expect("should never fail (has Arg::default_value)")
        .parse()?;

    let error_sink_unlocked: Box<dyn Any> = if arguments.is_present("dump") {
        Box::new(stderr())
    } else {
        Box::new(stdout())
    };

    let mut error_sink: Box<dyn Write> = if arguments.is_present("dump") {
        Box::new(error_sink_unlocked.downcast::<Stderr>().unwrap())
    } else {
        Box::new(error_sink_unlocked.downcast::<Stdout>().unwrap())
    };

    for remote in remotes(port, arguments.value_of("host"))? {
        let remote = remote?;
        let mut response = [0u8; 4096];
        let result = time::timeout(timeout, send(remote, &query, &mut response)).await;

        match result {
            Ok(Ok((length, local))) => {
                if arguments.is_present("dump") {
                    stdout().lock().write_all(&response[..length])?;
                    return Ok(());
                } else {
                    println!(";; {} ({})", remote, local);
                    pretty_print(&response[..length])?;
                    return Ok(());
                }
            }
            Ok(Err(error)) => {
                writeln!(error_sink, ";; {} error: {}", remote, error)?;
            }
            Err(_) => {
                writeln!(error_sink, ";; {} timed out", remote)?;
            }
        }
    }

    Ok(())
}

async fn send(
    remote: SocketAddr,
    query: &[u8],
    response: &mut [u8],
) -> Result<(usize, SocketAddr), tokio::io::Error> {
    let local = match remote {
        SocketAddr::V4(_) => SocketAddr::from((Ipv4Addr::UNSPECIFIED, 0)),
        SocketAddr::V6(_) => SocketAddr::from((Ipv6Addr::UNSPECIFIED, 0)),
    };

    let mut socket = UdpSocket::bind(&local).await?;

    // RFC 2181 § 4
    socket.connect(&remote).await?;

    socket.send(&query).await?;

    Ok((socket.recv(response).await?, socket.local_addr()?))
}

fn remotes<'h>(
    port: u16,
    host: impl Into<Option<&'h str>>,
) -> Result<Box<dyn Iterator<Item = Result<SocketAddr, Error>>>, Error> {
    if let Some(host) = host.into() {
        return Ok(Box::new((host, port).to_socket_addrs()?.map(Ok)));
    }

    let mut result = self::platform::resolvers(port)?.peekable();

    if result.peek().is_some() {
        return Ok(Box::new(result));
    }

    let ip6 = SocketAddr::from((Ipv6Addr::LOCALHOST, port));
    let ip4 = SocketAddr::from((Ipv4Addr::LOCALHOST, port));

    Ok(Box::new(once(ip6).chain(once(ip4)).map(Ok)))
}