use std::io;

use imap_codec::codec::Encode;
use imap_codec::types::response::{Data as ImapData, Status as ImapStatus};

#[derive(Debug)]
pub enum Body {
    Once(Vec<Data>),
}

impl Body {
    pub(crate) fn into_data(self) -> Vec<Data> {
        match self {
            Body::Once(data) => data,
        }
    }
}

impl FromIterator<Data> for Body {
    fn from_iter<T: IntoIterator<Item = Data>>(iter: T) -> Self {
        Body::Once(Vec::from_iter(iter))
    }
}

impl FromIterator<ImapData> for Body {
    fn from_iter<T: IntoIterator<Item = ImapData>>(iter: T) -> Self {
        Body::from_iter(iter.into_iter().map(Data::Data))
    }
}

impl From<Vec<Data>> for Body {
    fn from(body: Vec<Data>) -> Self {
        Body::from_iter(body)
    }
}

impl From<Vec<ImapData>> for Body {
    fn from(data: Vec<ImapData>) -> Self {
        Body::from_iter(data)
    }
}

impl From<ImapData> for Body {
    fn from(data: ImapData) -> Self {
        Body::from_iter([data])
    }
}

#[derive(Debug, Clone)]
pub enum Data {
    Data(ImapData),
    Status(ImapStatus),
}

impl Encode for Data {
    fn encode(&self, writer: &mut impl io::Write) -> std::io::Result<()> {
        match self {
            Data::Data(ref data) => data.encode(writer),
            Data::Status(ref status) => status.encode(writer),
        }
    }
}

impl From<ImapData> for Data {
    fn from(data: ImapData) -> Self {
        Data::Data(data)
    }
}

impl From<ImapStatus> for Data {
    fn from(status: ImapStatus) -> Self {
        Data::Status(status)
    }
}