use std::{
    error::Error,
    fs::{read_dir, DirEntry},
    net::TcpStream,
    path::PathBuf,
    vec::IntoIter, collections::HashMap,
};

use imap::Session;
use rustls_connector::RustlsConnector;

pub trait EmailReader {
    fn read_rfc822_messages(&mut self) -> Box<IntoIter<(String, Vec<u8>)>>;
}

pub(crate) struct TestMessagesReader {
    path: PathBuf,
}

impl TestMessagesReader {
    pub fn new(path: PathBuf) -> Self {
        TestMessagesReader { path }
    }
}

impl EmailReader for TestMessagesReader {
    fn read_rfc822_messages(&mut self) -> Box<IntoIter<(String, Vec<u8>)>> {
        let reader = match read_dir(&self.path) {
            Ok(r) => r,
            Err(_) => return Box::new(Vec::new().into_iter()),
        };

        let items = reader
            .filter(|i| i.is_ok())
            .map(|i| i.unwrap() as DirEntry)
            .filter(|d| match d.path().extension() {
                Some(ext) => ext == "eml",
                None => false,
            })
            .map(|i| {
                let uid = i.path().file_stem().unwrap().to_owned();
                if let Ok(data) = std::fs::read(i.path()) {
                    Some((uid.into_string().unwrap(), data))
                } else {
                    None
                }
            })
            .filter(|i| i.is_some())
            .map(|i| i.unwrap());

        let iter = items.collect::<Vec<(String, Vec<u8>)>>().into_iter();

        Box::new(iter)
    }
}

fn connect(
    server: &str,
    port: u16,
    username: &str,
    password: &str,
) -> Result<HashMap<String, Vec<u8>>, Box<dyn Error>> {
    let mut session = open_session(server, port, username, password)?;

    session.examine("INBOX")?;

    let items = match session.uid_search("ALL") {
        Ok(i) => i,
        Err(e) => return Err(Box::new(e)),
    };

    let mut msgs = HashMap::<String, Vec<u8>>::with_capacity(items.len());

    //println!("# of messages: {}", &items.len());

    for item in items {
        let msg = session.uid_fetch(&item.to_string(), "(BODY.PEEK[] UID)")?;

        let message = if let Some(m) = msg.iter().next() {
            m
        } else {
            continue;
        };

        let body = message.body().expect("Message did not have a body.");

        msgs.insert(item.to_string(), body.to_owned());
    }

    session.logout().expect("Could not log out");

    Ok(msgs)
}

fn open_session(
    server: &str,
    port: u16,
    username: &str,
    password: &str,
) -> Result<
    Session<
        rustls_connector::rustls::StreamOwned<
            rustls_connector::rustls::ClientConnection,
            TcpStream,
        >,
    >,
    Box<dyn Error + 'static>,
> {
    let stream = TcpStream::connect((server, port))?;
    let tls = RustlsConnector::new_with_webpki_roots_certs();
    let tls_stream = tls.connect(server, stream)?;

    let client = imap::Client::new(tls_stream);

    Ok(client.login(username, password).map_err(|e| e.0)?)
}