use thiserror::Error;

            let prompt = meta.0;

            let prompt = super::Meta::try_from(meta).unwrap().0;

    impl TryFrom<(u8, Meta)> for Success {
        type Error = super::MimeError;
        fn try_from((_, meta): (u8, Meta)) -> Result<Self, Self::Error> {
            let mime = Mime::try_from(meta)?;
            Ok(Self { mime })

    impl From<(u8, Meta)> for Success {
        fn from((_, meta): (u8, Meta)) -> Self {
            let mime = Mime::try_from(Meta::try_from(meta).unwrap()).expect("failed to read mime");
            Self { mime }

    #[derive(Error, Debug)]
    #[error("failed to read mime: {0}")]
    pub struct UrlError(#[from] url::ParseError);
    impl TryFrom<(u8, Meta)> for Redirect {
        type Error = UrlError;
        fn try_from((code, meta): (u8, Meta)) -> Result<Self, Self::Error> {

    impl From<(u8, Meta)> for Redirect {
        fn from((code, meta): (u8, Meta)) -> Self {

            Ok(Self {
                url: meta.0.parse()?,

            Self {
                url: meta.0.parse().expect("not a valid url"),

            })

            }

}
#[derive(Error, Debug)]
pub enum HeaderError {
    #[error("bad status code: [{0},{1}]")]
    BadStatus(u8, u8),
    #[error("{0}")]
    Mime(#[from] MimeError),
    #[error("{0}")]
    Url(#[from] header::UrlError),

    type Error = HeaderError;

    type Error = String;

        match status {

        match match status {

            2 => Some(Header::Success((sub, meta).try_into()?)),
            3 => Some(Header::Redirect((sub, meta).try_into()?)),

            2 => Some(Header::Success((sub, meta).into())),
            3 => Some(Header::Redirect((sub, meta).into())),

        } {
            Some(s) => Ok(s),
            None => Err(format!("bad status code: [{:?},{:?}]", status, sub)),

        .ok_or(HeaderError::BadStatus(status, sub))

use thiserror::Error;

#[derive(Error, Debug)]
#[error("reading MIME type: {0}")]
pub struct MimeError(#[from] mime::FromStrError);
impl TryFrom<Meta> for Mime {
    type Error = MimeError;
    fn try_from(value: Meta) -> Result<Self, Self::Error> {
        Ok(value.0.parse()?)

impl From<Meta> for Mime {
    fn from(value: Meta) -> Self {
        value.0.parse().unwrap()

trait RaiseTo {
    type Target;
    type Output<'a>;
    fn raise_to<'a>(&self, target: &'a mut Self::Target) -> Self::Output<'a>;

trait RaiseTo<Target> {
    type Output<'a>
    where
        Target: 'a;
    fn raise_to<'a>(&self, target: &'a mut Target) -> Self::Output<'a>;

impl<'a> RaiseTo for Media<'a> {
    type Target = String;

impl RaiseTo<String> for Media<'_> {

    fn raise_to<'a>(&self, target: &'a mut Self::Target) -> Self::Output<'a> {

    fn raise_to<'a>(&self, target: &'a mut String) -> Self::Output<'a> {

            Media::Gemini(gem) => todo!(),
            Media::Text(text) => text.raise_to(target),

            Media::Gemini(gem) => Media::Gemini(gem.raise_to(target)),
            Media::Text(text) => Media::Text(text.raise_to(target)),

}
impl RaiseTo<String> for Gemini<'_> {
    type Output<'a> = Gemini<'a>;
    fn raise_to<'a>(&self, target: &'a mut String) -> Self::Output<'a> {
        Self {
            lines: self.lines.iter().map(|ln| ln.raise_to(target)).collect(),
        }
    }

#[derive(Clone, Debug)]

#[derive(Copy, Clone, Debug)]

}
impl RaiseTo<String> for Line<'_> {
    type Output<'a> = Line<'a>;
    fn raise_to<'a>(&self, target: &'a mut String) -> Self::Output<'a> {
        match self {
            Line::Heading { level, title } => Line::Heading {
                level: *level,
                title: title.raise_to(target),
            },
            Line::Link { url, description } => {
                let url = url.raise_to(target);
                let description = description.map(|d| d.raise_to(target));
                Line::Link { url, description }
            }
            Line::Text(t) => Line::Text(t.raise_to(target)),
            Line::Preformatted(p) => Line::Preformatted(p.raise_to(target)),
            Line::ListItem(li) => Line::ListItem(li.raise_to(target)),
            Line::Quote(q) => Line::Quote(q.raise_to(target)),
        }
    }

}
impl RaiseTo<String> for Preformat<'_> {
    type Output<'a> = Preformat<'a>;
    fn raise_to<'a>(&self, target: &'a mut String) -> Self::Output<'a> {
        let alt = self.alt.raise_to(target);
        let lines = self.lines.iter().map(|ln| ln.raise_to(target)).collect();
        Self { alt, lines }
    }

impl<'tl> RaiseTo for TextLine<'tl> {
    type Target = String;

impl RaiseTo<String> for TextLine<'_> {

impl<'st> RaiseTo for &'st str {
    type Target = String;

impl RaiseTo<String> for &'_ str {

// unconditionally trusts

/// Unconditionally trusts all certificates

// trust on first use
pub struct Tofu {}

/// Trust on first use
pub struct Tofu {
    known_hosts: Vec<TofuHost>,
}
pub struct TofuHost {}
/*
impl rustls::client::ServerCertVerifier for Tofu {
    fn verify_server_cert(
        &self,
        end_entity: &Certificate,
        _: &[Certificate],
        server_name: &ServerName,
        scts: &mut dyn Iterator<Item = &[u8]>,
        ocsp_response: &[u8],
        now: SystemTime,
    ) -> Result<ServerCertVerified, Error> {
        let host: TofuHost = TofuHost::new();
        if self.knows(host) {
            if self.trusts(host) {
                Ok(())
            } else {
                Err(())
            }
        } else {
            self.remember(host);
            Ok(())
        }
    }
}
*/