use bstr::ByteVec;

use rustls::{ClientConnection, ServerName};

use rustls::ClientConnection;

    io::{self, BufReader, Read, Write},

    io::{BufReader, Read, Result as ioResult, Write},

    sync::Arc,

mod danger;
mod io;
mod read_until;
//TODO: refactor and repurpose this
mod response;
mod server;
mod cl {
    use clap::Parser;
    #[derive(Parser)]
    pub struct App {
        pub url: Option<String>,
    }
}

    let mut stream = connect(&url);

    let mut stream = server::connect::<danger::Naive>(&url);

// todo parse from 2-digit response header

// TODO parse from 2-digit response header

// todo parse etc

// TODO parse etc

fn read_response_header(
    stream: &mut rustls::StreamOwned<ClientConnection, TcpStream>,
) -> io::Result<(Code, Meta)> {
    let code = read_n::<2>(stream)?;

fn read_response_header(stream: &mut Stream) -> ioResult<response::Status> {
    let status = io::read_n::<2>(stream)?;
    let status = status.map(|s| s.checked_sub(b'0').expect("bad status fragment"));

    let c = read_byte(stream)?;

    let c = io::read_byte(stream)?;

    // TODO limit to 1024

    // drop last 2
    for _ in 0..2 {
        meta.pop();
    }

    Ok((code, meta))
}

    let meta = meta.into_string().expect("Meta was not valid UTF8");
    let header = response::raw::Header { meta, status };

mod read_until;

    Ok(header.try_into().expect("failed to parse header"))
}

fn read_response_string(
    stream: &mut rustls::StreamOwned<ClientConnection, TcpStream>,
) -> io::Result<String> {

fn read_response_string(stream: &mut Stream) -> ioResult<String> {

}
fn read_byte(
    stream: &mut rustls::StreamOwned<ClientConnection, TcpStream>,
) -> Result<u8, io::Error> {
    let [c] = read_n::<1>(stream)?;
    Ok(c)
}
fn read_n<const N: usize>(
    stream: &mut rustls::StreamOwned<ClientConnection, TcpStream>,
) -> io::Result<[u8; N]> {
    let mut buf = [0; N];
    stream.read_exact(&mut buf)?;
    Ok(buf)

fn send_request(stream: &mut rustls::StreamOwned<ClientConnection, TcpStream>, url: Url) {

fn send_request(stream: &mut impl Write, url: Url) {

fn connect(url: &Url) -> rustls::StreamOwned<ClientConnection, TcpStream> {
    let host = url.host().expect("");
    let sn = server(host);
    let stream = {
        let cfg = tls_cfg();
        let conn = {
            let client = ClientConnection::new(cfg, sn).expect("could not connect");
            client
        };
        let addrs = url
            .socket_addrs(|| Some(1965))
            .expect("could not get addresses for URL");
        let addr = addrs.get(0).expect("no addresses");
        let sock = TcpStream::connect(addr).expect("failed to connect");
        let stream = Stream { conn, sock };
        stream
    };
    stream
}
fn server(host: url::Host<&str>) -> ServerName {
    let url::Host::Domain(s) = host
        else {unreachable!("the url is always a string")};
    let sn = s.try_into().expect("this should be a valid DNS name");
    sn
}
fn tls_cfg() -> Arc<rustls::ClientConfig> {
    let root_store = rustls::RootCertStore::empty();
    let cfg = {
        let mut cfg = rustls::ClientConfig::builder()
            .with_safe_defaults()
            .with_root_certificates(root_store)
            .with_no_client_auth();
        cfg.dangerous()
            .set_certificate_verifier(Arc::new(danger::Naive {}));
        Arc::new(cfg)
    };
    cfg
}
mod danger {
    use std::time::SystemTime;
    use rustls::{client::ServerCertVerified, Certificate, Error, ServerName};
    // unconditionally trusts
    pub struct Naive;
    // trust on first use
    pub struct Tofu {}
    impl rustls::client::ServerCertVerifier for Naive {
        fn verify_server_cert(
            &self,
            _: &Certificate,
            _: &[Certificate],
            _: &ServerName,
            _: &mut dyn Iterator<Item = &[u8]>,
            _: &[u8],
            _: SystemTime,
        ) -> Result<ServerCertVerified, Error> {
            Ok(ServerCertVerified::assertion())
        }
    }
}
mod cl {
    use clap::Parser;
    #[derive(Parser)]
    pub struct App {
        pub url: Option<String>,
    }
}