use tokio::runtime::Runtime;

use crate::certs::{fingerprint::CertFingerprint, CertificateDer};

use super::*;

#[test]
fn check_parser() {
    let rt = Runtime::new().unwrap();
    let client = Client::builder().dangerous_with_no_verifier().build();

    let mut recv = Vec::new();
    let stream = tokio::io::join(
        "20 text/gemini\r\n# hello world\n👍\n".as_bytes(),
        &mut recv,
    );

    let mut resp = rt
        .block_on(client.perform_io("gemini://unw.dc09.ru", stream))
        .unwrap();

    {
        let status = resp.status();
        assert_eq!(status.status_code(), StatusCode::Success);
        assert_eq!(status.reply_type(), ReplyType::Success);
        assert_eq!(status.num(), 20u8);
        assert_eq!(status.second_digit(), 0u8);
    }

    assert_eq!(resp.is_ok(), true);

    assert_eq!(resp.message(), "text/gemini");

    {
        let mime = resp.mime().unwrap();
        assert_eq!(mime.type_(), mime::TEXT);
        assert_eq!(mime.subtype(), "gemini");
    }

    assert_eq!(rt.block_on(resp.text()).unwrap(), "# hello world\n👍\n");

    drop(resp); // to free recv from mutable borrowing
    assert_eq!(recv.as_slice(), b"gemini://unw.dc09.ru\r\n");
}

#[test]
fn check_real_site() {
    let rt = Runtime::new().unwrap();
    let client = Client::builder()
        .with_selfsigned_cert_verifier(Verifier {})
        .build();

    rt.block_on(client.request("gemini://geminiprotocol.net/docs"))
        .unwrap();

    struct Verifier;

    #[async_trait::async_trait]
    impl SelfsignedCertVerifier for Verifier {
        async fn verify(
            &self,
            cert: &CertificateDer<'_>,
            host: &str,
            port: u16,
        ) -> Result<bool, LibError> {
            assert_eq!(host, "geminiprotocol.net");
            assert_eq!(port, 1965);
            assert_eq!(
                CertFingerprint::new_sha256(cert).base64(),
                "OBuOKRLSTQcgHXdQ0QFshcGQSgc5o+g0fnHDY+7SolE",
            );
            Ok(true)
        }
    }
}