use clap;
use error_chain::error_chain;
use log::{debug, error, trace};
use std::{
    fs,
    io::{self, BufRead},
    ops::Deref,
};

use crate::{
    app::App,
    flag::model::Flag,
    imap::model::ImapConnector,
    input,
    mbox::cli::mbox_target_arg,
    msg::model::{Attachments, Msg, Msgs, ReadableMsg},
    smtp,
};

error_chain! {
    links {
        Imap(crate::imap::model::Error, crate::imap::model::ErrorKind);
        Input(crate::input::Error, crate::input::ErrorKind);
        MsgModel(crate::msg::model::Error, crate::msg::model::ErrorKind);
        Smtp(crate::smtp::Error, crate::smtp::ErrorKind);
    }
    foreign_links {
        Utf8(std::string::FromUtf8Error);
    }
}

pub fn uid_arg<'a>() -> clap::Arg<'a, 'a> {
    clap::Arg::with_name("uid")
        .help("Specifies the targetted message")
        .value_name("UID")
        .required(true)
}

fn reply_all_arg<'a>() -> clap::Arg<'a, 'a> {
    clap::Arg::with_name("reply-all")
        .help("Includes all recipients")
        .short("a")
        .long("all")
}

fn page_size_arg<'a>() -> clap::Arg<'a, 'a> {
    clap::Arg::with_name("page-size")
        .help("Page size")
        .short("s")
        .long("size")
        .value_name("INT")
}

fn page_arg<'a>() -> clap::Arg<'a, 'a> {
    clap::Arg::with_name("page")
        .help("Page number")
        .short("p")
        .long("page")
        .value_name("INT")
        .default_value("0")
}

fn attachment_arg<'a>() -> clap::Arg<'a, 'a> {
    clap::Arg::with_name("attachments")
        .help("Adds attachment to the message")
        .short("a")
        .long("attachment")
        .value_name("PATH")
        .multiple(true)
        .takes_value(true)
}

pub fn msg_subcmds<'a>() -> Vec<clap::App<'a, 'a>> {
    vec![
        clap::SubCommand::with_name("list")
            .aliases(&["lst", "l"])
            .about("Lists all messages")
            .arg(page_size_arg())
            .arg(page_arg()),
        clap::SubCommand::with_name("search")
            .aliases(&["query", "q", "s"])
            .about("Lists messages matching the given IMAP query")
            .arg(page_size_arg())
            .arg(page_arg())
            .arg(
                clap::Arg::with_name("query")
                    .help("IMAP query (see https://tools.ietf.org/html/rfc3501#section-6.4.4)")
                    .value_name("QUERY")
                    .multiple(true)
                    .required(true),
            ),
        clap::SubCommand::with_name("write")
            .aliases(&["w"])
            .about("Writes a new message")
            .arg(attachment_arg()),
        clap::SubCommand::with_name("send")
            .about("Sends a raw message")
            .arg(clap::Arg::with_name("message").raw(true)),
        clap::SubCommand::with_name("save")
            .about("Saves a raw message")
            .arg(clap::Arg::with_name("message").raw(true)),
        clap::SubCommand::with_name("read")
            .aliases(&["r"])
            .about("Reads text bodies of a message")
            .arg(uid_arg())
            .arg(
                clap::Arg::with_name("mime-type")
                    .help("MIME type to use")
                    .short("t")
                    .long("mime-type")
                    .value_name("MIME")
                    .possible_values(&["plain", "html"])
                    .default_value("plain"),
            )
            .arg(
                clap::Arg::with_name("raw")
                    .help("Reads raw message")
                    .long("raw")
                    .short("r"),
            ),
        clap::SubCommand::with_name("attachments")
            .aliases(&["attach", "att", "a"])
            .about("Downloads all message attachments")
            .arg(uid_arg()),
        clap::SubCommand::with_name("reply")
            .aliases(&["rep", "re"])
            .about("Answers to a message")
            .arg(uid_arg())
            .arg(reply_all_arg()),
        clap::SubCommand::with_name("forward")
            .aliases(&["fwd", "f"])
            .about("Forwards a message")
            .arg(uid_arg()),
        clap::SubCommand::with_name("copy")
            .aliases(&["cp", "c"])
            .about("Copies a message to the targetted mailbox")
            .arg(uid_arg())
            .arg(mbox_target_arg()),
        clap::SubCommand::with_name("move")
            .aliases(&["mv", "m"])
            .about("Moves a message to the targetted mailbox")
            .arg(uid_arg())
            .arg(mbox_target_arg()),
        clap::SubCommand::with_name("delete")
            .aliases(&["remove", "rm", "del", "d"])
            .about("Deletes a message")
            .arg(uid_arg()),
        clap::SubCommand::with_name("template")
            .aliases(&["tpl", "t"])
            .about("Generates a message template")
            .subcommand(
                clap::SubCommand::with_name("new")
                    .aliases(&["n"])
                    .about("Generates a new message template"),
            )
            .subcommand(
                clap::SubCommand::with_name("reply")
                    .aliases(&["rep", "r"])
                    .about("Generates a reply message template")
                    .arg(uid_arg())
                    .arg(reply_all_arg()),
            )
            .subcommand(
                clap::SubCommand::with_name("forward")
                    .aliases(&["fwd", "fw", "f"])
                    .about("Generates a forward message template")
                    .arg(uid_arg()),
            ),
    ]
}

pub fn msg_matches(app: &App) -> Result<bool> {
    if let Some(matches) = app.arg_matches.subcommand_matches("list") {
        debug!("list command matched");

        let page_size: usize = matches
            .value_of("page-size")
            .and_then(|s| s.parse().ok())
            .unwrap_or(app.config.default_page_size(&app.account));
        debug!("page size: {}", &page_size);
        let page: usize = matches
            .value_of("page")
            .unwrap()
            .parse()
            .unwrap_or_default();
        debug!("page: {}", &page);

        let mut imap_conn = ImapConnector::new(&app.account)?;
        let msgs = imap_conn.list_msgs(&app.mbox, &page_size, &page)?;
        let msgs = if let Some(ref fetches) = msgs {
            Msgs::from(fetches)
        } else {
            Msgs::new()
        };

        trace!("messages: {:?}", msgs);
        app.output.print(msgs);

        imap_conn.logout();
        return Ok(true);
    }

    if let Some(matches) = app.arg_matches.subcommand_matches("search") {
        debug!("search command matched");

        let page_size: usize = matches
            .value_of("page-size")
            .and_then(|s| s.parse().ok())
            .unwrap_or(app.config.default_page_size(&app.account));
        debug!("page size: {}", &page_size);
        let page: usize = matches
            .value_of("page")
            .unwrap()
            .parse()
            .unwrap_or_default();
        debug!("page: {}", &page);

        let query = matches
            .values_of("query")
            .unwrap_or_default()
            .fold((false, vec![]), |(escape, mut cmds), cmd| {
                match (cmd, escape) {
                    // Next command is an arg and needs to be escaped
                    ("subject", _) | ("body", _) | ("text", _) => {
                        cmds.push(cmd.to_string());
                        (true, cmds)
                    }
                    // Escaped arg commands
                    (_, true) => {
                        cmds.push(format!("\"{}\"", cmd));
                        (false, cmds)
                    }
                    // Regular commands
                    (_, false) => {
                        cmds.push(cmd.to_string());
                        (false, cmds)
                    }
                }
            })
            .1
            .join(" ");
        debug!("query: {}", &page);

        let mut imap_conn = ImapConnector::new(&app.account)?;
        let msgs = imap_conn.search_msgs(&app.mbox, &query, &page_size, &page)?;
        let msgs = if let Some(ref fetches) = msgs {
            Msgs::from(fetches)
        } else {
            Msgs::new()
        };
        trace!("messages: {:?}", msgs);
        app.output.print(msgs);

        imap_conn.logout();
        return Ok(true);
    }

    if let Some(matches) = app.arg_matches.subcommand_matches("read") {
        debug!("read command matched");

        let uid = matches.value_of("uid").unwrap();
        debug!("uid: {}", uid);
        let mime = format!("text/{}", matches.value_of("mime-type").unwrap());
        debug!("mime: {}", mime);
        let raw = matches.is_present("raw");
        debug!("raw: {}", raw);

        let mut imap_conn = ImapConnector::new(&app.account)?;
        let msg = imap_conn.read_msg(&app.mbox, &uid)?;
        if raw {
            let msg = String::from_utf8(msg)
                .chain_err(|| "Could not decode raw message as utf8 string")?;
            let msg = msg.trim_end_matches("\n");
            app.output.print(msg);
        } else {
            let msg = ReadableMsg::from_bytes(&mime, &msg)?;
            app.output.print(msg);
        }

        imap_conn.logout();
        return Ok(true);
    }

    if let Some(matches) = app.arg_matches.subcommand_matches("attachments") {
        debug!("attachments command matched");

        let uid = matches.value_of("uid").unwrap();
        debug!("uid: {}", &uid);

        let mut imap_conn = ImapConnector::new(&app.account)?;
        let msg = imap_conn.read_msg(&app.mbox, &uid)?;
        let attachments = Attachments::from_bytes(&msg)?;
        debug!(
            "{} attachment(s) found for message {}",
            &attachments.0.len(),
            &uid
        );
        for attachment in attachments.0.iter() {
            let filepath = app
                .config
                .downloads_filepath(&app.account, &attachment.filename);
            debug!("downloading {}…", &attachment.filename);
            fs::write(&filepath, &attachment.raw)
                .chain_err(|| format!("Could not save attachment {:?}", filepath))?;
        }

        debug!(
            "{} attachment(s) successfully downloaded",
            &attachments.0.len()
        );
        app.output.print(format!(
            "{} attachment(s) successfully downloaded",
            &attachments.0.len()
        ));

        imap_conn.logout();
        return Ok(true);
    }

    if let Some(matches) = app.arg_matches.subcommand_matches("write") {
        debug!("write command matched");

        let mut imap_conn = ImapConnector::new(&app.account)?;
        let attachments = matches
            .values_of("attachments")
            .unwrap_or_default()
            .map(String::from)
            .collect::<Vec<_>>();
        let tpl = Msg::build_new_tpl(&app.config, &app.account)?;
        let content = input::open_editor_with_tpl(tpl.to_string().as_bytes())?;
        let mut msg = Msg::from(content);
        msg.attachments = attachments;

        loop {
            match input::post_edit_choice() {
                Ok(choice) => match choice {
                    input::PostEditChoice::Send => {
                        debug!("sending message…");
                        let msg = msg.to_sendable_msg()?;
                        smtp::send(&app.account, &msg)?;
                        imap_conn.append_msg("Sent", &msg.formatted(), &[Flag::Seen])?;
                        input::remove_draft()?;
                        app.output.print("Message successfully sent");
                        break;
                    }
                    input::PostEditChoice::Edit => {
                        let content = input::open_editor_with_draft()?;
                        msg = Msg::from(content);
                    }
                    input::PostEditChoice::LocalDraft => break,
                    input::PostEditChoice::RemoteDraft => {
                        debug!("saving to draft…");
                        imap_conn.append_msg("Drafts", &msg.to_vec()?, &[Flag::Seen])?;
                        input::remove_draft()?;
                        app.output.print("Message successfully saved to Drafts");
                        break;
                    }
                    input::PostEditChoice::Discard => {
                        input::remove_draft()?;
                        break;
                    }
                },
                Err(err) => error!("{}", err),
            }
        }
        imap_conn.logout();
        return Ok(true);
    }

    if let Some(matches) = app.arg_matches.subcommand_matches("reply") {
        debug!("reply command matched");

        let uid = matches.value_of("uid").unwrap();
        debug!("uid: {}", uid);
        let attachments = matches
            .values_of("attachments")
            .unwrap_or_default()
            .map(String::from)
            .collect::<Vec<_>>();
        debug!("found {} attachments", attachments.len());
        trace!("attachments: {:?}", attachments);

        let mut imap_conn = ImapConnector::new(&app.account)?;
        let msg = Msg::from(imap_conn.read_msg(&app.mbox, &uid)?);
        let tpl = if matches.is_present("reply-all") {
            msg.build_reply_all_tpl(&app.config, &app.account)?
        } else {
            msg.build_reply_tpl(&app.config, &app.account)?
        };

        let content = input::open_editor_with_tpl(&tpl.to_string().as_bytes())?;
        let mut msg = Msg::from(content);
        msg.attachments = attachments;

        loop {
            match input::post_edit_choice() {
                Ok(choice) => match choice {
                    input::PostEditChoice::Send => {
                        debug!("sending message…");
                        let msg = msg.to_sendable_msg()?;
                        smtp::send(&app.account, &msg)?;
                        imap_conn.append_msg("Sent", &msg.formatted(), &[Flag::Seen])?;
                        imap_conn.add_flags(&app.mbox, uid, "\\Answered")?;
                        input::remove_draft()?;
                        app.output.print("Message successfully sent");
                        break;
                    }
                    input::PostEditChoice::Edit => {
                        let content = input::open_editor_with_draft()?;
                        msg = Msg::from(content);
                    }
                    input::PostEditChoice::LocalDraft => break,
                    input::PostEditChoice::RemoteDraft => {
                        debug!("saving to draft…");
                        imap_conn.append_msg("Drafts", &msg.to_vec()?, &[Flag::Seen])?;
                        input::remove_draft()?;
                        app.output.print("Message successfully saved to Drafts");
                        break;
                    }
                    input::PostEditChoice::Discard => {
                        input::remove_draft()?;
                        break;
                    }
                },
                Err(err) => error!("{}", err),
            }
        }

        imap_conn.logout();
        return Ok(true);
    }

    if let Some(matches) = app.arg_matches.subcommand_matches("forward") {
        debug!("forward command matched");

        let uid = matches.value_of("uid").unwrap();
        debug!("uid: {}", uid);
        let attachments = matches
            .values_of("attachments")
            .unwrap_or_default()
            .map(String::from)
            .collect::<Vec<_>>();
        debug!("found {} attachments", attachments.len());
        trace!("attachments: {:?}", attachments);

        let mut imap_conn = ImapConnector::new(&app.account)?;
        let msg = Msg::from(imap_conn.read_msg(&app.mbox, &uid)?);
        let tpl = msg.build_forward_tpl(&app.config, &app.account)?;
        let content = input::open_editor_with_tpl(&tpl.to_string().as_bytes())?;
        let mut msg = Msg::from(content);
        msg.attachments = attachments;

        loop {
            match input::post_edit_choice() {
                Ok(choice) => match choice {
                    input::PostEditChoice::Send => {
                        debug!("sending message…");
                        let msg = msg.to_sendable_msg()?;
                        smtp::send(&app.account, &msg)?;
                        imap_conn.append_msg("Sent", &msg.formatted(), &[Flag::Seen])?;
                        input::remove_draft()?;
                        app.output.print("Message successfully sent");
                        break;
                    }
                    input::PostEditChoice::Edit => {
                        let content = input::open_editor_with_draft()?;
                        msg = Msg::from(content);
                    }
                    input::PostEditChoice::LocalDraft => break,
                    input::PostEditChoice::RemoteDraft => {
                        debug!("saving to draft…");
                        imap_conn.append_msg("Drafts", &msg.to_vec()?, &[Flag::Seen])?;
                        input::remove_draft()?;
                        app.output.print("Message successfully saved to Drafts");
                        break;
                    }
                    input::PostEditChoice::Discard => {
                        input::remove_draft()?;
                        break;
                    }
                },
                Err(err) => error!("{}", err),
            }
        }

        imap_conn.logout();
        return Ok(true);
    }

    if let Some(matches) = app.arg_matches.subcommand_matches("template") {
        debug!("template command matched");

        if let Some(_) = matches.subcommand_matches("new") {
            debug!("new command matched");
            let tpl = Msg::build_new_tpl(&app.config, &app.account)?;
            trace!("tpl: {:?}", tpl);
            app.output.print(tpl);
        }

        if let Some(matches) = matches.subcommand_matches("reply") {
            debug!("reply command matched");

            let uid = matches.value_of("uid").unwrap();
            debug!("uid: {}", uid);

            let mut imap_conn = ImapConnector::new(&app.account)?;
            let msg = Msg::from(imap_conn.read_msg(&app.mbox, &uid)?);
            let tpl = if matches.is_present("reply-all") {
                msg.build_reply_all_tpl(&app.config, &app.account)?
            } else {
                msg.build_reply_tpl(&app.config, &app.account)?
            };
            trace!("tpl: {:?}", tpl);
            app.output.print(tpl);

            imap_conn.logout();
        }

        if let Some(matches) = matches.subcommand_matches("forward") {
            debug!("forward command matched");

            let uid = matches.value_of("uid").unwrap();
            debug!("uid: {}", uid);

            let mut imap_conn = ImapConnector::new(&app.account)?;
            let msg = Msg::from(imap_conn.read_msg(&app.mbox, &uid)?);
            let tpl = msg.build_forward_tpl(&app.config, &app.account)?;
            trace!("tpl: {:?}", tpl);
            app.output.print(tpl);

            imap_conn.logout();
        }

        return Ok(true);
    }

    if let Some(matches) = app.arg_matches.subcommand_matches("copy") {
        debug!("copy command matched");

        let uid = matches.value_of("uid").unwrap();
        debug!("uid: {}", &uid);
        let target = matches.value_of("target").unwrap();
        debug!("target: {}", &target);

        let mut imap_conn = ImapConnector::new(&app.account)?;
        let msg = Msg::from(imap_conn.read_msg(&app.mbox, &uid)?);
        let mut flags = msg.flags.deref().to_vec();
        flags.push(Flag::Seen);
        imap_conn.append_msg(target, &msg.raw, &flags)?;
        debug!("message {} successfully copied to folder `{}`", uid, target);
        app.output.print(format!(
            "Message {} successfully copied to folder `{}`",
            uid, target
        ));

        imap_conn.logout();
        return Ok(true);
    }

    if let Some(matches) = app.arg_matches.subcommand_matches("move") {
        debug!("move command matched");

        let uid = matches.value_of("uid").unwrap();
        debug!("uid: {}", &uid);
        let target = matches.value_of("target").unwrap();
        debug!("target: {}", &target);

        let mut imap_conn = ImapConnector::new(&app.account)?;
        let msg = Msg::from(imap_conn.read_msg(&app.mbox, &uid)?);
        let mut flags = msg.flags.deref().to_vec();
        flags.push(Flag::Seen);
        imap_conn.append_msg(target, &msg.raw, &flags)?;
        imap_conn.add_flags(&app.mbox, uid, "\\Seen \\Deleted")?;
        debug!("message {} successfully moved to folder `{}`", uid, target);
        app.output.print(format!(
            "Message {} successfully moved to folder `{}`",
            uid, target
        ));

        imap_conn.expunge(&app.mbox)?;
        imap_conn.logout();
        return Ok(true);
    }

    if let Some(matches) = app.arg_matches.subcommand_matches("delete") {
        debug!("delete command matched");

        let uid = matches.value_of("uid").unwrap();
        debug!("uid: {}", &uid);

        let mut imap_conn = ImapConnector::new(&app.account)?;
        imap_conn.add_flags(&app.mbox, uid, "\\Seen \\Deleted")?;
        debug!("message {} successfully deleted", uid);
        app.output
            .print(format!("Message {} successfully deleted", uid));

        imap_conn.expunge(&app.mbox)?;
        imap_conn.logout();
        return Ok(true);
    }

    if let Some(matches) = app.arg_matches.subcommand_matches("send") {
        debug!("send command matched");

        let mut imap_conn = ImapConnector::new(&app.account)?;

        let msg = if matches.is_present("message") {
            matches
                .value_of("message")
                .unwrap_or_default()
                .replace("\r", "")
                .replace("\n", "\r\n")
        } else {
            io::stdin()
                .lock()
                .lines()
                .filter_map(|ln| ln.ok())
                .map(|ln| ln.to_string())
                .collect::<Vec<_>>()
                .join("\r\n")
        };
        let msg = Msg::from(msg.to_string());
        let msg = msg.to_sendable_msg()?;
        smtp::send(&app.account, &msg)?;
        imap_conn.append_msg("Sent", &msg.formatted(), &[Flag::Seen])?;

        imap_conn.logout();
        return Ok(true);
    }

    if let Some(matches) = app.arg_matches.subcommand_matches("save") {
        debug!("save command matched");

        let mut imap_conn = ImapConnector::new(&app.account)?;
        let msg = matches.value_of("message").unwrap();
        let msg = Msg::from(msg.to_string());
        imap_conn.append_msg(&app.mbox, &msg.to_vec()?, &[Flag::Seen])?;

        imap_conn.logout();
        return Ok(true);
    }

    {
        debug!("default list command matched");

        let mut imap_conn = ImapConnector::new(&app.account)?;
        let msgs =
            imap_conn.list_msgs(&app.mbox, &app.config.default_page_size(&app.account), &0)?;
        let msgs = if let Some(ref fetches) = msgs {
            Msgs::from(fetches)
        } else {
            Msgs::new()
        };
        app.output.print(msgs);

        imap_conn.logout();
        Ok(true)
    }
}